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 cc4ca7e..c89c405 100644 --- a/.claude/memory/learnings.md +++ b/.claude/memory/learnings.md @@ -241,6 +241,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 | --- @@ -1856,3 +1858,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. diff --git a/CHANGELOG.md b/CHANGELOG.md index 18712e4..01ff3b3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -38,6 +38,7 @@ Format follows [Keep a Changelog](https://keepachangelog.com/) and this project - model-router residuals of the confirmation waves: a failed `/route forget` or `/route ask` write logs its cause and answers a generic text; forget answers clean every file-sourced name, phase and key; a restore names a frontmatter file only for a valid skill name and refuses a `__proto__` row; `/route forget` never restores `changed.phases`; the dialog's Change offers and writes shipped phases only (a machine-only phase never reaches routing.json, and an alias no shipped phase uses says so); a failure after the user answered keeps the key asked instead of asking again at every use. - `gitflow delete` (and `finish`) land on the base that contains the branch and drop the branch's upstream before `git branch -d`, so a branch whose upstream lags (manual-push mode) is deleted instead of refused by git (T18k). - An invalid `gitflow.autopush` value (not a boolean, or a config read that fails) no longer pushes. The post-commit / post-merge hooks and every push site of `lib/gitflow.sh` (`start`, `finish`, the `origin/` cleanup of `delete`) read it as auto and pushed; they now push nothing and say why. Each hook run prints `gitflow post-commit: gitflow.autopush unreadable (git rc ) — NOT pushed, treated as manual push mode; fix the value by hand` (post-merge likewise), and the lib passes through the `push-mode` verb's line, `gitflow.sh push-mode: gitflow.autopush='' is not a boolean (git rc )`. A repo with its own committed `.githooks/` (onboarded projects) keeps running its old hooks, which still push on an invalid value, until a session start runs `reconcile-hooks` and rewrites them; commit that refresh so other clones get it. Tests: `lib/gitflow-test.sh` T18q block. +- `/guardrails` residuals. The live probe fails closed in more cases: every followed same-host redirect is charged to the request budget, and a budget that runs out mid-redirect reads ERROR; an anon-read or cross-user answer that is not a 200 or a refusal, or a 200 whose body is empty, over 1 MB or not JSON, reads SKIPPED instead of CLOSED; a rate-limit burst cut short by the budget or the transport reads SKIPPED; the source-map probe tries every candidate map of a script instead of stopping at the first it cannot confirm, and a `data:` map is OPEN whatever its encoding; the fields probe no longer flags metadata keys (`token_type`, `has_password`, `next_page_token`). The plan's Supabase `url` must be an http(s) url when tables or cross-user paths are set, `supabase.tables` must be a list of strings, and the `--authorized` refusal names both hosts. Scanner and probe text output strip control characters from file names and remote strings. Static rules lose false positives (hydrated state read per export chunk, webpack dev configs, `data-*` names with a UI suffix such as `-toggle` or `-strength`, GraphQL `_bool_exp` and capitalised types under `$where`) and gain detections: Go backtick SQL in `fmt.Sprintf`, `rf` / `fr` and triple-quoted Python f-strings, `sql.raw` / `db.raw` / `trx.raw`, an empty `.select()` on a users table, a hidden input spanning lines, a Rust `{}` argument to a DB shell tool, a large public `.map` whose head holds `"sources"`. Tests: `lib/tests/guardrails-scan.test.sh`, `lib/tests/guardrails-probe.test.sh`. ## [2.0.0] — 2026-10-06 diff --git a/lib/tests/guardrails-probe.test.sh b/lib/tests/guardrails-probe.test.sh index 5f935ab..ccd66b8 100644 --- a/lib/tests/guardrails-probe.test.sh +++ b/lib/tests/guardrails-probe.test.sh @@ -127,6 +127,31 @@ class H(BaseHTTPRequestHandler): if path == "/boom": return self._send(500, b"Traceback (most recent call last):\n" b' File "app.py", line 12, in handler\n') + if path == "/hop1": + return self._send(302, b"", {"Location": "/hop2"}) + if path == "/hop2": + return self._send(302, b"", {"Location": "/hop3"}) + if path == "/hop3": + return self._send(200, b'{"ok": true}') + if path == "/rest/v1/deep": + return self._send(200, b"[" * 200000) + if path == "/meta/keys": + return self._send(200, b'{"tokenType": "bearer", "has_password": true, ' + b'"token_expires_in": 3600, "password_changed_at": "2026"}', + {"Content-Type": "application/json"}) + if path == "/forbidden.js": + return self._send(200, b"f();\n//# sourceMappingURL=forbidden-real.js.map\n") + if path == "/forbidden.js.map": + return self._send(403, b"") + if path == "/forbidden-real.js.map": + return self._send(200, b'{"version":3,"sources":["f.ts"]}') + if path == "/pct.js": + return self._send(200, b"p();\n//# sourceMappingURL=data:" + b"application/json,%7B%22version%22%3A3%7D\n") + if path == "/limited.js": + return self._send(200, b"l();\n") + if path == "/limited.js.map": + return self._send(429, b"") if path == "/api/me": return self._send(200, b'{"id": 1, "email": "t@t.io", ' b'"password_hash": "x", "profile": {"api_key": "y"}, ' @@ -245,7 +270,7 @@ check "the random 404 path is CLOSED" \ check "sensitive keys in a JSON response are OPEN" \ "$(verdict "$OUT" 'fields:/api/me')" OPEN check "the sensitive key names are listed, never the values" \ - "$(printf '%s\n' "$OUT" | grep -A1 'fields:/api/me' | grep -c 'api_key, next_page_token, password_hash$')" 1 + "$(printf '%s\n' "$OUT" | grep -A1 'fields:/api/me' | grep -c 'api_key, password_hash$')" 1 check "a bare token key is OPEN, a bare private key is not" \ "$(verdict "$OUT" 'fields:/api/session')" OPEN check "the session key list is token only" \ @@ -336,6 +361,19 @@ check "a truncated script is SKIPPED" \ check "an oversize map is SKIPPED" \ "$(verdict "$OUT" 'sourcemap:/bigmap.js')" SKIPPED +cat > "$WORK/maps2.json" < "$WORK/fields.json" < "$WORK/sbfile.json" +ERR="$(probe --authorized "$WORK/sbfile.json" 2>&1 >/dev/null)" +check "a file:// supabase url exits 2" \ + "$(probe --authorized "$WORK/sbfile.json" >/dev/null 2>&1; echo $?)" 2 +check "the usage error names supabase.url" \ + "$(printf '%s\n' "$ERR" | grep -c 'supabase.url must be an http(s) url')" 1 +printf '{"base_url": "%s", "supabase": {"tables": ["t"]}}\n' "$BASE" > "$WORK/sbnourl.json" +ERR="$(probe --authorized "$WORK/sbnourl.json" 2>&1 >/dev/null)" +check "tables without a supabase url is a usage error, no traceback" \ + "$(printf '%s\n' "$ERR" | grep -c 'Traceback')" 0 +check "tables without a supabase url exits 2" \ + "$(probe --authorized "$WORK/sbnourl.json" >/dev/null 2>&1; echo $?)" 2 +printf '{"base_url": "%s", "supabase": {"url": "%s", "tables": "notes"}}\n' \ + "$BASE" "$BASE" > "$WORK/sbstr.json" +check "a string tables exits 2" \ + "$(probe --authorized "$WORK/sbstr.json" >/dev/null 2>&1; echo $?)" 2 +printf '{"base_url": "%s", "supabase": {"url": "https://a.test/\\u001b[2J", "tables": ["t"]}}\n' \ + "$BASE" > "$WORK/sbesc.json" +ERR="$(probe "$WORK/sbesc.json" 2>&1 >/dev/null)" +check "the refusal names the supabase url, control character replaced" \ + "$(printf '%s\n' "$ERR" | grep -cF 'and https://a.test/?[2J')" 1 +check "no ESC byte reaches the refusal" \ + "$(printf '%s\n' "$ERR" | LC_ALL=C grep -c "$(printf '\033')")" 0 +cat > "$WORK/deep.json" <"$WORK/deep.err")" +check "a deeply nested rows body is SKIPPED, never CLOSED" \ + "$(verdict "$OUT" 'anon-read:deep')" SKIPPED +check "a deeply nested rows body raises no traceback" \ + "$(grep -c Traceback "$WORK/deep.err")" 0 +cat > "$WORK/cu401.json" < "$WORK/meta.json" < src/pages/index.tsx" +echo "== residual misses (hydrated chunks, dev configs, Go/py/Drizzle forms)" +raises() { # raises