` (`resolveMainRef`; warns when local main lags its remote) and writes a structured `state/git-attention.json` sidecar that `watchtower-build-context.mjs` re-verifies against live git before relaying any banner — so a stale "MERGE OR LOSE" line can't survive a merge that already happened; act:6f36cbe2, act:a136b362. Since grp:wt-noise-immunity Ring 1's tick also RETRACTS what the rings filed — every machine retraction routes through `autoReconcileItem` (watchtower-lib; `'auto-reconciled'` + `evidence.actor`, excluded from engagement buckets portfolio-wide): `autoResolveBranchDivergedItems` retracts branch-diverged items whose branch merged, is verifiably gone (membership in a successful branch listing — a failed git call retracts nothing), or sits on `defaults.long_lived_branches` (staging/production exact + `backup/*` glob) — an exclusion that gates FILING ONLY, so an excluded branch stays visible on all four attention surfaces (attention line, git-attention sidecar, summary, Standing Issues; act:98649971); `autoReconcileCompletionReviews` resolves completion-review items whose action fid is verifiably CLOSED in its own project's pib-db (opened read-only; fid-not-found KEEPS the item — act:9eebbac4); worktree-unmerged filing splits an earned-urgency register (act:c008862c): `urgent` only with real unmerged commits, `normal` for uncommitted-files-only (`evidence.unmerged`), with REGISTER-AWARE dedup — a register change supersedes + refiles under the current register, and escalation is damped (a soft→urgent flip needs corroborating commits ahead, since `hasUnmergedContent` fails toward true on git blips); `countRealUncommitted` excludes generated runtime state via the watchtower-lib SSOT. CP3 hardening: untracked filenames pass as execFile args (never shell-interpolated), every branch-name path gates on `isSafeRefName`, and the detector census fails loudly on a non-literal `category:` inside a filing owner), Ring 2 (Claude intelligence, fast 5-min + slow 30-min tiers; the slow tier also runs `recallCanary` (act:6354a9db) — reads + prunes `state/suppression-ledger.jsonl`, writes `state/recall-canary.json`, an over-suppression-only trend detector gated on `defaults.recall_canary`; `buildRecallCanary`/`readLedgerRecords`/`withinDays` exported — and `runDraftAnnotationSweep` (act:00051dca; gated on `defaults.draft_annotations`, default ON): annotates pending knowledge-extraction drafts with freshness (cited `act:` fids positively CLOSED in the item's own project pib-db — parameter-bound lookups via `openPibDb`, now `timeout: 5000` for lock parity with Ring 3) and fold proposals (the watchtower-queue recipe), demoting them out of batch sign-off, never dismissing; act:09184ad7 added a SECOND fold corpus — pending pattern-promotion items, grouped per `evidence.target_member` (cross-member similarity is never a duplicate), so near-duplicate pattern variants arrive pre-annotated for the next consolidation pass (`pattern_items_scanned`/`pattern_fold_annotated`/ `unscanned_pattern_items` counters); act:ea23b3a5 added a THIRD corpus — pending `raised-unhandled` loose ends, grouped per project (`loose_end_items_scanned`/`loose_end_fold_annotated`). That third corpus is where the spec's "aggregate recurring loose ends into ONE item" landed after measurement refused the merge: `proposeFolds` scores with `overlapCoefficient` (act:421a8ab2 retired `unigramJaccard`), whose `min()` denominator lets two three-token titles sharing ONE word clear `FOLD_SIMILARITY_THRESHOLD = 0.22` — four false folds in fifteen pairs against the six live titles — and the five timelog specimens were resolved `deferred` (real work the operator postponed, across two projects and three date ranges), so merging would have buried which gaps remain. The threshold was calibrated for ADVISORY retrieval, not a destructive merge: **a lexical matcher may propose, never silently suppress.** Unreadable dbs and out-of-config items are counted LOUDLY (`skipped_projects`/`unscanned_items`) and every run writes the positive-confirmation sidecar `state/draft-annotations-health.json`, so "no annotations" is distinguishable from "never ran". The slow tier also owns the **memory-budget standing debt + its retraction** (act:ea23b3a5): `surfacePersistentViolations` files ONE accumulating `watchtower-health` item per project instead of a fresh one every 7 days — keyed by CALENDAR DAY (a per-run key would count ~48 cron ticks a day and make the replay guard dead code), appended via `annotateItemEvidence` so `filed_at` is never bumped, carrying `session_count` because that is the spelling `itemSessionWeight` already reads — and `retractClearedMemoryBudgetItems` retracts on the SAME pass over the `passProjects` `runMemoryHygiene` already computes. Deliberately not in Ring 1: a second memory-health producer is forbidden by name in `watchtower-contracts.md`, and at a 30-minute throttle against ring2's 30-minute cadence it would buy zero freshness. Both selectors match the LEGACY `{violations, streak}` title shape as well as the new `debt_class`, because every item on disk when this shipped carried the former. The cabinet-roster review now files only `uncovered-tech` (a proposed cabinet seat is a decision); `dormant-skill` and `stale-briefing` became ambient metrics in `state/roster-review.json` (`parseDormantSkills` reports TRUE counts — the cap bounds the NAME list only) and `retireRosterFindingItems` supersedes any of the two retired kinds still pending, since the filing site was the only code that ever touched them. The slow tier's `scanAuditPatterns` (the pattern-promotion filing site) now runs the act:09184ad7 emission-quality SHAPE GATE — `patternHasRequiredShape` requires the `**Evidence:**` + `**Gap:**` blocks Phase 2e's prompt mandates, rejecting document echoes (wave ledgers, dependency graphs, recipes, transcript fragments — 17/144 items in the 2026-07-26 consolidation) BEFORE the routing Claude call; rejections are counted loudly (`rejected_malformed_total`/`last_scan_rejected` in `state/pattern-detection.json`) and their hashes marked processed, never retried. Calibrated against the consolidation corpus: 120/120 legitimate bodies pass, 17/17 fragments fail. act:02e21a69 closed the hole that gate left — it checked a `**Gap:**` block EXISTED, not that it ASSERTS a gap, so a well-formed positive ("**Gap:** No gap — this is positive practice worth reinforcing") shipped as a promotion. `gapBlockAssertsGap` rejects an empty or gap-negating block, folding into the existing counters AND its own `rejected_gap_negating_total`/`last_scan_rejected_gap_negating` pair; calibrated on the live 2432-section corpus at 12 rejections, with `nothing` measured OUT of the negation list (it rejected a real gap opening on a quotation). Opt-OUT (`defaults.pattern_gap_assertion`), unlike the two dedup corpora — it is a defect fix, not a new suppression surface; hermetic suite in `__tests__/ring2-pattern-gate.test.mjs`), Ring 3 (session close, transcript processing; fires session-close routines as Phase 2j2; runs the standing session advisors as Phase 2m — see below; runs three session-close extraction lenses (act:4ff2cfb3) — Phase 2n raised-but-unhandled (loose ends the session raised but neither did nor filed → inbox category `raised-unhandled`), Phase 2o skill-candidate (a manual procedure repeated by hand → `skill-candidate` inbox item), Phase 2p checklist-catch (a surfaced change-impact check that caught a real bug → `checklist-stats.json`); its Phase 2e quality-pattern prompt is the exported `QUALITY_PATTERN_SYSTEM_PROMPT` carrying the act:09184ad7 generation-side exclusions — no-gap positives, transcript-artifact observations, document echoes are never patterns — the prompt half of ring2's mechanical shape gate, guarded by `__tests__/ring2-pattern-gate.test.mjs`; its Phase 2h feedback "flush" was deleted 2026-06-12 — it marked without delivering), Ring 4 (periodic truth reconciliation, act:36dae795 — stage-1 BUILT, weekly cadence; cron/launchd registration is a deferred `/watchtower install` follow-up). Ring 4 mechanically compares documentary CLAIMS against codebase REALITY and files `doc-drift` inbox items (`filed_by: 'ring4'`): (a) backtick-fenced repo-relative paths missing on disk, gated on a real top-level dir + gitignore-awareness, plus precision gates that skip removal-narrative spans (a same-clause `deleted`/`replaced by`/`renamed` — one live occurrence re-arms the claim), suffix-fragments of a longer real path referenced in the same doc (`bin/mux` pulled out of `templates/mux/bin/mux`), and generated-artifact path segments (`__pycache__` etc.; act:acbf5442); (b) opt-in config-declared count-claim rules. Current-reality docs only (root CLAUDE.md, system-status, briefing files, memory entries — `.claude/plans/` + `.claude/methodology/` excluded as historical record); the memory pass is DRIFT-SUPERSEDE only (hygiene stays Ring 2 slow). Weekly rotation prioritized by git recency, per-run project (3) + item (8) caps, deduped `doc-drift` items. Stage 1 makes NO Claude API call. `templates/scripts/watchtower-ring4.mjs` + `watchtower-ring4-runner.sh` (PID-locked, modeled on Ring 2's); 21 hermetic tests in `__tests__/ring4-reconcile.test.mjs`. Config flags `defaults.truth_reconciliation` + `ring_frequencies.ring4` (604800); contract in `watchtower-contracts.md` ("Ring 4 — Truth Reconciliation (built, stage 1)"). SessionStart/End hooks register conditionally via `mergeWatchtowerHooks()`; the SessionStart context builder (`watchtower-build-context.mjs`) is the home for the environment-advisory pass (`runAdvisoryPass` in `watchtower-advisories.mjs`, act:f9ea075d — NOT Ring 1, whose cron PATH can't reach `claude` for the install-probe) and loads project-root `.claude/memory/patterns/` (top-5) so enforcement lessons keep shaping behavior past orient (act:202e5934). Ships `/watchtower` (install/status/configure/uninstall/sync — configure now manages declared routines; sync content-hash-diffs the 3 script tiers and heals a single-file drift between full reinstalls, act:4e05ff53), `/inbox` (triage extracted knowledge and signals, formerly `/decisions`; its bulk-triage mode carves out gated items first — presented one-by-one with the /briefing Step 3b two-path offer — and executes each approved ungated group via ONE `applyBatch` call), `/briefing` (v2: the single daily surface with /recap alias — a portfolio-wide curator chunked by project, decisions never interleaved; per-chunk batch dispositions executed in-conversation via `applyBatch` with typed reasons; anti-accretion invariant: every "briefing should show X" duty routes through the curator's top-N selection inside the owning project's chunk, no permanent sections; Step 3b enumerates the weighable candidate classes — a new duty adds an entry there, never a section — most recently the backlog-hygiene nudge (fires on the per-project state file's >=3 stale or >=2 completion-candidate counts → consider /spring-clean) and environment advisories (the context builder's `suggested` advisories-state entries, read-only, no probe; act:5e8a9e89), and unprocessed mux DX captures (active items in the mux global `dx.json` whose origin resolves to a walk project, read at Step 1h, drained via `manage-dx.py done`/`mark-filed`; act:891fb9e4); two floors — pending gated items are never curated out, open `qa_verdict.filed_gaps` keep a one-line roll-up; Step 3c runs the M4 SAVE-direction batch sign-off (`partitionForBatchSignoff` over the high-confidence pre-drafted memory drafts) BEFORE the decay proposal (act:ffae4eec); decay = the curator's default stale-batch proposal per chunk, never a global sweep; full mode also spawns the live advisor panel — Step 1g — whose observations route through Step 3b/Step 4, never their own section), `/threads` (read-only cross-project thread map — renders work-thread cursors in plain language and flags segmentation collapse), `/catch-up` (read-only mid-session awareness refresh — diffs current watchtower state against a per-session baseline captured at session start and shows only what CHANGED since; new inbox items, advanced/new threads, new/cleared git attention, freshly-due deferrals; thin orchestrator over `watchtower-snapshot.mjs`; act:a8057f87), `/close` (fast session-end verb — commit + push, plus on an ORPHANED worktree only (unmerged content AND no qa-handoff filed) a conditional offer to land the branch via the existing `/execute` Step 8 / qa-handoff merge-now recipe, so the rings don't file `worktree-unmerged` (act:9ce4dfde) — `/qa-handoff` stays the primary merge path; the background rings handle inventory/capture/routing after you walk away; targets 15–30s, never `--no-verify`; act:8bf86966), and `/qa-handoff` (package a worktree branch into a surfaced `qa-handoff` inbox item — what merged, what the worktree could NOT runtime-verify, what hangs on the next step — then push it to the desk's main window via `mux qa dispatch`; usually filed right after the merge — an unmerged named branch now PROMPTS merge-now (Claude merges → `merged`) vs keep-gated, never a silent `merge-pending` default (act:350e7373); merge-pending is opt-in, filed BEFORE the merge only when the merge is gated on a named external blocker (`evidence.merge_gate`, required at the boundary; act:3d1ac2b7), in which case stage-2 dispatch defers until `markHandoffMerged` records the verified flip — see the watchtower-queue `merge_state` entry above; stages 1–2 of the QA-handoff protocol, `.claude/plans/qa-handoff-protocol.md`). Stage 3 — the drain — is enforced by the staff-QA recipient gate in `watchtower-queue.mjs`: qa-handoff items cannot leave the queue silently (validated `qa_verdict` on resolve, typed reasons on dismiss/supersede, never auto-expires); the playbook, tiers, and verdict shape are single-sourced in the qa-handoff skill's "The recipient gate" section, the producer emits `risk_surface` + `tier_hint` (consumer re-validates), and `/briefing` re-surfaces `qa_verdict.filed_gaps` until closed. The standing session advisors (historian, system-advocate, user-advocate, anthropic-insider) are re-homed to the session boundary (act:aded4fc9): new standing-mandate vocabulary `session-close` (Ring 3 Phase 2m — index-driven roster via `_index.json`, scoped by `directives.session-close`, findings filed as `advisor-finding` inbox items, max 2/member/session, deduped vs pending+resolution corpora, flag `defaults.session_advisors`, reuses Ring 3's pinned-sonnet run) and `briefing` (/briefing's live panel, spawned only on full-mode invocation); their orient/debrief mandates were REMOVED — /briefing re-surfaces fresh findings near the top of the owning project's chunk; contract in `watchtower-contracts.md` ("Session Advisor Pass"). `mux qa drain` is inbox-synced (act:796fe6dc): descriptors are cross-checked against inbox status (resolved ghosts skipped + removed), the offered descriptor parks in `in-flight/` instead of being deleted (restored on next drain if no verdict lands; gate exits clear it), and an empty dispatch queue falls back to walking the inbox for pending qa-handoff items. Ring 3's `threadCapture` mints right-sized, overlapping, concretely-named threads (initiative + project-area + cross-cutting zoom levels; earned multi-membership; rich `display_name`) and writes per-thread `cursor_history` — an append-only array of timestamped cursor snapshots (current cursor = `cursor_history[last].cursor`), so the evolution of understanding is preserved rather than overwritten. Project identity is keyed by the canonical resolver — `resolveProjectIdentity()` in `templates/scripts/watchtower-lib.mjs` (git-aware: worktrees resolve to their main repo's config project). Ring 3, `watchtower-build-context.mjs`, and mux's `worktree-cleanup.sh` all route through it (Ring 3's six independent `basename(cwd)` derivations were deleted — worktree sessions no longer file under phantom keys). The queue item schema carries `project_unresolved` (resolution failed at filing) and `desk` (mux desk at filing time; display metadata only, never a grouping key); `/inbox` renders an "unresolved project" group for flagged items. `watchtower-migrate-keys.mjs` re-keys pre-resolver phantom-key data (dry-run default, `--apply` backs up first, idempotent; wired as one-time install step 2b in the watchtower SKILL.md, whose post-copy coherence assertion checks `resolveProjectIdentity` + `updateThreadFile` + `preserveRing3LastSession` are importable). Thread files and the project-state `## Last Session` section follow a disk-wins / section-ownership contract (`updateThreadFile` + `preserveRing3LastSession` in watchtower-lib.mjs; the model's `is_new` is advisory — disk existence wins; Ring 1 never clobbers Ring 3's authored summary; contract in `watchtower-contracts.md`). Runtime at `~/.claude-cabinet/watchtower/`, refreshed on reinstall by `refreshWatchtowerRuntime()` in `lib/watchtower-setup.js` (act:2da80102, content-aware, refresh-only — see the lib/CLAUDE.md entry). All ring extractions (Ring 2 slow + Ring 3 + Ring 4's `doc-drift`) route through the inbox (watchtower observes, user triages and routes). `watchtower-status` CLI available at `~/.local/bin/`. ## mux (opt-in, off by default) Multi-project terminal manager. Desks (tmux sessions), auto-worktrees with shared project identity (copied `.claude/`, identity symlink, config — workaround for Claude Code #34437; creation is fail-loud — never a silent fallback to the main checkout, and `mux resume` reuses its existing worktree), self-healing worktree health checks (4 checks: path isolation, node_modules, identity slug, .claude/ freshness), `·wt` tab indicator with health-aware coloring (green=healthy, red=issues), double-click popup for health details, auto-cleanup on window close (dirty-detection via the single shared fail-DIRTY `worktree-dirty-check.sh`; carve-out-aware `mux worktree refresh` preserves uncommitted edits to ANY tracked `.claude/` file — tracked = authored, only gitignored infra is disposable, classification single-sourced in `worktree-session-health.sh` and guarded by the `claude-carveout` test suite), worktree lane lifecycle (act:dc80380c: per-project `.mux-worktree-provision` env-file provisioning at spawn, `mux worktree preflight` pre-spawn source check, docker container reap on every removal path — all single-sourced in `worktree-session-health.sh`), live per-worktree excludes + skip-worktree identity-churn suppression so a fully-merged worktree never reads "MERGE OR LOSE" over mux/runtime residue (act:c008862c), trail logging, sticky notes, global DX captures, portal color-switching, durable tmux bindings (`mux.tmux.conf` sourced via `~/.tmux.conf`), clipboard copy with hard-wrap removal (`unwrap-copy.py`), screenshot-to-clipboard launchd watcher (dual-representation: PNG data + file reference), and an MCP server for Claude. Installs to user-level paths (`~/.local/bin/`, `~/.config/mux/`, `~/.local/share/mux/`). ## engagement-server (opt-in, off by default) Central multi-engagement API server deployed once to Railway/Fly. Raw node:http + better-sqlite3, multi-tenant with token-scoped isolation, management CLI, startup migrations, full security hardening. `requires: ['engagement', 'work-tracking']`. Runtime at `~/.claude-cabinet/engagement-server/`. ## bash-compress (opt-in, off by default) PostToolUse hook that compresses noisy Bash stdout (git status walls, npm/yarn install output) to reclaim context in long sessions. stderr and error/warning lines pass through verbatim; every rewrite carries a visible `[compressed]` marker; fail-open on any error. `requires: ['hooks']`. Wired via `mergeBashCompressHooks()`; template `templates/hooks/bash-output-compress.sh`. ## output-register (default-installed) The Cabinet Register (act:9a0af01a): makes plain-English, decision-level communication the shipped DEFAULT instead of guidance that decays. Two halves, BOTH unconditional — dropping either reintroduces the decay the module exists to fix. **(a) The style.** `templates/output-styles/cabinet-register.md` → `~/.claude/output-styles/` (user-level — where Claude Code reads custom styles from), seeded by `lib/output-register.js` via the `output-register-setup` postInstall handler. The register lands in the SYSTEM PROMPT: re-sent in full every request, never decays, unaffected by compaction. That is the strongest placement available — but it is still prompt context, NOT a move up the compliance stack (`enforcement-pipeline.md`), and the module does not claim to be. Every clause traces to an existing operator source (global `CLAUDE.md`, `.claude/rules/plain-english-decisions.md`, `skill-output-conventions.md` §9, `act:f87cef4f`, and named memories); the trailing traceability block is keyed by exact section heading and audited BOTH directions by `test/output-register/`. **(b) The per-turn hook.** `templates/hooks/register-reinforce.sh`, a `UserPromptSubmit` hook emitting ONE line pointing at the register, registered by `mergeRegisterHooks()` (module-gated, exactly as `mergeBashCompressHooks()` is). **Do not "simplify" this away as redundant with (a).** The docs claim "all output styles trigger reminders … during the conversation" — **that is FALSE for CUSTOM styles, and the docs are wrong.** Verified by controlled experiment (two isolated temp projects, headless `claude -p`): built-in `Explanatory` gets the reminder, a custom style gets NONE. The binary agrees — the reminder generator indexes `Lle`, a BUILT-INS-ONLY registry (`default`/`Proactive`/`Explanatory`/`Learning`), and `turn-reminder` does not exist as frontmatter, so a custom style cannot supply one. Anthropic shipping a per-turn reminder for its own styles IS the platform's concession that placement alone doesn't hold a register; custom styles just don't get it, so we supply it. A POINTER, not caveman's full restatement: our rules are already in the system prompt every request, so the line's job is attention, not memory. Silent unless `outputStyle` actually names our style; fail-open, always exit 0 (a `UserPromptSubmit` hook that errors is a spurious failure every turn). **The v2.0.37 floor — the guard that matters, and why a file test is useless.** `keep-coding-instructions` was ADDED in Claude Code v2.0.37 (v1.0.81 released output styles; v2.0.30 deprecated them; v2.0.32 un-deprecated on community feedback; v2.0.37 added the field; v2.1.94 added it for plugin styles). Below v2.0.37 the field is **silently ignored**, its `false` default applies, and Claude Code's software-engineering instructions are **STRIPPED from the system prompt with no error**. A test that the field is present IN THE FILE passes on every version ever shipped and detects this **never** — it guards the author forgetting the field, not the platform refusing to honor it. Only `claude --version` can, hence `versionGate()`, which REFUSES below the floor and fails OPEN when the binary is absent or unparseable (absence is not an old version). For the same reason every check also runs against the **INSTALLED** copy: `templates/` is the one file that cannot cause the failure. CC's coercion is strict `=== true`, so YAML-truthy `yes`/`on`/`1` read as undefined and strip the instructions — `coerceKeepCoding()` mirrors it exactly. **Identity.** Claude Code keys a custom style by its **frontmatter `name`, verbatim** (the filename is only a fallback when `name` is absent) and selects by exact lookup. So `REGISTER_STYLE_NAME` in `lib/output-register.js`, the `STYLE_NAME` in the hook, and the style's frontmatter are ONE identity in three spellings — any drift makes the register silently inert while every file looks right. A test asserts all three agree. **Ownership: seed-if-absent + validate-loudly.** A prose register is the most edit-inviting artifact CC ships. `mux-setup` and `watchtower-setup` are OPPOSITE engines and neither is right here (mux compares a cached manifest hash so a hand edit is never re-examined — the footgun persists forever; watchtower compares on-disk bytes and reconverges — hand edits reverted every reinstall). This engine takes the third path CC already built: `isProjectOwnedSeed()` semantics (`lib/copy.js`, act:2001bf54) — seed if absent, NEVER overwrite, omit from the project manifest — then closes the gap that opens by validating the installed copy on every install and FAILING LOUD rather than silently rewriting it. The `/validate` `output-register` check is the standing detector (warning, not a gate: user-level machine state, not repo structure). **The knob is the platform's own.** `outputStyle`, no new config invented. `.ccrc.json` is deliberately unused — Claude Code never reads it at runtime, so a level stored there could not reach the system prompt. Precedence (verified in the binary, whose own comment reads "Ordered low-to-high priority") is user < project < local < CLI < managed, which gives the per-project override for free. The installer seeds `outputStyle` into the PROJECT's `.claude/settings.json` (a per-project module changing the project, not the portfolio) — seed-if-absent, and an incumbent style at ANY layer is reported and left alone, never clobbered. No dial: one style (operator ruling 2026-07-14); heads-down is a SITUATION the register handles via its contextual valve, not a setting to flip. **`--register` ENUMERATES; it cannot adjudicate.** It is blind to plugin `force-for-plugin` (which overrides `outputStyle` entirely), CLI `--settings`, and managed policy. So it prints what each readable settings file says, names the layers it could not consult, and points at `/status` and `/context` (the system prompt — the only ground truth that the style landed). Its contract is three-valued `{level, ours, source}`: a foreign style reports its literal name with `ours:false`, NEVER collapsing to `off` (two-valued would let the never-clobber guard destroy an `Explanatory`), and an unreadable layer above the winner reports `unknown` rather than a confident `off`. **Not reaching subagents** (verified): "Subagents receive only this system prompt plus basic environment details… not the full Claude Code system prompt" — cabinet members' structured findings are unaffected. A verified containment, not an intention. Full design + dismissed alternatives: `.claude/plans/clear-and-concise-register.md`. ## audit The **audit** module includes a deliberative workflow (`deliberative-audit.js`) that runs audits in two stages: Stage-1 members investigate, Stage-2 critics annotate findings (challenge/support/context/correction). Optional Stage-3 rebuttal lets challenged members respond. Falls back to prompt-driven parallel spawning when the Workflow tool is absent. Triage UI renders annotations inline with color-coded badges and status strips. `merge-findings.js` UNIONS the two artifacts a run dir holds (act:8e1fa16f). They are complementary and merging either alone loses real work: the per-member `.json` files are written by each Stage-1 agent the moment it finishes — guaranteed to survive orchestrator death, but written BEFORE any critic ran, so they carry no annotations and no status (they can also hold findings the workflow itself dropped on a parse failure); `deliberation-report.json` is the workflow's own ranked+annotated set, holding the entire Stage-2/3 outcome plus any finding whose per-member Write failed. So per-member files are the base, the report overlays only its verdict fields (`annotations`, `status`, `rebuttal`, `triageParked` — never member-authored prose or severity), and a finding present on only one side is kept and named in the output. Merging the base alone was the original defect: a production-readiness audit lost 85 annotations and 16 challenges and reported success, and the merge's annotation-handling branch was unreachable through the documented flow, so the code read as though deliberation were handled. Fail-loud now: an unreadable or findings-less report ABORTS (a clean-looking summary with the deliberation missing is the exact shape being fixed), a report carrying zero annotations WARNS, and a post-condition refuses to write a summary carrying fewer annotated findings than the report did — an assertion the union makes unfireable by construction, kept because the defect was a silent loss reported as success. 12 tests in `test/deliberative-audit/deliberation-merge.test.js`. ## memory (v0.27.2+) Provides a curated write/validate layer over Claude Code's built-in file memory: `/cc-remember` writes indexed memories, `/memory` browses them, `validate-memory.mjs` guards MEMORY.md integrity, and `memory-index-guard.sh` (PostToolUse hook) flags writes the just-written file can't be reached from. The index is a bounded **working set** (act:02d15a70, building on the act:a71b4cea cold-tier work): MEMORY.md holds a pinned tier (load-bearing constraints/identity, decay-exempt) + a recency block + **region pointers** (a backtick-glob standing in for a whole class of files), and the optional `MEMORY-archive.md` cold tier stays off the session-start budget (≤200 lines / ≤25KB hot; 50KB cold cap; warns if unlinked). `validate-memory.mjs` check #2 is **reachability, not enumeration** — every on-disk memory must be reachable from MEMORY.md (a direct index line OR a covering region pointer; "present on disk" is not reachable), it fails a stale region pointer (a glob matching nothing on disk), and it samples working-set pressure to `.memory-pressure.jsonl` (≥90% of budget, once/day) — the signal that gates the Stage-2 lifecycle verbs (decay/consolidate/supersede). The model is specified in `templates/cabinet/memory-lifecycle-contract.md`. This replaced the retired omega-memory engine (Python venv) from the v0.27 wind-down. The CLI still ships one-time migration tooling (`--migrate-memory`) for projects upgrading off omega — see `MIGRATION-0.27.md`. ## planning (v0.31.0+) Ships `/generate-plan-groups` and `/execute-group`. `/generate-plan-groups` reads `grp:`-tagged plans from pib-db and groups them for parallel execution (generator only — no execution). `/execute-group` runs one group as a 3-stage composable pipeline with operator checkpoints between stages: (1) interactive CP1 at the skill level — cabinet members pre-review, operator decides proceed/drop/override; (2) `execute-group-implement.js` workflow — parallel worktree implementation + sequential merge, purely mechanical; (3) `execute-group-complete.js` workflow — advisory CP3 (never halts/reverts) + integration check + Completion Report. The only hard automatic gate is merge-delta `/validate`: Stage 2 captures a baseline on main before the first merge, and only NEW failures vs that baseline gate anything (revert at merge, gate at completion) — inherited main debt is reported under `pre_existing_debt`, never gated. CP3 is advisory. The Completion Report is required by the completion hook for grp:-tagged plans (the gate resolves the MAIN checkout for breadcrumbs/report, so worktree invocations land artifacts durably). `checkpoint-protocol.md` documents three CP modes (Interactive, Advisory, Full) and is the shared contract between `/execute` and `/execute-group`. `/execute` is worktree-aware (act:1067adee): its Step 0 reads the worktree-invocation contract and syncs main *into* the worktree (the merge OUT happens once, at close-out); breadcrumb writes resolve to `$MAIN/.claude/verification/`, closing the lost-on-cleanup gap (act:d4767af6); and its Step 8 worktree close-out is MERGE-FIRST (act:3d1ac2b7): re-sync + re-gate, merge + push via `/qa-handoff`'s merge-now recipe (no prompt — merge-now is the default; every failure HALTs loudly, the action stays open), then file a `merged` qa-handoff that dispatches unconditionally. Done is marked only after merge + filing succeed. `merge-pending` is reserved for an explicitly gated merge (`evidence.merge_gate` required). Without watchtower the close-out still merges, then degrades loudly (never silently) — the no-handoff note names what to QA manually. On the main checkout all of this no-ops.