chore(memory): guard fail-closed journal, BDR-136 amended
This commit is contained in:
1 parent
e8598dfee5
commit
1a96fca750
5 files changed
+298
-1
No files matched your search
@@ -1488,6 +1488,7 @@ Supersedes [[BDR-030]].
|
||||
- **Alternatives rejected**: `$.ui.ask` mod gate, phrase-list gate (challenges 2026-10-25); 16 routing rows for the guard (run slot drops mid-run, would open first-use + ask-tier dialogs); `git -C * merge *` (asks on any commit text with " merge ", sub-agent ask refused); quoted finish rule (matcher ignores quote in pattern); `gitflow_finish*`, `bash -s*` (bench RAN); `Bash(/*)` (kills `*/rtk` twins); per-spawn guard.
|
||||
- **Residuals**: Bash write forms outside guard; latch reset on register.ts reload; sourced `gitflow_finish`, `git -C <dir> merge`; `rtk read -n .env` flag-first (security MEDIUM, TODO); code-limits TMPDIR state dir ownership unchecked; silent in this repo (code-origin foreign).
|
||||
- **Gates**: plan r1 correctness FATAL(8) robustness FATAL(5) → r2 → confirmation CONCERNS(4) → r3; user interactive ask check; SDD 11 tasks; final opus review With fixes → fix wave; GATE 0 ABANDONED(2) user-accepted; verifier ECARTS(6) → ECARTS(2) human-gated; security PASS (1 MEDIUM, 3 LOW). Refs [[BDR-125]], [[BDR-068]], [[BDR-123]], [[BLK-018]], [[LRN-256]], [[LRN-257]].
|
||||
- **Status (2026-11-16)**: accepted, amended: point (4) router write guard now fails closed via next.called (guard failure holds main-loop code write outside skill run; sub-agents, runs, .md/.txt pass); refused/isError Skill no longer latches. 859e504, BDR-125 gap A6, user choice 2026-11-12
|
||||
|
||||
## BDR-137 — Phase 4b memory capture mod: error-shaped Bash failures redacted into a per-project store, 4-gram index per call, one note per milestone, memory_pending (2026-11-04)
|
||||
- **Context**: BDR-125 phase 4b, `feature/memory-capture` (f1d4f9d..HEAD), contract `.claude/tasks/contracts/2026-11-03-memory-capture-0100.md`, spec `docs/superpowers/specs/2026-11-03-memory-capture-design.md`, plan r3, spike `.claude/tasks/plans/2026-11-03-memory-capture-spike/REPORT.md`. Capture = weak link: 5/7 real errors of 2026-10-23 no entry.
|
||||
|
||||
@@ -766,3 +766,4 @@ rules:
|
||||
|
||||
## 2026-11-16
|
||||
- A5 T18 bun guard: memory.test.sh T18 entriesOf/index parity prints SKIP when bun absent instead of FAIL (b9f2d81); no prior bun-skip convention (memory-feedback.test.sh still hard-fails). settings.json left dirty by user choice (/model opus[1m] save). Next A6.
|
||||
- A6 router write guard fail-closed: .catch uses next.called (called → replay next(e); not called → hold main-loop out-of-run non-doc write with user-chosen deny); Skill latch ignores isError answers (BDR-137 shape, was one-call bypass) (859e504). BDR-136 (4) amended. 3 plan rounds: r1/r2 latches unreachable, engine-documented pattern won. gates.sh 120s timeout < make test ~135s: GATES_TIMEOUT=400. Next A7.
|
||||
@@ -0,0 +1,27 @@
|
||||
# CONTRACT — guard-fail-closed (BDR-125 gap audit A6)
|
||||
- date: 2026-11-16 | flow: feat | branch: feature/guard-fail-closed (off develop)
|
||||
- status: active
|
||||
|
||||
## REQUEST (verbatim — IMMUTABLE)
|
||||
A6 (BDR-125 gap audit, phase 2 shared rule "guards fail closed", user choice 2026-11-12): the model-router write guard (mods/model-router/hooks/register.ts registerGuard, ~:4441-4464) fails open: when guardWrite throws, the .catch logs and lets the Edit/Write/NotebookEdit through. Make it fail closed for the guard's own failure: a main-loop code write the guard could not decide is denied with "model-router: the write guard failed (<error kind>), so this write is held. Enter /hotfix, /feat, /bugfix or /ship-feature, or re-enter the skill you were running, then make this edit." Sub-agents, writes inside a skill run, and doc files still pass without touching the code that can fail. Errors from the downstream tool (next) keep today's behavior. Tests in mods/model-router/hooks/register.test.ts.
|
||||
|
||||
## CLARIFICATIONS
|
||||
- [gated 2026-11-16] deny text chosen by the user: "Same redirect + cause" (the text quoted in REQUEST, `<error kind>` = `errWord(err)`).
|
||||
- [internal 2026-11-16, challenge r1] plan .claude/tasks/plans/2026-11-16-guard-fail-closed-0025.md section r2 wins. Real throw sources are session.root and a raw ui.log in the config load (config READ errors never throw; an unreadable override turns the router off, unchanged). The config-load log goes through tryLog; the Skill and skill.prompt .catch paths latch so entering a skill stays a working exit. guardWrite returns the deny text; own warnOnce key 'write guard'. Rig gains a World `root: 'fail'` knob. Amends BDR-136 point (4) (guard fail-open) per the user's 2026-11-12 choice; recorded at capitalize.
|
||||
- [internal 2026-11-16, re-challenge r2] plan section r3 wins over r2: guardWrite unchanged; the three guard .catch blocks use the engine's documented `next.called` split (called → replay next(e) as today; not called → hold a main-loop out-of-run non-doc write with the user-chosen text, else pass). No tryLog or .catch-latch changes. Gate 0 note: criterion 1 CHECK runs `claude plugin test` (the kit `claude-code/testing` exists only under the engine; bare `bun test` cannot load it), as lib/tests/mods.test.sh does. Scope extension under the user's "fill every gap found" instruction: the Skill latch no longer opens on an `isError` output (BDR-137: engine refusals carry isError, not deny).
|
||||
|
||||
- [gated 2026-11-16, after verify] user accepted as built: the deny's kind is `next.error.kind` (throw | timeout, never a path), not `errWord(err)`; sub-agents, skill runs and doc files pass through the `.catch` fallback after the guard ran (engine-documented next.called pattern), not by being decided before code that can fail. Outcome unchanged and tested.
|
||||
|
||||
## ACCEPTANCE CRITERIA
|
||||
1. model-router suite green, with the new fail-closed tests.
|
||||
CHECK: cd /home/bchanot/Documents/claude && PATH=$HOME/.bun/bin:$PATH claude plugin test mods/model-router </dev/null 2>&1 | grep -cE '(^| )0 fail'
|
||||
EXPECT: 1
|
||||
EVIDENCE: MET exit=0 marker-found :: 1
|
||||
2. Full make test green.
|
||||
CHECK: cd /home/bchanot/Documents/claude && PATH=$HOME/.bun/bin:$PATH make test </dev/null 2>&1 | tail -1
|
||||
EXPECT: all suites green
|
||||
EVIDENCE: MET exit=0 marker-found :: all suites green
|
||||
3. The deny tests (main Write, Edit, NotebookEdit held when session.root fails) and the isError-latch test fail on the pre-change register.ts; the doc, sub-agent, in-run and exit tests pass after the change; type-check clean if the repo has one for mods; lines ≤ 80 columns in the touched files (manual).
|
||||
|
||||
## FILE SCOPE
|
||||
mods/model-router/hooks/register.ts (guard region ~:4397-4465 and its comment, Skill handler latch predicate ~:4577), mods/model-router/hooks/register.test.ts (rig World type and session.root mock ~:40-212, GUARD section ~:7288-7470).
|
||||
@@ -6,7 +6,7 @@
|
||||
- [x] A3 DONE 87aecc1 (docs 038670e, residuals BUGS-FOUND 07f9a7f). /bugfix memory_index rc 0 on unreadable/non-regular blockers.md → digest `- open: none` (4c digest defect, BUGS-FOUND:87): non-zero rc → `- open: unknown`; SD9b/SD9c re-pinned.
|
||||
- [x] A4 DONE e0311f4 (tests strengthened in same commit, CHANGELOG eb801b7, residuals BUGS-FOUND 074cdde). memory.sh `check --staged`: new entry ID = max+1 (4a ask TODO:170; today comment "gap harmless" :162).
|
||||
- [x] A5 DONE b9f2d81. memory.test.sh T18 hard-fails without bun on PATH → SKIP line like other bun-gated tests.
|
||||
- A6 (user choice) routing guard fail mode (phase 2 shared rule "guards fail closed"; today fail-open).
|
||||
- [x] A6 DONE 859e504 (docs e8598df, BDR-136 amended). (user choice) routing guard fail mode (phase 2 shared rule "guards fail closed"; today fail-open).
|
||||
|
||||
## Batch B — measurements and live proofs (run by me headless where possible)
|
||||
- B1 /context delta never recorded for 4a, 5, 2, 4b-4d: headless pair method (LRN-270 caveat) with/without each phase's lever where reproducible; else a recorded "not measured" with bracketing figures.
|
||||
|
||||
@@ -0,0 +1,268 @@
|
||||
# PLAN — guard-fail-closed (BDR-125 gap audit A6)
|
||||
|
||||
## CONTEXT
|
||||
- mods/model-router/hooks/register.ts ~:4397-4465. `guardWrite($, st, e)`
|
||||
awaits `ensureConfig` first, then checks `st.off`, `e.agentId`,
|
||||
`inRun(st)`, then `writtenPath` and `isFreePath(path, await
|
||||
$.session.root())`. `registerGuard` registers three `tool.call` handlers
|
||||
(Edit, Write, NotebookEdit): `guardWrite` true → `{ deny: GUARD_REASON }`,
|
||||
else `next(e)`; each `.catch(($, e, next) => { warnOnce(...); return
|
||||
next(e) })` fails open for ANY error, the guard's own or the downstream
|
||||
tool's.
|
||||
- Comment above (~:4402) says "Fail-open like every hook here".
|
||||
- `errWord(err)` (~:367) = the log-safe error kind. `warnOnce(st, $, hook,
|
||||
kind)` (~:1092) logs once per hook key with the fixed tail "routing
|
||||
skipped for this event".
|
||||
- Tests: register.test.ts GUARD section (~:7288-7470), helpers
|
||||
`guardRig`, `write`, `denied`, constant `GUARD`.
|
||||
|
||||
## APPROACH
|
||||
1. Reorder `guardWrite` so the cheap, infallible checks come first and the
|
||||
code that can fail is reached only for a main-loop out-of-run write:
|
||||
`if (e.agentId !== undefined || inRun(st)) return false` →
|
||||
`const path = writtenPath(e); if (path === undefined) return false` →
|
||||
`if (DOC_FILE.test(path) && !dotDot(path)) return false` is NOT added
|
||||
separately: instead split `isFreePath` so the doc-file test runs before
|
||||
`$.session.root()` is awaited (the `/../` rejection stays first, as
|
||||
today) → `await ensureConfig($, st)` → `if (st.off) return false` →
|
||||
`return !isFreePath(path, await $.session.root())`.
|
||||
Result for every input the guard decided before: unchanged (same
|
||||
predicates, same outcome; only order differs; ensureConfig is an
|
||||
idempotent lazy load that every other hook also calls).
|
||||
2. Fail closed on the guard's own failure only: each handler wraps the
|
||||
`guardWrite` call, not `next(e)`:
|
||||
```
|
||||
let held: boolean
|
||||
try { held = await guardWrite($, st, e) } catch (err) {
|
||||
return guardFailed($, st, '<Tool> guard', err)
|
||||
}
|
||||
if (held) return { deny: GUARD_REASON } as never
|
||||
return next(e)
|
||||
```
|
||||
Factor the three identical handlers into one helper
|
||||
`guardHandler(tool)` returning the handler, so the try/catch exists
|
||||
once (the file already repeats the block three times; one helper is
|
||||
the minimum that keeps the new logic in one place).
|
||||
`guardFailed` logs once per hook key via the existing `warnOnce`
|
||||
mechanism (new optional 5th param `effect`, default `'routing skipped
|
||||
for this event'`; the guard passes `'write held'`) and returns
|
||||
`{ deny: GUARD_FAIL(errWord(err)) }` where
|
||||
`GUARD_FAIL = (kind) => 'model-router: the write guard failed (' + kind
|
||||
+ '), so this write is held. Enter /hotfix, /feat, /bugfix or ' +
|
||||
'/ship-feature, or re-enter the skill you were running, then make ' +
|
||||
'this edit.'` (exact user-chosen text).
|
||||
3. The existing `.catch(... warnOnce; return next(e))` stays for errors
|
||||
thrown by `next(e)` (downstream tool): today's behavior, untouched.
|
||||
4. Comment above the guard: replace "Fail-open like every hook here" with
|
||||
one sentence: the guard's own failure holds a main-loop code write
|
||||
(fail closed, BDR-125 phase 2 rule); sub-agents, skill runs and doc
|
||||
files never reach the code that can fail; a downstream tool error
|
||||
passes through as before.
|
||||
|
||||
## EDGE CASES
|
||||
- `ensureConfig` throws (config read error) on a main-loop code write
|
||||
outside a run → denied with GUARD_FAIL. Same write inside a skill run or
|
||||
from a sub-agent → allowed (never reaches ensureConfig).
|
||||
- `$.session.root()` throws → a `.md`/`.txt` path still passes (doc test
|
||||
runs first); any other path → denied.
|
||||
- A path with `/../` → not free (unchanged), reaches root().
|
||||
- `st.off` (mod off) → allowed, but only once ensureConfig succeeded; if
|
||||
config cannot be read the mod's off state is unknown → held (fail
|
||||
closed). Entering a skill still writes.
|
||||
- warnOnce dedupe: one log line per tool key per session, as today.
|
||||
|
||||
## TESTS (register.test.ts, GUARD section)
|
||||
Make a guard step throw in the rig (e.g. a `$.session.root` that throws,
|
||||
or a config read that throws; use whatever the rig already offers to
|
||||
inject failures, read neighbouring tests for the idiom):
|
||||
- GUARD fail-closed: root() throws, main code write → deny contains
|
||||
"the write guard failed (" and "so this write is held".
|
||||
- GUARD fail-closed: root() throws, `README.md` write → not denied.
|
||||
- GUARD fail-closed: root() throws, sub-agent write (`agentId` set) → not
|
||||
denied.
|
||||
- GUARD fail-closed: root() throws, inside a skill run (latch opened as
|
||||
the existing "a typed skill opens it" test does) → not denied.
|
||||
- GUARD fail-closed: Edit and NotebookEdit get the same deny.
|
||||
- Downstream error untouched: a bottom `tool.call` handler that throws
|
||||
for a free path → the error behaves as before (not converted to the
|
||||
GUARD_FAIL deny).
|
||||
- Existing GUARD tests stay green unchanged.
|
||||
The fail-closed tests must fail on the pre-change register.ts.
|
||||
|
||||
## DISPOSITION
|
||||
Honors BDR-125 (phase 2 shared rule: guards fail closed) and follows
|
||||
BDR-112's precedent (push-guard text-only deny, fail closed). Honors the
|
||||
model-router CLAUDE.md doctrine (main loop writes no code outside a skill
|
||||
run): entering a skill stays the way out when the guard fails.
|
||||
|
||||
## FILES
|
||||
mods/model-router/hooks/register.ts, mods/model-router/hooks/register.test.ts.
|
||||
|
||||
## r2 (challenge r1: correctness CONCERNS(2), robustness CONCERNS(1), simplicity CONCERNS(1)) — SUPERSEDES APPROACH, EDGE CASES and TESTS above
|
||||
Landed: (a) when ensureConfig throws, every latch hook (Skill tool.call
|
||||
:4566, skill.prompt :4588, prompt.submit :4899, /route) also fails before
|
||||
latching, so "enter a skill" led nowhere (robustness 1); (b) config READ
|
||||
errors never throw (readLayer/readOverride catch; an unreadable override at
|
||||
first load turns the router off → write passes): the r1 edge case was false
|
||||
(correctness 2); the real throw sources are `$.session.root()` and a raw
|
||||
`$.ui.log` in reloadConfig (:2139) / registerTool's catch (:3612);
|
||||
(c) guardHandler + guardFailed + a warnOnce 5th param were heavier than
|
||||
needed (simplicity 1-2); (d) moving ensureConfig later dropped the lazy
|
||||
load other hooks rely on after /reload-plugins (robustness 2); (e) shared
|
||||
warnOnce key with the downstream .catch (robustness 3, correctness 5);
|
||||
(f) the rig cannot make session.root fail (correctness 1); (g) BDR-136
|
||||
point 4 records the guard as fail-open (correctness 7).
|
||||
|
||||
1. `guardWrite($, st, e): Promise<string | undefined>` returns the deny
|
||||
text, undefined = allow. Order:
|
||||
a. `let cfgErr: unknown; try { await ensureConfig($, st) } catch (err)
|
||||
{ cfgErr = err ?? 'error' }` — the lazy load still runs on every
|
||||
write, as today (keeps other hooks' first load after
|
||||
/reload-plugins).
|
||||
b. `e.agentId !== undefined || inRun(st)` → undefined.
|
||||
c. `path = writtenPath(e)`; undefined → undefined.
|
||||
d. root-free check, new function `freeWithoutRoot(path): boolean |
|
||||
undefined`: `/../` or trailing `/..` → false (not free, keep
|
||||
going); DOC_FILE → true (allow, return undefined); else undefined
|
||||
(needs the root).
|
||||
e. `cfgErr !== undefined` → `heldBy(st, $, cfgErr)`.
|
||||
f. `st.off` → undefined.
|
||||
g. `let root; try { root = await $.session.root() } catch (err) {
|
||||
return heldBy(st, $, err) }`.
|
||||
h. root-dependent check, `isFreePath(path, root)` reduced to the tree
|
||||
test only (`startsWith(root/)`, `.claude/` minus
|
||||
`.claude/worktrees/`, `docs/`); the `/../` rejection stays in front
|
||||
of it via step d (a `docs/../src/a.ts` path is never free).
|
||||
Not free → `GUARD_REASON`; free → undefined.
|
||||
`heldBy(st, $, err)`: `warnOnce(st, $, 'write guard', errWord(err))`
|
||||
(unchanged warnOnce, own key 'write guard', distinct from the
|
||||
'<Tool> guard' keys of the .catch blocks) and returns
|
||||
`GUARD_FAIL(errWord(err))`, `GUARD_FAIL` = the user-chosen text
|
||||
verbatim with the kind spliced in.
|
||||
Handlers change by one line each: `const deny = await guardWrite($,
|
||||
st, e); if (deny !== undefined) return { deny } as never; return
|
||||
next(e)`. The three `.catch` blocks stay as they are (downstream tool
|
||||
errors: unchanged behavior). No handler factory, warnOnce untouched.
|
||||
2. The exit always works:
|
||||
- reloadConfig's `log` (:2139) and registerTool's catch log (:3612)
|
||||
go through the existing `tryLog` so a failing ui.log can no longer
|
||||
abort the config load.
|
||||
- Skill tool.call `.catch` (:~4583): after `const out = await next(e)`,
|
||||
latch like the main handler does: main loop (`e.agentId ===
|
||||
undefined`) and `out` not a deny → `st.skillRun = true`; return out.
|
||||
- skill.prompt `.catch` (:~4598): `if (typedPath(st, e.skill) !==
|
||||
undefined) st.skillRun = true` before `return next(e)` (typedPath is
|
||||
config-independent; it reads typedSlash/promptAllowed/loops).
|
||||
3. Comment above the guard (:~4402) replaces "Fail-open like every hook
|
||||
here": the guard's own failure (session.root, a config load that
|
||||
throws) holds a main-loop code write outside a skill run (fail closed,
|
||||
BDR-125 phase 2 rule, amends BDR-136 (4)); sub-agents, skill runs and
|
||||
doc files are decided before anything that can fail; entering a skill
|
||||
latches even when the config load failed; a downstream tool error
|
||||
passes through the .catch as before.
|
||||
|
||||
EDGE CASES (real behavior):
|
||||
- Unreadable or broken routing.json / override: no throw; first load with
|
||||
an unreadable override → router off → write passes (unchanged).
|
||||
- session.root throws: doc file passes, sub-agent passes, in-run passes,
|
||||
main code write outside a run → GUARD_FAIL deny.
|
||||
- ensureConfig throws (residual, after tryLog): same as above for main
|
||||
code writes; a model Skill call or a typed skill still latches through
|
||||
the .catch paths, then writes pass.
|
||||
- `/../` paths: never free (unchanged), held or redirected.
|
||||
|
||||
TESTS (register.test.ts):
|
||||
- Rig: World gains `root?: 'fail'` (pattern of `repo: 'fail'`); the
|
||||
session.root mock (:209) reads `w.root` per call and throws when
|
||||
'fail', so a test flips it after boot. FILE SCOPE widened to the rig
|
||||
lines.
|
||||
- Red-first (fail on the pre-change code): root fails → main code Write
|
||||
denied with text containing "the write guard failed (" and "so this
|
||||
write is held"; same for Edit and NotebookEdit (one test, as :7423).
|
||||
- Regression guards (pass before and after): root fails → README.md
|
||||
write passes; sub-agent write passes; in-run write (typed skill latch,
|
||||
as :7347) passes.
|
||||
- Exit test: root fails → main code write held → a model Skill call
|
||||
(the existing "model-loaded skill opens it" idiom, :7366) → the same
|
||||
write passes.
|
||||
- If the rig can make ensureConfig throw (e.g. an unrecorded ui.log on a
|
||||
warning config at first load with st.loaded false), add: write held,
|
||||
then a model Skill call, then the write passes. If it cannot, say so in
|
||||
the report with the reason; do not invent a rig path beyond the World
|
||||
`root` knob.
|
||||
- No downstream-error test (behavior unchanged, re-run semantics already
|
||||
pinned at :6403).
|
||||
- Existing GUARD tests unchanged and green.
|
||||
|
||||
CAPITALIZE (closing step, not the executor): BDR-136 status line through
|
||||
`memory.sh status` naming the amendment of point (4).
|
||||
FILES: mods/model-router/hooks/register.ts,
|
||||
mods/model-router/hooks/register.test.ts.
|
||||
|
||||
## r3 (re-challenge r2: correctness CONCERNS(2 MAJOR), robustness CONCERNS(1 MAJOR)) — SUPERSEDES r2 §1-3, EDGE CASES and TESTS
|
||||
Landed: (a) after tryLog no known source makes ensureConfig throw: the
|
||||
cfgErr hold and both new .catch latches had no reachable trigger and no
|
||||
test; the skill.prompt latch could not fire in its target state (prompt
|
||||
.submit fails before noteTyped) (corr 1-2, rob 3); (b) the engine API
|
||||
documents the guard pattern: `.catch(($, e, next) => next.called ? next(e)
|
||||
: { deny })` (claude-code.d.ts tool.call remark ~:4744-4747; Caught
|
||||
~:1500-1511: when `called`, next(e) replays the settled result, nothing
|
||||
beneath runs again) — it covers EVERY guard-own failure, not two sources
|
||||
(corr 7, rob 4); (c) pre-existing latch hole: a Skill call the engine
|
||||
refused or that failed returns `isError` with no `deny` key (BDR-137), yet
|
||||
the main latch (:4577-4579) opens the guard for the session (rob 1; the
|
||||
memory mod already tests both, mods/memory/hooks/register.ts:1441);
|
||||
(d) warnOnce's fixed tail says "routing skipped" on a held write (corr 6,
|
||||
rob 5).
|
||||
|
||||
1. `guardWrite` and `isFreePath`: UNCHANGED (order, ensureConfig first,
|
||||
lazy load kept, `/../` handling kept). No tryLog change, no latch in
|
||||
any .catch, no prompt.submit change.
|
||||
2. The three guard `.catch` blocks (Edit, Write, NotebookEdit) call one
|
||||
new helper `guardCaught(st, $, e, next, hook)`:
|
||||
- `next.called` → `warnOnce(st, $, hook, next.error.kind); return
|
||||
next(e)` (downstream tool error: exactly today's behavior, replayed,
|
||||
nothing re-run).
|
||||
- not called (the guard itself failed): if `e.agentId !== undefined ||
|
||||
inRun(st)` or the write is a doc file (`writtenPath(e)` undefined, or
|
||||
DOC_FILE matches and the path has no `/../` and does not end in
|
||||
`/..`) → `warnOnce(st, $, hook, next.error.kind); return next(e)`
|
||||
(writes the guard never holds still pass).
|
||||
- else → log once per session through `tryLog` under the
|
||||
`st.warned` key `'write guard held'`: `model-router: write guard
|
||||
failed (<kind>): main-loop code writes are held until a skill runs`;
|
||||
return `{ deny: GUARD_FAIL(next.error.kind) }` with GUARD_FAIL = the
|
||||
user-chosen text verbatim, kind spliced in. A `.claude/` or `docs/`
|
||||
path is held too in this branch (the root is unknown when the guard
|
||||
failed: it could not decide).
|
||||
Type `next` as the engine's `Next & Caught` (or what the handler's
|
||||
inferred type is); no new dependency.
|
||||
3. Latch predicate fix (pre-existing hole, in scope per the user's
|
||||
"fill every gap found" instruction for this run): the Skill handler's
|
||||
`refused` (:~4577) = not a successful output: `typeof out !== 'object'
|
||||
|| out === null || 'deny' in out || (out as { isError?: unknown })
|
||||
.isError === true`; latch only when main loop and not refused.
|
||||
4. Comment above the guard: replace "Fail-open like every hook here" with:
|
||||
the guard's own failure holds a main-loop code write outside a skill
|
||||
run (fail closed via `next.called`, BDR-125 phase 2 rule, amends
|
||||
BDR-136 (4)); sub-agents, skill runs and doc files still pass; a
|
||||
downstream tool error is replayed as before. Residual (one line): if
|
||||
the config load itself threw, only a model Skill call can latch (no
|
||||
known throw source today).
|
||||
|
||||
TESTS (register.test.ts):
|
||||
- Rig: World gains `root?: 'fail'` (pattern of `repo: 'fail'`); the
|
||||
session.root mock (:209) reads `w.root` per call and throws when
|
||||
'fail'. Flip it after boot.
|
||||
- Red-first: root fails → main code Write, Edit and NotebookEdit each
|
||||
denied with text containing "the write guard failed (" and "so this
|
||||
write is held" (one test, as :7423).
|
||||
- Regression guards: root fails → README.md write passes; sub-agent write
|
||||
passes; in-run write (typed-skill latch, as :7347) passes.
|
||||
- Exit: root fails → main code write held → model Skill call (idiom
|
||||
:7366) → same write passes.
|
||||
- Latch hole, red-first: a Skill bottom returning `{ isError: true, ... }`
|
||||
(shape per the kit; read :7450-7471 for the deny variant) → a later
|
||||
main code write is still redirected with GUARD.
|
||||
- Existing GUARD tests unchanged and green; full suite green.
|
||||
FILES unchanged (register.ts, register.test.ts incl. rig lines).
|
||||
Reference in new issue
Block a user