diff --git a/.claude/memory/blockers.md b/.claude/memory/blockers.md index 83d8076..0137b63 100644 --- a/.claude/memory/blockers.md +++ b/.claude/memory/blockers.md @@ -52,6 +52,7 @@ rules: | BLK-030 | 2026-10-15 | model-router kept routing best-tier phases to Fable out of usage credits: each new session + each hold lapse lost a turn to 429 `model_requires_usage_credits`; breaker reactive only | resolved | | BLK-031 | 2026-10-16 | model-router: session starting on Fable w/o credits lost 1st turn + each hold lapse; probe skipped kept cur | resolved | | BLK-032 | 2026-10-19 | Main loop pinned on Fable in long sessions: session model Fable 1M + downgrade cap 120k + prompt rule `plan` → inline code on Fable xhigh; user routing policy recorded for next /feat | open | +| BLK-033 | 2026-10-21 | Guardrails residuals: probe trusted plan `supabase.url`, redirects free of budget, unread bodies read CLOSED, `str(URLError)` hid budget signal; rules 5 FP / 7 misses | resolved | --- @@ -334,3 +335,9 @@ rules: ## BLK-032 — Main loop pinned on Fable in long sessions: session model Fable 1M + downgrade cap 120k + prompt rule `plan` → inline code on Fable xhigh [open] - **Cause**: `~/.claude/settings.json` `"model": "claude-fable-5-1[1m]"` (every session starts on Fable); model-router never moves main above the session model, moves DOWN only under `downgradeMaxTokens` 120000 (LRN-204 cold read) → a long session (faunosteo R4.x, context > 120k) never reaches `implement`/sonnet; prompt rule `(plan|design|architecture…)` → phase plan = best/xhigh each turn ("plan §B.1.7"). No doctrine ceiling: CLAUDE.md allows inline work "doable in a few tool calls", BDR-115 "pin = default, never ceiling". - **User policy 2026-10-19**: session model Opus 5.5; sonnet writes, opus decides what to write; Fable only for orchestrator reflection/plans and the important audits (security, functional), other judges opus. → next `/feat`: settings model, `judge` split, ceiling rule in CLAUDE.md, BDR superseding part of BDR-066 / BDR-115. Links [[BDR-066]], [[BDR-107]], [[BDR-115]], [[LRN-204]]. + +## BLK-033 — Guardrails residuals: probe trusted plan `supabase.url`, redirects free of budget, unread bodies read CLOSED; rules 5 FP / 7 misses [resolved] +- **Friction**: GATE 2 of the a11y split (f586304) left a MEDIUM + 3 LOW on probe.py, opus review left Minors on the rules. Parked in TODO, fixed via `/bugfix` 2026-10-20/21. +- **Cause**: `supabase.url` read from the plan w/o `_http_url` → planted SUPABASE_URL would receive GUARDRAILS_ANON_KEY / JWT2, `file://` read CLOSED; `_SameHost` redirector followed hops w/o charging `session.budget`; `_rows_state` collapsed non-200 / empty / >1 MB / non-JSON into CLOSED (unobserved = CLOSED, breaks LRN-220); plan r2 mapped budget exhaustion on `str(URLError)`, which wraps the reason → never matched. Rules: SENSITIVE_KEY on metadata names (`token_type`, `has_password`), 403 on first map candidate stopped the walk, hydrated scan read whole route file, NOSQL `$where` fired on GraphQL `_bool_exp`; misses: Go backtick Sprintf, `rf`/triple-quoted f-strings, `sql|db|trx.raw`, empty `.select()`, multi-line hidden input, Rust `{}` shell arg, `"sources"` map head. +- **Solution**: 5a98c2c (`_BudgetExhausted(URLError)` + `BUDGET_EXHAUSTED` constant, `_SameHost(session)` charges per hop, `_rows_state` rows|empty|unreadable → SKIPPED, `_map_outcome` full candidate walk, `data:` OPEN w/o decoding, `printable` on remote strings, `_safe_text` in scanner, rule fixes + mutant per language variant) + 633faa2 (checks.md: `IN (…)` placeholder list flagged, judged by hand). Plan r3 after 2 challenge rounds, contract 22 oracles MET, verifier CONFORME, auditor PASS. Suites probe 84, scan 241. +- **Residual** (LOW, parked in TODO): table names not `IDENT.fullmatch`-checked per table (`/` → path walk on the approved host); `printable` lets Unicode bidi/format controls through. Links [[LRN-219]], [[LRN-220]], [[LRN-222]], [[LRN-223]]. diff --git a/.claude/memory/journal.md b/.claude/memory/journal.md index 1053e89..7db4d40 100644 --- a/.claude/memory/journal.md +++ b/.claude/memory/journal.md @@ -629,3 +629,7 @@ rules: ## 2026-10-19 - Guardrails split shipped via /ship-feature (feature/a11y-split-inj-exp): /a11y skill on the shared engine, injection + exposure domains, probe exposure block, secure-by-default six domains. SDD 9 tasks, GATE 1 ECARTS(9)→CONFORME (fields CLOSED route, suppressions removed), GATE 2 PASS (7 LOW), opus review 0 Critical / 6 Important fixed. Routing finding: Fable pinned in long sessions (BLK-032), user policy recorded for a later /feat. Merge on user go. + +## 2026-10-21 +- /prune-memory: learnings.md index backfilled LRN-191..218 (28 rows), c7ebc3d on chore/prune-learnings-index. Index 221 rows = 221 entries. +- /bugfix guardrails residuals (bugfix/guardrails-residuals): plan r3 after 2 challenge rounds (4 BLOCKERs r1: WARN severity, budget must raise, three-way SKIPPED, vacuous timing; r2: `str(URLError)` wrap), contract 22 oracles, 3 part executors, GATE 0/1/2 green, 5a98c2c + 633faa2 (checks.md IN() wording caught by doc-syncer, not the gates). BLK-033, LRN-222/223. Two LOW parked. Both branches await merge signal. Next: /feat routing policy (BLK-032). diff --git a/.claude/memory/learnings.md b/.claude/memory/learnings.md index 112892b..abbc1a8 100644 --- a/.claude/memory/learnings.md +++ b/.claude/memory/learnings.md @@ -213,6 +213,8 @@ rules: | LRN-219 | 2026-10-19 | Scanner regex over untrusted trees: bound every repeat, cap comment blankers, timing lock on adversarial file | any whole-file regex scanner | | LRN-220 | 2026-10-19 | Live probe verdicts fail closed by construction: fixture route per negative branch, 3xx = SKIPPED, depth/size limit = SKIPPED never CLOSED | writing probes and their suites | | LRN-221 | 2026-10-19 | Floor-guard suppressions: remove, never waive; contract CHECK asserts intent (symbol/behaviour), not one code spelling | suppressions, writing CHECK: lines | +| LRN-222 | 2026-10-21 | Map an error to a verdict on a typed exception or carried constant, never on `str(err)`: URLError wraps its reason | probe/fetch error mapping, any err→verdict code | +| LRN-223 | 2026-10-21 | Regex timing lock is vacuous when the input matches early: feed a non-matching worst-path input, assert `is None`, keep ≥ 2x margin under the lock | every bounded regex test | --- @@ -1828,3 +1830,11 @@ Rule: when editing a doctrine file under structure locks, grep the test's lock s ## LRN-221 — Floor-guard suppressions: remove, never waive; contract oracles assert intent, not syntax - **Context**: GATE 1 counted 6 floor findings: `# noqa: E402` ×2 (import after `sys.path.insert`), a `# shellcheck disable=SC2016` copied from another suite (dead: deleting it raised nothing), 3 plan quotes of the same lines. `importlib.import_module` after the insert needs no noqa. Then criterion 16's CHECK grepped `^import scanner` and went red on the legit fix. - **Apply**: a suppression = first try the construct that needs none; test a copied `disable` by deleting it; a CHECK greps the symbol or behaviour (`scanner.Catalogue` loaded), never one spelling of the code. Links [[BDR-102]]. + +## LRN-222 — Map an error to a verdict on a typed exception or carried constant, never on `str(err)` +- **Context**: guardrails residuals plan r2 detected budget exhaustion by `BUDGET_EXHAUSTED in str(err)`; `URLError` renders as `` and wraps the reason object, so the match never fired and the verdict stayed SKIPPED instead of ERROR. Challenger (correctness lens) caught it as BLOCKER before the contract. Fix: `_BudgetExhausted(URLError)` subclass carrying the constant, mapper uses `isinstance`, regression test raises the real type. +- **Apply**: err→verdict code matches on type or an attribute the raiser sets; the test raises the real exception class through the real call path, never a hand-built message. Links [[LRN-220]], [[BLK-033]]. + +## LRN-223 — Regex timing lock is vacuous when the input matches early: non-matching worst-path input, assert `is None`, ≥ 2x margin +- **Context**: plan r1 timing cases (LRN-219 lock, 1.0 s / 80 KB) fed inputs the bounded regex matched at the start, so they ran fast by construction and proved nothing (challenger BLOCKER, robustness lens). r3: inputs built to force the longest non-matching scan, cases assert `is None` and the elapsed time; SHELL_DB case at 0.65 s was too close to the lock → 1800 units (~29 KB) for margin. +- **Apply**: one timing case per bounded regex, input that does NOT match and exercises the widest quantifier; assert the non-match too, else a regex that matches everything passes the lock; keep elapsed ≤ half the lock. Links [[LRN-219]], [[BLK-033]]. diff --git a/.claude/tasks/TODO.md b/.claude/tasks/TODO.md index 655895d..1ddc8a7 100644 --- a/.claude/tasks/TODO.md +++ b/.claude/tasks/TODO.md @@ -2,8 +2,8 @@ ## 2026-10-19 — guardrails split: /a11y + injection/exposure (feature/a11y-split-inj-exp) - [x] run — SDD 9/9, gates 0/1/2 green, opus review Importants fixed (c0fdbec, 9275e0d, 63a88bc), capitalize BDR-122 LRN-219..221 BLK-032; merge = user go -- [ ] parked (review Minors): SENSITIVE_KEY matches metadata names (`token_type`, `has_password`, `next_page_token` locked as sensitive); 403 on first map candidate → SKIPPED before header/comment candidates (S3/CloudFront); EXP-HYDRATED-SENSITIVE scans whole route file (Remix/SvelteKit actions); `webpack.dev.js` WARN; `data-password-toggle` WARN; GraphQL `$where: users_bool_exp` → INJ-NOSQL-OPERATOR; misses: Go raw-string Sprintf, Drizzle `sql.raw`, `db.raw`, `rf""`, Supabase `.select()` no arg, multi-line JSX hidden input, triple-quoted f-strings; `IN (${placeholders})` = FAIL (name in judging step); timing lock skips CONCAT (~2.6 s/1 MB); per-language variants without mutant; SKILL.md:96 fields bearer JWT2; large `.map` head misses esbuild/rollup (`"version":3`); URL-encoded `data:` maps. -- [ ] parked (GATE 2 non-blocking, pre-existing on develop): probe `supabase.url` not validated by `_http_url` nor shown in the `--authorized` refusal (MEDIUM, probe.py:168,194: planted SUPABASE_URL would receive the test JWT; `file://` reads CLOSED); same-host redirects not counted in `session.budget` (LOW); `_nonempty_rows` catches ValueError only, deep JSON → RecursionError exit 1 (LOW); scanner text output prints `f.path` / `project.root` without `_printable` (LOW). +- [x] parked review Minors + GATE 2 residuals (probe `supabase.url`, redirects, `_nonempty_rows`, printable) → /bugfix 2026-10-21, 5a98c2c + 633faa2, BLK-033 +- [ ] parked (GATE 2 LOW, 5a98c2c): probe table names not checked with `IDENT.fullmatch` per table (a `/` walks a path on the approved Supabase host); `printable` lets Unicode bidi/format controls (U+202E, U+2066…) through to the tty - [ ] routing policy /feat (user 2026-10-19, BLK-032): settings model → Opus 5.5; `judge` split (security-auditor + verifier → Fable, plan-challenger/analyzer/code review → opus); executors stay sonnet, "what to write" on opus; ceiling rule: main on Fable never writes code beyond a hotfix edit → dispatched executor; BDR superseding part of BDR-066 / BDR-115. ## 2026-10-18 — secure-by-default guardrails: 5 domains + /guardrails skill (feature/secure-by-default) diff --git a/.claude/tasks/contracts/2026-10-20-guardrails-residuals-1455.md b/.claude/tasks/contracts/2026-10-20-guardrails-residuals-1455.md new file mode 100644 index 0000000..a010311 --- /dev/null +++ b/.claude/tasks/contracts/2026-10-20-guardrails-residuals-1455.md @@ -0,0 +1,136 @@ +# CONTRACT — guardrails-residuals +- date: 2026-10-20 | flow: bugfix | branch: develop (bugfix branch at STEP 4) +- status: active +- plan: .claude/tasks/plans/2026-10-20-guardrails-residuals-1410.md (r3, challenged twice) + +## REQUEST (verbatim — IMMUTABLE) +User message (typed): "corrige tout les 4 points qui tu as souligne" — point 1 = the MEDIUM +of the security gate (probe `supabase.url` unvalidated) and point 2 = the parked +review Minors and the 4 LOW, both in `.claude/tasks/TODO.md` lines 5-6. + +Skill arguments ($ARGUMENTS to /bugfix): +"Guardrails residuals parked in .claude/tasks/TODO.md lines 5-6 after the a11y split merge (f586304). Fix all of them: (1) probe.py `supabase.url` validated through `_http_url` and echoed next to base_url in the `--authorized` refusal (planted SUPABASE_URL would receive GUARDRAILS_ANON_KEY / GUARDRAILS_JWT2; `file://` reads CLOSED); same-host redirects counted against `session.budget`; `_nonempty_rows` catches RecursionError like `_json_body`; scanner.py text output passes `f.path` and `project.root` through a printable filter. (2) review Minors: SENSITIVE_KEY false positives on metadata names (`token_type`, `has_password`, `next_page_token`); 403 on the first map candidate must not stop before header/comment candidates; EXP-HYDRATED-SENSITIVE scoped to the loader/getServerSideProps return, not the whole route file; `webpack.dev.js` and `data-password-toggle` stay silent; GraphQL `$where: users_bool_exp` not INJ-NOSQL-OPERATOR; misses to cover: Go raw-string Sprintf, Drizzle `sql.raw`, `db.raw`, Python `rf""`, Supabase `.select()` with no arg, multi-line JSX hidden input, triple-quoted f-strings; `IN (${placeholders})` named in checks.md judging step; timing lock also covers CONCAT; a mutant per language variant; SKILL.md:96 fields example with bearer JWT2; large `.map` head detection for esbuild/rollup (`"version":3`); URL-encoded `data:` source maps. Suites: lib/tests/guardrails-scan.test.sh, guardrails-probe.test.sh, a11y-scan.test.sh via make test. Working tree has two pre-existing uncommitted files (mods/model-router/routing.json, settings.json) that are not part of this task and must never be staged." + +## CLARIFICATIONS +Pass B (STEP 3, 2026-10-20, AskUserQuestion): plan approved; B1 full METADATA_KEY list +(`next_page_token` stops being reported); webpack dev configs and UI-suffixed data-* +names silent with benign locks; no new CLI flag. [gated 2026-10-20] +Analyzer corrections accepted: B12's real miss is the key order of rollup maps (the +`"mappings"` key after `sourcesContent`), not a `"version":3` test; B13 base64 form +was already OPEN, the percent-encoded form was the miss. The judging step named in +the request lives in SKILL.md (checks.md has none): the bullet goes there, the +by-design line in checks.md is amended. +Challenge rulings (r1, r2): a line-start `data:` sourceMappingURL directive is OPEN +whatever its encoding (no decoding); budget exhaustion is one constant +`BUDGET_EXHAUSTED` mapped in `fetch`; hydrated scope = export chunks; triple-quoted +f-strings = STMT-anchored alternative; timing cases assert non-match at ≈ 80 KB. +Executor rulings (Part 1, 2026-10-20): METADATA_KEY alternation `expires?(?:_in)?` so `token_expires_in` is metadata (plan regex missed it); oracle 12 wrapped in a subshell (orchestrator oracle defect). [gated 2026-10-20] +Executor rulings (Part 2, 2026-10-20): oracle 17 gains an `index.js` (a lone .map leaves the exposure domain not applicable, orchestrator oracle defect); SKILL.md Part 1 sentence reworded "Before adding `--authorized`" to match criterion 20's grep; oracle 15 negative grep narrowed to the INJ-NOSQL-OPERATOR row (g.ts under src/api also raises API-ROUTE-NO-AUTH, orchestrator oracle defect). +Severities never change: INJ-NOSQL-OPERATOR WARN, INJ-SQL-CONCAT FAIL, INJ-SQL-RAW-UNSAFE WARN. + +## ACCEPTANCE CRITERIA +1. Probe suite green. + CHECK: make test suite=lib/tests/guardrails-probe.test.sh >/dev/null 2>&1 && echo PT-GREEN + EXPECT: PT-GREEN + EVIDENCE: MET exit=0 marker-found :: PT-GREEN +2. Scan suite green. + CHECK: make test suite=lib/tests/guardrails-scan.test.sh >/dev/null 2>&1 && echo ST-GREEN + EXPECT: ST-GREEN + EVIDENCE: MET exit=0 marker-found :: ST-GREEN +3. a11y suite green untouched (shared engine). + CHECK: make test suite=lib/tests/a11y-scan.test.sh >/dev/null 2>&1 && git diff --quiet develop -- lib/tests/a11y-scan.test.sh && echo A11Y-GREEN + EXPECT: A11Y-GREEN + EVIDENCE: MET exit=0 marker-found :: A11Y-GREEN +4. Full suite and shellcheck green. + CHECK: make test >/dev/null 2>&1 && shellcheck *.sh hooks/*.sh lib/*.sh && echo ALL-GREEN + EXPECT: ALL-GREEN + EVIDENCE: MET exit=0 marker-found :: ALL-GREEN +5. A1: a non-http(s) `supabase.url` is a usage error (exit 2) naming it; tables without a url is a usage error too; no traceback. + CHECK: p=$(mktemp); printf '{"base_url":"http://127.0.0.1:9","supabase":{"url":"file:///etc/hosts","tables":["t"]}}' > "$p"; python3 -B skills/guardrails/scripts/probe.py "$p" --authorized >/dev/null 2>"$p.err"; rc=$?; q=$(mktemp); printf '{"base_url":"http://127.0.0.1:9","supabase":{"tables":["t"]}}' > "$q"; python3 -B skills/guardrails/scripts/probe.py "$q" --authorized >/dev/null 2>"$q.err"; rc2=$?; [ "$rc" -eq 2 ] && [ "$rc2" -eq 2 ] && grep -q 'supabase.url must be an http(s) url' "$p.err" && ! grep -q Traceback "$q.err" && echo A1-URL-GUARDED + EXPECT: A1-URL-GUARDED + EVIDENCE: MET exit=0 marker-found :: A1-URL-GUARDED +6. A1: the refusal names the Supabase url next to base_url, control characters replaced. + CHECK: p=$(mktemp); printf '{"base_url":"http://127.0.0.1:9","supabase":{"url":"https://a.test/\\u001b[2J","tables":["t"]}}' > "$p"; python3 -B skills/guardrails/scripts/probe.py "$p" 2>&1 | grep -q 'confirm you own http://127.0.0.1:9 and https://a.test/?\[2J' && echo A1-REFUSAL-BOTH + EXPECT: A1-REFUSAL-BOTH + EVIDENCE: MET exit=0 marker-found :: A1-REFUSAL-BOTH +7. A2: budget exhaustion is one constant reported by `fetch`, before and inside a redirect. + CHECK: cd skills/guardrails/scripts && python3 -B -c 'import probe; s=probe.Session(budget=0); r=probe.fetch(s,"GET","http://127.0.0.1:9/"); assert r.error==probe.BUDGET_EXHAUSTED, r.error; assert issubclass(probe._BudgetExhausted, Exception); import inspect; assert "session" in inspect.signature(probe._SameHost.__init__).parameters; print("A2-BUDGET-CONST")' + EXPECT: A2-BUDGET-CONST + EVIDENCE: MET exit=0 marker-found :: A2-BUDGET-CONST +8. A2: a redirect chain is charged per hop and an exhausted budget mid-chain reads ERROR on a route probe (locked in the probe suite). + CHECK: grep -q 'DEFAULT_BUDGET - 3' lib/tests/guardrails-probe.test.sh && grep -q 'budget=2' lib/tests/guardrails-probe.test.sh && grep -q '/hop1' lib/tests/guardrails-probe.test.sh && echo A2-HOPS-LOCKED + EXPECT: A2-HOPS-LOCKED + EVIDENCE: MET exit=0 marker-found :: A2-HOPS-LOCKED +9. A3: a 200 body the probe cannot read as JSON rows is `unreadable` (→ SKIPPED), an empty list is `empty`, rows are `rows`. + CHECK: cd skills/guardrails/scripts && python3 -B -c 'import probe; R=probe.Response; print(probe._rows_state(R(200,{},b"["*200000)), probe._rows_state(R(200,{},b"[]")), probe._rows_state(R(200,{},b"[{\"a\":1}]")))' | grep -q '^unreadable empty rows$' && echo A3-THREE-WAY + EXPECT: A3-THREE-WAY + EVIDENCE: MET exit=0 marker-found :: A3-THREE-WAY +10. A4: the scanner's text output never carries control characters, in the report, the check-mode rows and the usage error, while the finding still raises. + CHECK: d=$(mktemp -d); mkdir -p "$d/src/components"; f="$d/src/components/$(printf 'x\033[31m').tsx"; printf 'export default function X({user}){ console.log(user); return null }\n' > "$f"; o=$(python3 -B skills/guardrails/scripts/scan.py "$d" 2>&1); a=$(python3 -B skills/guardrails/scripts/scan.py "$d" --assert-absent "EXP-CONSOLE-DATA:src/components/$(printf 'x\033[31m').tsx" 2>&1); printf '%s\n%s\n' "$o" "$a" | grep -q 'EXP-CONSOLE-DATA' && [ "$(printf '%s%s' "$o" "$a" | grep -c $'\033')" -eq 0 ] && printf '%s\n' "$a" | grep -q 'PRESENT' && echo A4-PRINTABLE + EXPECT: A4-PRINTABLE + EVIDENCE: MET exit=0 marker-found :: A4-PRINTABLE +11. B1: metadata keys are never sensitive, matched after snake-casing; real secrets still are. + CHECK: cd skills/guardrails/scripts && python3 -B -c 'import probe; m=lambda k: bool(probe.METADATA_KEY.search(probe._snake(k))); assert all(m(k) for k in ["tokenType","has_password","next_page_token","token_expires_in","password_changed_at","csrf_token"]); assert not any(m(k) for k in ["password_hash","api_key","access_token","secret"]); print("B1-METADATA")' + EXPECT: B1-METADATA + EVIDENCE: MET exit=0 marker-found :: B1-METADATA +12. B2/B13: every map candidate is examined; a line-start `data:` directive is OPEN without decoding; an unconfirmed status is a note, never a negative. + CHECK: (cd skills/guardrails/scripts && python3 -B -c 'import probe; s=probe.Session(budget=0); k=lambda u: probe._map_outcome(s,"http://h.test/a.js",u)[0]; assert k("data:application/json,%7B%22version%22%3A3%7D")=="open"; assert k("data:application/json;base64,eyJ2ZXJzaW9uIjozfQ==")=="open"; assert k("https://cdn.invalid/a.js.map")=="note"; print("B2-OUTCOMES")') && grep -q 'forbidden-real' lib/tests/guardrails-probe.test.sh && grep -q 'limited.js' lib/tests/guardrails-probe.test.sh && echo B2-WALK-LOCKED + EXPECT: B2-WALK-LOCKED + EVIDENCE: MET exit=0 marker-found :: B2-OUTCOMES B2-WALK-LOCKED +13. B3: hydrated scope is the export chunk of the loader: a Remix action after a clean loader is silent, a one-line loader returning a token raises. + CHECK: d=$(mktemp -d); mkdir -p "$d/app/routes"; printf 'export async function loader() {\n return json({ ok: true });\n}\nexport async function action({ request }) {\n const form = await request.formData();\n return json({ password: form.get("password") });\n}\n' > "$d/app/routes/a.tsx"; printf 'export const loader = () => json({ token: t });\n' > "$d/app/routes/b.tsx"; o=$(python3 -B skills/guardrails/scripts/scan.py "$d" --json 2>/dev/null); printf '%s' "$o" | grep -q 'EXP-HYDRATED-SENSITIVE' && ! printf '%s' "$o" | grep -q 'routes/a.tsx' && echo B3-CHUNK-SCOPED + EXPECT: B3-CHUNK-SCOPED + EVIDENCE: MET exit=0 marker-found :: B3-CHUNK-SCOPED +14. B4/B5: a webpack dev config and a UI-suffixed data attribute are silent; a prod config and a value-carrying attribute still raise. + CHECK: d=$(mktemp -d); mkdir -p "$d/src/components"; printf 'module.exports = { devtool: "eval-source-map" };\n' > "$d/webpack.dev.js"; printf 'module.exports = { devtool: "source-map" };\n' > "$d/webpack.prod.js"; printf 'export const A = () =>
;\n' > "$d/src/components/A.tsx"; o=$(python3 -B skills/guardrails/scripts/scan.py "$d" 2>/dev/null); printf '%s\n' "$o" | grep -q 'EXP-SOURCEMAP-PUBLIC *webpack.prod.js' && ! printf '%s\n' "$o" | grep -q 'webpack.dev.js' && [ "$(printf '%s\n' "$o" | grep -c 'EXP-DATA-ATTR-SENSITIVE')" -eq 1 ] && echo B4-B5-SILENT + EXPECT: B4-B5-SILENT + EVIDENCE: MET exit=0 marker-found :: B4-B5-SILENT +15. B6: `$where` with a string, an identifier or a call is WARN INJ-NOSQL-OPERATOR; a GraphQL `_bool_exp` type is silent. + CHECK: d=$(mktemp -d); mkdir -p "$d/src/api"; printf 'db.find({ $where: clause });\ndb.find({ $where: buildWhere(req.query) });\n' > "$d/src/api/m.ts"; printf 'const q = gql`query($where: users_bool_exp) { users(where: $where) { id } }`;\n' > "$d/src/api/g.ts"; o=$(python3 -B skills/guardrails/scripts/scan.py "$d" 2>/dev/null); [ "$(printf '%s\n' "$o" | grep -c 'WARN *INJ-NOSQL-OPERATOR *src/api/m.ts')" -eq 2 ] && ! printf '%s\n' "$o" | grep -q 'INJ-NOSQL-OPERATOR *src/api/g.ts' && echo B6-WHERE + EXPECT: B6-WHERE + EVIDENCE: MET exit=0 marker-found :: B6-WHERE +16. B7: Go backtick Sprintf, a multi-line triple-quoted f-string, `sql.raw(var)`, `.select()` on users and a multi-line hidden input all raise. + CHECK: d=$(mktemp -d); mkdir -p "$d/src/api" "$d/src/components"; printf 'package a\nfunc q(o string) string { return fmt.Sprintf(`select id from notes where owner = %%s`, o) }\n' > "$d/src/api/a.go"; printf 'def q(owner):\n return f"""\n select id from notes\n where owner = {owner}\n """\n' > "$d/src/api/b.py"; printf 'export const r = (w) => db.execute(sql.raw(w));\nexport const u = () => supabase.from("users").select();\n' > "$d/src/api/c.ts"; printf 'export const F = () => (\n \n);\n' > "$d/src/components/F.tsx"; o=$(python3 -B skills/guardrails/scripts/scan.py "$d" 2>/dev/null); printf '%s\n' "$o" | grep -q 'FAIL *INJ-SQL-CONCAT *src/api/a.go' && printf '%s\n' "$o" | grep -q 'FAIL *INJ-SQL-CONCAT *src/api/b.py' && printf '%s\n' "$o" | grep -q 'WARN *INJ-SQL-RAW-UNSAFE *src/api/c.ts' && printf '%s\n' "$o" | grep -q 'EXP-RESPONSE-WIDE *src/api/c.ts' && printf '%s\n' "$o" | grep -q 'EXP-DATA-ATTR-SENSITIVE *src/components/F.tsx' && echo B7-MISSES-COVERED + EXPECT: B7-MISSES-COVERED + EVIDENCE: MET exit=0 marker-found :: B7-MISSES-COVERED +17. B12: a public map over 1 MB in rollup key order (mappings last) is FAIL. + CHECK: d=$(mktemp -d); mkdir -p "$d/public"; printf 'export const a = 1;\n' > "$d/index.js"; { printf '{"version":3,"file":"app.js","sources":["a.ts"],"sourcesContent":["'; head -c 1100000 /dev/zero | tr '\0' 'x'; printf '"],"names":[],"mappings":"AAAA"}'; } > "$d/public/app.js.map"; python3 -B skills/guardrails/scripts/scan.py "$d" 2>/dev/null | grep -q 'FAIL *EXP-SOURCEMAP-PUBLIC *public/app.js.map' && echo B12-ROLLUP-MAP + EXPECT: B12-ROLLUP-MAP + EVIDENCE: MET exit=0 marker-found :: B12-ROLLUP-MAP +18. B9: the timing lock covers the CONCAT alternatives, NOSQL and HIDDEN_INPUT with non-matching inputs. + CHECK: awk '/== regex timing/,/REGEX-FAST/' lib/tests/guardrails-scan.test.sh > /tmp/timing-block.$$; grep -q 'injection.CONCAT' /tmp/timing-block.$$ && grep -q 'injection.NOSQL' /tmp/timing-block.$$ && grep -q 'exposure.HIDDEN_INPUT' /tmp/timing-block.$$ && grep -q 'is None' /tmp/timing-block.$$ && grep -q 'export const load' /tmp/timing-block.$$ && rm -f /tmp/timing-block.$$ && echo B9-TIMING-COVERS + EXPECT: B9-TIMING-COVERS + EVIDENCE: MET exit=0 marker-found :: B9-TIMING-COVERS +19. B10: per-variant locks exist (routing-dependent mutants plus the sub-pattern table). + CHECK: grep -q '== per-variant' lib/tests/guardrails-scan.test.sh && [ "$(grep -c '^mutant ' lib/tests/guardrails-scan.test.sh)" -ge 100 ] && grep -q 'Command::new' lib/tests/guardrails-scan.test.sh && grep -q 'getTraceAsString' lib/tests/guardrails-scan.test.sh && echo B10-VARIANTS + EXPECT: B10-VARIANTS + EVIDENCE: MET exit=0 marker-found :: B10-VARIANTS +20. B8/B11 docs: the judging bullet, the RAW receivers, the metadata exclusion, the data: wording, the bearer sentence and the both-hosts step are in the skill docs. + CHECK: grep -q 'placeholders' skills/guardrails/SKILL.md && grep -q 'logged-in user sees' skills/guardrails/SKILL.md && grep -qi 'before adding `--authorized`' skills/guardrails/SKILL.md && grep -q '`--json` output' skills/guardrails/SKILL.md && grep -q 'sql.raw' skills/guardrails/references/checks.md && grep -q '_bool_exp' skills/guardrails/references/checks.md && grep -qi 'metadata' skills/guardrails/references/checks.md && grep -q 'exhausted budget' skills/guardrails/references/checks.md && echo DOCS-SYNCED + EXPECT: DOCS-SYNCED + EVIDENCE: MET exit=0 marker-found :: DOCS-SYNCED +21. Pre-existing dirty files never staged or committed. + CHECK: ! git diff --cached --name-only | grep -Eq '^(settings.json|mods/model-router/routing.json)$' && [ -z "$(git log --oneline develop..HEAD -- settings.json mods/model-router/routing.json)" ] && echo DIRTY-UNTOUCHED + EXPECT: DIRTY-UNTOUCHED + EVIDENCE: MET exit=0 marker-found :: DIRTY-UNTOUCHED +22. No new lint or test suppression in the diff (floor-guard clean). + CHECK: bash lib/floor-guard.sh develop -- . >/dev/null 2>&1 && echo FLOOR-CLEAN + EXPECT: FLOOR-CLEAN + EVIDENCE: MET exit=0 marker-found :: FLOOR-CLEAN + +## FILE SCOPE +skills/guardrails/scripts/probe.py +skills/guardrails/scripts/scanner.py +skills/guardrails/scripts/checks/common.py +skills/guardrails/scripts/checks/exposure.py +skills/guardrails/scripts/checks/injection.py +skills/guardrails/references/checks.md +skills/guardrails/SKILL.md +lib/tests/guardrails-scan.test.sh +lib/tests/guardrails-probe.test.sh +.claude/tasks/plans/2026-10-20-guardrails-residuals-1410.md +.claude/tasks/contracts/2026-10-20-guardrails-residuals-1455.md +.claude/tasks/TODO.md +.claude/tasks/plans/2026-10-20-guardrails-residuals-part1-report.md [gated 2026-10-20: executor report, orchestrator artifact] +.claude/tasks/plans/2026-10-20-guardrails-residuals-part2-report.md [gated 2026-10-20: executor report, orchestrator artifact] +.claude/tasks/plans/2026-10-20-guardrails-residuals-part3-report.md [gated 2026-10-20: executor report, orchestrator artifact] diff --git a/.claude/tasks/plans/2026-10-20-guardrails-residuals-1410.md b/.claude/tasks/plans/2026-10-20-guardrails-residuals-1410.md new file mode 100644 index 0000000..1e042b0 --- /dev/null +++ b/.claude/tasks/plans/2026-10-20-guardrails-residuals-1410.md @@ -0,0 +1,244 @@ +# FIX PLAN r3 — guardrails residuals after the a11y split (TODO.md lines 5-6) + +Base: develop f586304. Analysis: scratchpad `bugfix-analysis.md` (analyzer, read-only). +r1 and r2 challenged by three lenses each; r3 closes every r2 BLOCKER/MAJOR by +a named change (see "Challenge log"). No further challenge round (lib: one +re-challenge); residual MINORs are listed as blind spots in checks.md. + +Three executor parts, split by file, sequential on the same branch. Every rule +change ships a mutant (raises); every false-positive fix and every regex +widening ships a benign lock (stays silent); every new or widened repeat ships +a timing case that asserts BOTH `search(text) is None` AND < 1.0 s, sized to +about 0.2 s on this machine (5x margin). Suites: `make test suite=lib/tests/guardrails-probe.test.sh` +(PT), `make test suite=lib/tests/guardrails-scan.test.sh` (ST), full `make test` +once at the end. Rule ids, severities and exit codes never change (BDR-121): +INJ-NOSQL-OPERATOR WARN, INJ-SQL-CONCAT FAIL, INJ-SQL-RAW-UNSAFE WARN. +Shell suites: portable idioms only (`edit()` helper, no `sed -i`, BDR-110). + +Shared helper, written in Part 1, reused in Part 2 — `checks/common.py`: +```python +def printable(text): + """Control characters of a remote string, path or message never reach the tty.""" + return re.sub(r"[\x00-\x1f\x7f-\x9f\udc80-\udcff]", "?", str(text)) +``` +probe.py deletes `_printable` and does `from checks.common import printable` +(probe.py runs from `scripts/`, the package resolves like scan.py's import). + +## Part 1 — probe.py + lib/tests/guardrails-probe.test.sh + +A1 `_shape_error`: whenever `supabase` has `tables` or `cross_user_paths`, an +http(s) `url` is required (`"supabase.url must be an http(s) url"`) and +`tables`, when present, must be a list of strings +(`"supabase.tables must be a list of strings"`). `main`: the refusal prints both +urls through `printable` (`refused: pass --authorized to confirm you own and and may probe them`, +the "and …" part only when supabase.url is set); the `usage error:` line goes +through `printable` too. PT: `file:///etc/hosts` url → exit 2 + message; tables +without url → exit 2, no traceback; `"tables": "notes"` → exit 2; refusal on a +supabase url holding an ESC byte → `?` shown, 0 ESC bytes in stderr. +`skills/guardrails/SKILL.md` STEP 5 "Run it" (line ~97): before adding +`--authorized`, show the user the two hosts the plan names (base_url and the +Supabase url, the latter taken from the project's config and therefore +untrusted) and get their go on both; one sentence, single line (loops-light +locks STEP 9-11 strings only). + +A2 budget on redirects. probe.py defines +`BUDGET_EXHAUSTED = "request budget exhausted"` and +`class _BudgetExhausted(urllib.error.URLError)`. `_SameHost(session)`: +`Session.__init__` builds `build_opener(_SameHost(self))`; `redirect_request`: +off-host → None (unchanged); `self.session.budget <= 0` → +`raise _BudgetExhausted(BUDGET_EXHAUSTED)`; else decrement and delegate. +`fetch`: the pre-check returns `Response(None, {}, b"", BUDGET_EXHAUSTED)`; +`except _BudgetExhausted` (before the URLError clause) returns the same. So the +error string is one constant everywhere. `_rate_verdict`: when fewer than the +requested count were answered and no 429 was seen → SKIPPED +`"burst cut short (budget or transport), rate limit not confirmed"`, never OPEN. +PT: fixture routes `/hop1` → 302 `/hop2` → 302 `/hop3` → 200 `{"ok": true}`. +Python block on the PT `same_host` pattern (~378-383): `Session()` + +`fetch(s, "GET", BASE + "/hop1")` → status 200 and `s.budget == DEFAULT_BUDGET - 3`; +`Session(budget=2)` + same fetch → `error == probe.BUDGET_EXHAUSTED`; and +`_route_probe(Session(budget=2), BASE, {"path": "/hop1"})` → verdict ERROR. +No new plan file, nothing added to `plan.json`. + +A3 rows state. `_verdict` keeps handling the transport error first (ERROR). For +`_table_probe` and `_cross_user_probe`: status 200 → three-way +`_rows_state(resp)` through `_json_body`: `[]` or a non-list JSON → `empty` +(CLOSED, notes unchanged); a non-empty list → `rows` (OPEN); parse failure +(RecursionError, ValueError, empty body, truncated at BODY_CAP) → `unreadable` +→ SKIPPED `f"HTTP {resp.status}: body not readable as JSON rows, not confirmed"`. +Status 401/403/404 → CLOSED as today; any other non-200 → SKIPPED +`f"HTTP {resp.status}: not confirmed"`. PT: fixture route `/rest/v1/deep` +answering 200 with `b"[" * 200000`; plan `deep.json` with +`"supabase": {"url": BASE, "tables": ["deep"]}` run with `GUARDRAILS_ANON_KEY=test-anon` +→ `anon-read:deep` SKIPPED, no `Traceback` in stderr; cross-user on +`/api/guarded` (401) stays CLOSED (lock it). + +B1 metadata keys. `METADATA_KEY = re.compile(r"^(?:has|is|needs|requires)_|_(?:type|count|length|url|expires?|expiry|ttl|at)$|^(?:next_page_token|page_token|cursor|csrf_?token|xsrf_?token)$")` +tested on `_snake(k)` before SENSITIVE_KEY; a metadata key is never sensitive. +PT: `/api/me` keeps `next_page_token`; the lock at ~248 becomes +`api_key, password_hash$`; new route `/meta/keys` → +`{"tokenType": "bearer", "has_password": true, "token_expires_in": 3600, "password_changed_at": "2026"}` +→ fields CLOSED (camelCase proves the snake-cased match; `token_expires_in` and +`password_changed_at` are sensitive today). + +B2 + B13 `_map_verdict` walks every candidate. Candidates: resolve each through +`_same_host` first; dedupe on the resolved url, else on the raw url. Split a +per-candidate classifier `_map_outcome(session, script_url, url) -> (kind, target, note)` +with kind in `open | negative | note | error` out of the loop (25-line limit). +Per candidate: +- `data:` url (always a line-start `sourceMappingURL` directive since c0fdbec) + → `open`, note `inline source map in the script`, no decoding (base64 and + percent-encoded alike; the `"base64," not in url: continue` guard is deleted). +- off-host → `note` `map url on another host, not fetched`. +- transport error (incl. BUDGET_EXHAUSTED) → `error` → return ERROR now (today's behaviour). +- 200 at BODY_CAP → `note` (checked BEFORE the sources test; PT /bigmap.js.map lock stays SKIPPED). +- 200 with `"sources"` → `open`. +- 404, 410, or 200 without sources → `negative`. +- any other status (3xx, 401, 403, 429, 5xx…) → `note` `f"HTTP {status}: map not readable, not confirmed"`. +After the loop: any note → `("SKIPPED", first noted target, its note)`, else CLOSED. +PT, in a NEW plan file `maps2.json` (maps.json already lists 8 of SCRIPT_CAP 10): +`/forbidden.js` (comment → `/forbidden-real.js.map`; `/forbidden.js.map` → 403; +`/forbidden-real.js.map` → 200 with sources) → OPEN; `/pct.js` +(`sourceMappingURL=data:application/json,%7B%22version%22%3A3%7D`) → OPEN; +`/limited.js` (bare map → 429) → SKIPPED. Existing `/err.js` 503 and +`/inline.js` / `/biginline.js` locks stay. + +## Part 2 — engine, checks, docs, lib/tests/guardrails-scan.test.sh + +A4 scanner.py: one helper `_safe_text(text)` = `"\n".join(printable(l) for l in text.split("\n"))` +applied at the three text print sites (the text report, the check-mode lines, +the usage error); JSON untouched. ST: mutant with an ESC byte in a file name AND +in a supabase policy name (supabase.py:160 echoes it in `f.message`): 0 ESC bytes +in the text report; a `--assert-absent RULE:` run prints the +PRESENT row with `?` and 0 ESC bytes; a `--baseline` run 0 ESC bytes; findings +still raise. `SKILL.md` STEP 9 (~187-195): one sentence "pairs come from the +`--json` output, never from the text report". a11y suite stays green untouched. + +B3 `_hydrated` scoped by export chunks. One `finditer` of `^export\b` (re.M) +gives chunk starts (plus offset 0, EOF). For each chunk holding a LOADER match, +run `HYDRATED.finditer(text, line_start_of_first_match, chunk_end)`; offsets are +absolute, chunks disjoint, no merge. A `window.__X__ =` match is a LOADER member +and follows the same rule. Findings through `dedupe_lines`. ST mutants (WARN): +Prettier multi-line-params `getServerSideProps` with `}) => {`; one-line +`export const loader = () => json({ token: t });`; multi-line Remix `loader`; +SvelteKit `export async function load()`; multi-line `window.__STATE__ = {\n token: t\n}`. +Benigns: clean `loader` followed by an `action` holding `password: form.get("password")`; +`// getServerSideProps` comment above a clean loader. Timing case: 1 MB of +`export const load = 1\n` through the chunk builder + HYDRATED, < 1.0 s. +checks.md blind spots: a non-exported helper between two exports is still +scanned (false positive as today); a sensitive object built in a helper above +the loader is missed; a fix that moves the key above the loader clears the +oracle, the STEP 3 judge re-reads the whole loader. + +B4 `_map_config`: `other = [p for p in _named(project, "webpack") if p not in prod and not DEV_TOKEN.search(p.name)]`. +ST: benigns `webpack.dev.js`, `webpack.config.dev.js` with `devtool: 'eval-source-map'`; +`webpack.config.js` still WARN; mutant `webpack.prod.js` with the same devtool → FAIL. + +B5 DATA_ATTR: the sensitive word list becomes one constant `SENSITIVE_WORD` +used by DATA_ATTR and by `UI_ATTR = re.compile(rf"{SENSITIVE_WORD}-(?:toggle|visible|visibility|show|hide|reveal|mask|strength|meter|hint|label|placeholder|confirm|error|required|pattern)$", re.I)` +tested with `search` on the captured name (anchored at its end) → silent. +ST: benigns `data-password-toggle="true"`, `data-password-strength="3"`, +`data-secret-visible`; mutants `data-password="hunter2"`, `data-hide-api-key={k}`, +`data-api-key-input-value={v}` still WARN. + +B6 NOSQL `$where`: `\$where\s*:\s*(?!\w{0,64}_(?:bool_)?exp\b|[A-Z]\w{0,64}!?\s*[),])(?:['"`]|\w)` +(bounded repeats; excludes GraphQL `_bool_exp` types and a Capitalised type +followed by `)` or `,`). ST mutants (WARN): `{ $where: "this.name == '" + name + "'" }`, +`{ $where: clause }`, `{ $where: buildWhere(req.query) }`; benign +`$where: users_bool_exp` and `($where: UsersWhere)` in a `.ts` gql template. +Blind spot (checks.md): `$where: PascalCase` or `*_exp` identifiers. +Timing case added (B9). + +B7 misses, one mutant each, clean fixture stays 0/0: +- Go: CONCAT `.go` → `fmt\.Sprintf\(\s*(?:\"{DQ}?{STMT}|`\s{0,40}{STMT})`; mutants + double-quoted and backtick (statement first). Blind spot: a raw literal whose + statement keyword does not open it. +- RAW JS adds `\b(?:sql|db|trx|knex)\.raw` (non-literal argument → WARN). +- Python `rf""` / `fr""`: first `.py` alternative `\b(?:rf|fr|f)['\"]...`. +- Triple-quoted f-strings: alternative `\b(?:rf|fr|f)(?:\"\"\"|''')\s{0,40}{STMT}` + (STMT-anchored like the single-quote form, no `{` required). Mutant: multi-line + `f"""\n select id from notes\n where owner = {owner}\n"""`; benign plain + `"""select … %s"""`. Blind spot: a literal whose first non-blank line holds no + statement (comment first). +- Supabase `.select()` empty → WIDE `\.select\(\s*(?:['\"]\*['\"]\s*)?\)`. +- HIDDEN_INPUT `]{0,300}>` (newlines allowed, bounded); mutant with + `type="hidden"` and `name="api_key"` on separate lines. + +B8 docs, one pass. `SKILL.md` judging step (~50-57): bullet "INJ-SQL-CONCAT on +`IN (${placeholders})` where the list is generated `?`/`$n` markers and the +values travel in a separate array: parameterised, confirm by hand and drop it +from the proposals." `references/checks.md`: :41 RAW row adds `sql.raw`, +`db.raw`, `trx.raw`; :44 `$where` row "a string, an identifier or a function +(GraphQL `_bool_exp` and Capitalised types excluded)"; :52 webpack "WARN +elsewhere, dev configs silent"; :59 EXP-RESPONSE-WIDE adds `.select()`; +:141 by-design list adds the generated `?` list, webpack dev configs, +UI-suffixed data-* names, export-chunk scoping, metadata keys in the fields +probe; :226 fields row mentions the metadata exclusion; :232 verdict wording +"SKIPPED is a missing key or a body the probe could not read; ERROR is a +transport failure or an exhausted budget"; sourcemap row: a line-start +`data:` directive is OPEN whatever its encoding; blind spots list (B3, B6, B7 +above, 1 MB per-file CONCAT cost ≈ 3 s accepted). + +B9 timing lock (ST ~506-528): ADD cases, each asserting `search is None` and +< 1.0 s, sized ≈ 80 KB: JS backtick (`"`" + "select from " * N`), JS `'`-quoted, +py `f'`, py `f"""`, Go `` fmt.Sprintf(` `` raw, NOSQL `$where: ` units, +HIDDEN_INPUT `getMessage()`; `app.debug = True`; +SHELL_DB heads (`Command::new`, `popen`, `passthru`, `proc_open`, `spawn`, +`system`) and interpolations (`#{`, `{x}`, `%s`, `$var`). +A row that does not match is a real miss: fix the regex minimally, add a benign +lock for the widened form, a timing case if a repeat widens, and update its +checks.md row. More than 5 regex edits in this part → `STATUS : NEED-DECISION` +listing the rows, never widen further. + +## Out of scope +settings.json, mods/model-router/routing.json (pre-existing dirty, never staged). +Other domains' missing mutants (api, hosting, supabase, messaging, functions). + +## Gated answers [gated 2026-10-20] +- Plan approved (r1), both parts; r2/r3 restructure into three parts by file. +- B1: full METADATA_KEY list; `next_page_token` stops being reported. +- B4 + B5: webpack dev configs and UI-suffixed data-* names are silent, each with a benign lock. +- No new CLI flag (A2 locked through a python block). + +## Challenge log +r1 → r2: B6 mutants WARN; A2 URLError → ERROR; A3 three-way; B9 non-matching +shapes; B2 allowlist; B3 spans; B5 anchored; B6 identifier branch kept; B10 own +part; one `printable`; split by file; MINORs (DEV_TOKEN, `_at$`, url required, +two map keys, RAW receivers, checks.md rows, base64 unchanged, dedupe, A4 locks, +snake fixture, route names). +r2 → r3 (all three lenses): +- BLOCKER (c#1, r#1, s#3): `BUDGET_EXHAUSTED` constant + `_BudgetExhausted` subclass mapped in `fetch`; B2 keeps today's transport-error ERROR return. +- MAJOR c#2 / r#2 / s#4: A3 gated on status (200 three-way; 401/403/404 CLOSED; other SKIPPED), error first, `/rest/v1/deep` route only, 401 cross-user lock. +- MAJOR c#3 / s#2 / r#11: triple-quoted alternative = STMT-anchored form, multi-line mutant, blind spot documented. +- MAJOR c#4 / r#4 / s#1: B3 export-chunk scoping (linear), Prettier mutant. +- MAJOR c#5: Part 2 regains webpack.prod FAIL, loader/load/one-line WARN and double-quoted Go mutants. +- MAJOR r#3: SKILL.md STEP 5 shows both hosts before `--authorized`. +- MAJOR r#5 / r#6: timing cases assert non-match, sized ≈ 80 KB, 1 MB cost recorded as residual. +- s#3 accepted in part: `data:` directive → OPEN without decoding (simplicity r1#3 now accepted: the directive is line-anchored, so the payload is observed); the base64 guard is deleted. +- MINORs: tables typed (c#12, r#15); usage error printable (r#16); rate-limit SKIPPED on a cut burst (r#7); cap before sources, dedupe key (c#6, r#8); B5 end-anchored and shared word list (r#12, s#8); B6 bounded + timing (r#13, s#12); B12 OR (r#14, s#9); `expires_in` → `token_expires_in` (c#11); `_map_config` name (c#10); A4 single helper and ESC pair (s#6, c#7); JSON pairs sentence (r#17); docs rows (c#9); Part 3 table split and checks.md rows (s#10, s#11); hops.json dropped (s#5). diff --git a/.claude/tasks/plans/2026-10-20-guardrails-residuals-part1-report.md b/.claude/tasks/plans/2026-10-20-guardrails-residuals-part1-report.md new file mode 100644 index 0000000..7be7243 --- /dev/null +++ b/.claude/tasks/plans/2026-10-20-guardrails-residuals-part1-report.md @@ -0,0 +1,29 @@ +# Part 1 report — guardrails residuals (probe.py) + +STATUS: DONE (one plan hole fixed, one oracle defect found) + +Files: skills/guardrails/scripts/probe.py, skills/guardrails/scripts/checks/common.py +(printable), skills/guardrails/SKILL.md (STEP 5 sentence), lib/tests/guardrails-probe.test.sh. + +Applied: shared printable; A1 (supabase url/tables validation, refusal names both +hosts, usage error printable, SKILL.md sentence); A2 (BUDGET_EXHAUSTED, +_BudgetExhausted, _SameHost(session), rate verdict SKIPPED on cut burst); A3 +(_rows_state, _rows_verdict, 401/403/404 CLOSED, other non-200 SKIPPED); B1 +(METADATA_KEY, _is_sensitive); B2+B13 (_map_outcome, _status_outcome, walk of +all candidates, dedupe on resolved url, data: always OPEN). + +Tests: probe suite 84 passed 0 failed (70 passed 14 failed with probe.py and +common.py stashed: negative control OK). a11y-scan 23/0, guardrails-scan 184/0. + +Deviations: +1. Plan hole: METADATA_KEY as written does not match `token_expires_in` + (`_expires?$` needs the key to end there). Made it `expires?(?:_in)?`. + Required by the plan's own PT and oracle 11. +2. Oracle 12 (contract) is defective: after `cd skills/guardrails/scripts` + its `grep -q ... lib/tests/...` uses a relative path and fails. The python + half and both greps pass when run from the repo root. Orchestrator should + fix the oracle (use an absolute path or a subshell). + +Gates: criteria 1-9, 11, 21 MET. 12 NOT-MET for the oracle defect above. +10, 13-20, 22 belong to Parts 2-3 (22 is a diff-wide check, re-run at the end). +settings.json and routing.json untouched by me (pre-existing dirty). diff --git a/.claude/tasks/plans/2026-10-20-guardrails-residuals-part2-report.md b/.claude/tasks/plans/2026-10-20-guardrails-residuals-part2-report.md new file mode 100644 index 0000000..03a5497 --- /dev/null +++ b/.claude/tasks/plans/2026-10-20-guardrails-residuals-part2-report.md @@ -0,0 +1,20 @@ +# Part 2 report (guardrails-residuals) + +STATUS DONE. Suites: guardrails-scan 222/0, a11y-scan 23/0, guardrails-probe 84/0. shellcheck on the scan suite clean. +Gates rows 2,3,10,13-18,20 MET (19 = Part 3, 22 = floor guard, see below). + +Files: scanner.py (_safe_text at the 3 text print sites, printable imported), checks/exposure.py (SENSITIVE_WORD, UI_ATTR, HIDDEN_INPUT multi-line, WIDE .select(), _map_config dev exclusion, _large_map "sources" key, _hydrated_spans export chunks + dedupe_lines), checks/injection.py (Go backtick, rf/fr, triple-quoted f, sql/db/trx.raw, $where exclusions), SKILL.md, references/checks.md, lib/tests/guardrails-scan.test.sh, contract (oracle rulings). + +Negative control: with scanner/exposure/injection stashed the suite fails 20 checks (mutants, benigns, ESC, timing); restored after. +Timing at ~80 KB: every new case < 0.01 s, chunk builder on 1 MB of `export const load` 0.03 s. + +Choices the plan left open +- Test layout: new `== residual misses` section uses `solo`-based `raises` helper; ESC checks in a new `== text output` section; timing python moved to $WORK/timing.py (heredoc inside $(...) broke on quotes/backticks). +- Benigns that must stay 0/0 on the fixture sit under src/lib (src/api is a route dir and raises API-ROUTE-NO-AUTH); select-with-fields appended to $API. +- Contract oracle defects fixed (contract is in scope): 17 gains an index.js (a lone .map leaves exposure not applicable); 15 negative grep narrowed to the INJ-NOSQL-OPERATOR row (g.ts also raises API-ROUTE-NO-AUTH). +- SKILL.md Part 1 sentence reworded "Before adding it" -> "Before adding `--authorized`" so criterion 20's grep matches. +- STEP 3 bullet placed after the blind-spot paragraph; `--json` pairs sentence placed in STEP 10 item 3 (where the RULE:path pairs are written), not STEP 9. +- checks.md blind-spot bullets and by-design list extended as the plan lists. +- A variable named PY in the suite's python made shellcheck read it as heredoc end: renamed PYC. + +Concern: criterion 22 floor-guard flags only the contract text itself (line 116 mentions noqa); no suppression added by this diff. diff --git a/.claude/tasks/plans/2026-10-20-guardrails-residuals-part3-report.md b/.claude/tasks/plans/2026-10-20-guardrails-residuals-part3-report.md new file mode 100644 index 0000000..4410786 --- /dev/null +++ b/.claude/tasks/plans/2026-10-20-guardrails-residuals-part3-report.md @@ -0,0 +1,8 @@ +# Part 3 report (B10 per-variant locks) +STATUS DONE. Files: lib/tests/guardrails-scan.test.sh, skills/guardrails/scripts/checks/injection.py, skills/guardrails/references/checks.md. +- `== per-variant` section: 17 end-to-end mutants (Rust format!, objects.raw, extra, knex.raw, executeRawUnsafe, sequelize.query/literal, GENERATE_SOURCEMAP, vite true, angular WARN, Rails, FLASK_DEBUG, app.debug, Rust/Ruby shell-db, PHP getTraceAsString, flask str(e)) + 2 benign locks. mutant lines 86 -> 103. +- Python table in $WORK/timing.py: ~75 alternation rows (CONCAT, DYNAMIC_EXEC, POSTGREST, NOSQL, SENDING x ERROR_STACK/MESSAGE, SHELL_DB heads x interps incl. Command::new), regex.search per row. +- One real miss: SHELL_INTERP lacked Rust positional `{}` (Command::new("psql").arg(format!("-c {}", q))). Widened with `\{\}(?=[^"{}\n]{0,12}"\s*,)` (bounded, `{}` must close a format string before `,`). Benign locks: execSync("psql ...", {}) and Rust argv. Timing case `system(psql {} ` x5000 (0.65 s at 90 KB; first widening with {0,200} took 1.85 s, narrowed). checks.md INJ-SHELL-DB-TOOL row updated. +- Regex edits: 1 (limit 5). +- Results: scan suite 241 passed 0 failed; make test all green; shellcheck ok; gates VERDICT MET (22/22). +- Concern: SHELL_DB is pre-existing quadratic on single-line non-matching input (~0.5 s at 84 KB), margin to the 1 s timing lock is thin on slow machines.