create-claude-cabinet 0.44.0 → 0.46.0

package/lib/watchtower-setup.js

@@ -0,0 +1,210 @@
+/**
+ * watchtower-setup.js — keep the GLOBAL watchtower runtime fresh on reinstall.
+ *
+ * The watchtower module copies its files into the PROJECT (the normal module
+ * copy in lib/cli.js). But the GLOBAL runtime at ~/.claude-cabinet/watchtower/
+ * is only ever set up by the manual `/watchtower install` SKILL.md one-time
+ * step. So `npx create-claude-cabinet` (reinstall) refreshed the project files
+ * but NOT the global runtime scripts/docs/hooks — they went stale, and a
+ * brand-new runtime script (e.g. watchtower-advisories.mjs) never appeared
+ * until a hand-copy.
+ *
+ * This installer mirrors lib/mux-setup.js's content-aware refresh: a global
+ * SHA256 manifest at ~/.claude-cabinet/global-manifest.json records each
+ * dest's last-written hash, and only changed-or-new files are copied. Reusing
+ * mux's manifest is safe — entries are keyed by absolute dest path, so the
+ * watchtower dests (~/.claude-cabinet/watchtower/...) never collide with mux's
+ * (~/.config/mux/..., ~/.local/bin/...).
+ *
+ * REFRESH-ONLY semantics (critical): if the runtime directory does NOT already
+ * exist, this returns immediately with status 'absent' and writes nothing.
+ * Fresh runtime setup — launchd plist / cron, config.json, migrate-keys, the
+ * coherence assertion — is the `/watchtower install` SKILL.md step's job and is
+ * NOT replicated here. This function only keeps the code/docs/hooks of an
+ * EXISTING runtime current.
+ *
+ * The .mjs script set is globbed from templates/scripts/watchtower-*.mjs at
+ * load time (single source of truth — a newly shipped runtime script is picked
+ * up automatically; that "new file appears" case was the watchtower-advisories
+ * failure). The shell runners, session hooks, and cabinet docs are mapped
+ * explicitly since they live in different template subtrees and land in
+ * different runtime subdirs.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const CC_HOME = path.join(os.homedir(), '.claude-cabinet');
+const GLOBAL_MANIFEST_PATH = path.join(CC_HOME, 'global-manifest.json');
+const RUNTIME_DIR = path.join(CC_HOME, 'watchtower');
+const RUNTIME_SCRIPTS_DIR = path.join(RUNTIME_DIR, 'scripts');
+const RUNTIME_HOOKS_DIR = path.join(RUNTIME_DIR, 'hooks');
+const RUNTIME_CABINET_DIR = path.join(RUNTIME_DIR, 'cabinet');
+const TEMPLATE_DIR = path.resolve(__dirname, '..', 'templates');
+
+/**
+ * Build the MANAGED_FILES list: { src (absolute), dest (absolute), mode? }.
+ *
+ *   - ALL templates/scripts/watchtower-*.mjs       → runtime scripts/
+ *   - the watchtower shell runners under scripts/   → runtime scripts/ (0o755)
+ *   - templates/hooks/watchtower-session-*.sh       → runtime hooks/   (0o755)
+ *   - the two cabinet docs                          → runtime cabinet/
+ *
+ * Globbing the .mjs set keeps it the single source of truth — no hand-picked
+ * subset that can drift as new runtime scripts ship.
+ */
+function buildManagedFiles() {
+  const files = [];
+  const scriptsDir = path.join(TEMPLATE_DIR, 'scripts');
+
+  // All watchtower runtime .mjs scripts (globbed — complete set, no drift).
+  if (fs.existsSync(scriptsDir)) {
+    for (const name of fs.readdirSync(scriptsDir)) {
+      if (/^watchtower-.*\.mjs$/.test(name)) {
+        files.push({
+          src: path.join(scriptsDir, name),
+          dest: path.join(RUNTIME_SCRIPTS_DIR, name),
+        });
+      }
+    }
+  }
+
+  // Shell runners the runtime executes (cron/launchd target these). They live
+  // in templates/scripts/ and land beside the .mjs in the runtime scripts/ dir.
+  const shellRunners = [
+    'watchtower-ring1-runner.sh',
+    'watchtower-ring2-runner.sh',
+    'watchtower-status.sh',
+  ];
+  for (const name of shellRunners) {
+    files.push({
+      src: path.join(scriptsDir, name),
+      dest: path.join(RUNTIME_SCRIPTS_DIR, name),
+      mode: 0o755,
+    });
+  }
+
+  // Session hooks → runtime hooks/.
+  const hooksDir = path.join(TEMPLATE_DIR, 'hooks');
+  for (const name of ['watchtower-session-start.sh', 'watchtower-session-end.sh']) {
+    files.push({
+      src: path.join(hooksDir, name),
+      dest: path.join(RUNTIME_HOOKS_DIR, name),
+      mode: 0o755,
+    });
+  }
+
+  // Cabinet docs the runtime / advisory pass reads → runtime cabinet/.
+  const cabinetDir = path.join(TEMPLATE_DIR, 'cabinet');
+  for (const name of ['advisories-state-schema.md', 'watchtower-contracts.md']) {
+    files.push({
+      src: path.join(cabinetDir, name),
+      dest: path.join(RUNTIME_CABINET_DIR, name),
+    });
+  }
+
+  return files;
+}
+
+const MANAGED_FILES = buildManagedFiles();
+
+function sha256(content) {
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+function readGlobalManifest() {
+  if (!fs.existsSync(GLOBAL_MANIFEST_PATH)) return { files: {} };
+  try {
+    const m = JSON.parse(fs.readFileSync(GLOBAL_MANIFEST_PATH, 'utf8'));
+    // Guard shape drift: manifest.files is indexed unconditionally below.
+    if (typeof m !== 'object' || m === null || Array.isArray(m)) return { files: {} };
+    if (typeof m.files !== 'object' || m.files === null || Array.isArray(m.files)) m.files = {};
+    return m;
+  } catch {
+    return { files: {} };
+  }
+}
+
+function writeGlobalManifest(manifest) {
+  fs.mkdirSync(path.dirname(GLOBAL_MANIFEST_PATH), { recursive: true });
+  const tmp = GLOBAL_MANIFEST_PATH + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(manifest, null, 2));
+  fs.renameSync(tmp, GLOBAL_MANIFEST_PATH);
+}
+
+/**
+ * Refresh the code/docs/hooks of an EXISTING watchtower runtime, content-aware.
+ *
+ * @param {Object} opts
+ * @param {boolean} [opts.dryRun]
+ * @param {string[]} [opts.results] — human-readable lines are pushed here; a
+ *   fresh array is created and returned when not supplied.
+ * @returns {{ results: string[], status: 'absent'|'unchanged'|'refreshed' }}
+ */
+function refreshWatchtowerRuntime(opts = {}) {
+  const dryRun = !!opts.dryRun;
+  const results = opts.results || [];
+
+  // Refresh-only: never bootstrap a fresh runtime here. Fresh setup (launchd,
+  // cron, config.json, migrate-keys, coherence assertion) is the
+  // `/watchtower install` SKILL.md step's job. No runtime dir ⇒ no-op.
+  if (!fs.existsSync(RUNTIME_DIR)) {
+    return { results, status: 'absent' };
+  }
+
+  results.push('Refreshing watchtower runtime (content-aware)');
+
+  const manifest = readGlobalManifest();
+  let copiedCount = 0;
+
+  for (const file of MANAGED_FILES) {
+    if (!fs.existsSync(file.src)) {
+      results.push(`  ⚠ Template missing: ${file.src}`);
+      continue;
+    }
+
+    const content = fs.readFileSync(file.src);
+    const hash = sha256(content);
+
+    if (manifest.files[file.dest] === hash) {
+      continue; // file unchanged
+    }
+
+    if (dryRun) {
+      results.push(`  [dry-run] ${path.relative(TEMPLATE_DIR, file.src)} → ${file.dest}`);
+    } else {
+      fs.mkdirSync(path.dirname(file.dest), { recursive: true });
+      fs.writeFileSync(file.dest, content);
+      if (file.mode) {
+        fs.chmodSync(file.dest, file.mode);
+      }
+      manifest.files[file.dest] = hash;
+    }
+    copiedCount++;
+  }
+
+  if (!dryRun && copiedCount > 0) {
+    manifest.installedAt = new Date().toISOString();
+    writeGlobalManifest(manifest);
+  }
+
+  if (copiedCount > 0) {
+    results.push(`  ${copiedCount} runtime file${copiedCount !== 1 ? 's' : ''} refreshed under ${RUNTIME_DIR}`);
+    return { results, status: 'refreshed' };
+  }
+
+  results.push('  watchtower runtime already current');
+  return { results, status: 'unchanged' };
+}
+
+// MANAGED_FILES, RUNTIME_DIR, and TEMPLATE_DIR are exported for the
+// runtime-refresh test so it can seed a faithful, complete global manifest
+// (single source of truth — the test never re-derives the file list).
+module.exports = {
+  refreshWatchtowerRuntime,
+  MANAGED_FILES,
+  RUNTIME_DIR,
+  TEMPLATE_DIR,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.44.0",
+  "version": "0.46.0",
   "description": "Claude Cabinet — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-cabinet": "bin/create-claude-cabinet.js"
@@ -22,6 +22,10 @@
   ],
   "author": "Oren Magid",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orenmagid/claude-cabinet.git"
+  },
   "engines": {
     "node": ">=18"
   },

package/templates/cabinet/_cabinet-member-template.md

@@ -27,7 +27,10 @@ briefing:
   # Common: .claude/cabinet/_briefing-architecture.md, _briefing-jurisdictions.md, _briefing-api.md
 standing-mandate: audit
   # Add plan, execute, orient, debrief if this member should activate
-  # in those contexts. Most members are audit-only.
+  # in those contexts. Most members are audit-only. Two session-boundary
+  # contexts exist for standing advisors (watchtower installs):
+  # session-close (Ring 3's automatic transcript-fed advisor pass) and
+  # briefing (/briefing's live advisor panel).
 tools:
   # List every external tool/command this member uses.
   # Format: "tool-name (scope -- what it does)"
@@ -37,8 +40,10 @@ tools:
   #   - grep patterns (all projects -- dead code detection)
   # Use "tools: []" for pure-reasoning members with no tool stage.
 directives:
-  # Only if standing-mandate includes plan, execute, orient, or debrief.
-  # Each directive is a one-sentence focused task for that context.
+  # Only if standing-mandate includes plan, execute, orient, debrief,
+  # session-close, or briefing. Each directive is a one-sentence focused
+  # task for that context. A mandate without a matching directive is a
+  # data error — consumers skip the member and say so.
   # plan: >
   #   What to evaluate when reviewing a plan.
   # execute: >

package/templates/cabinet/advisories-state-schema.md

@@ -1,12 +1,18 @@
 # Advisory dismissal state — schema and rules
 
-Orient surfaces stack-aware advisories (install the Ruby language server, register the Railway MCP, install `hookify`, …). Without memory, every advisory re-nags every session — the same attention-fatigue pattern the watchtower rings were built to eliminate. This file defines the per-project state that gives advisories a memory, and the exact rules orient follows so an advisory is never *permanently* silenced by accident.
+The watchtower **SessionStart context builder** surfaces stack-aware advisories (install the Ruby language server, register the Railway MCP, install `hookify`, …) via `scripts/watchtower-advisories.mjs` (act:f9ea075d). Without memory, every advisory re-nags every session — the same attention-fatigue pattern the watchtower rings were built to eliminate. This file defines the per-project state that gives advisories a memory, and the exact rules the advisory pass follows so an advisory is never *permanently* silenced by accident.
+
+> **Actor.** The owner of these rules is `watchtower-advisories.mjs` (`runAdvisoryPass`), called by the context builder when watchtower is installed. On a project WITHOUT watchtower, orient runs a thin one-shot fallback (it may shell the same module via `node scripts/watchtower-advisories.mjs` when present, else surface basic install hints with no persistent dismissal state). The module is the single implementation of the rules below; do not re-encode them anywhere else.
 
 ## Where it lives
 
-`.claude/cabinet/advisories-state.json` — **per project, generated at runtime**, NOT shipped as a template. Orient creates it on first write. It must never be added to a module's template array: a shipped stub would overwrite a project's real dismissal history on reinstall (the `.ccrc.json` clobber class of bug). If the file is absent, every advisory is treated as never-seen.
+`.claude/cabinet/advisories-state.json` — **per project, generated at runtime**, NOT shipped as a template. The advisory pass creates it on first write. It must never be added to a module's template array: a shipped stub would overwrite a project's real dismissal history on reinstall (the `.ccrc.json` clobber class of bug). If the file is absent OR malformed JSON, every advisory is treated as never-seen (the reader degrades to `{}`, never throws).
+
+> Worktree note: `.claude/cabinet/` is copied per worktree, so dismissal state can diverge between a worktree and its main checkout. That is acceptable — advisories are advisory — and is the reason this is project-local, not user-global. **Path-consistency rule:** the pass reads AND writes the state at the SAME path (the session's `--project-path` cwd). Never read from one path and write to another, or a decline recorded in one place is invisible from the other and the advisory re-nags forever.
+
+## Reserved `_meta` key
 
-> Worktree note: `.claude/cabinet/` is copied per worktree, so dismissal state can diverge between a worktree and its main checkout. That is acceptable — advisories are advisory — and is the reason this is project-local, not user-global.
+`_meta` is a **reserved top-level key**, NOT an advisory entry. It holds pass-level bookkeeping — currently `{ "last_probe": "<UTC YYYY-MM-DD>" }`, the throttle stamp for the `claude plugin list` install-probe (run at most once/day/checkout; UTC to match `last_shown` and sqlite `date('now')`). Any consumer iterating advisory entries (e.g. `Object.entries(state)`) MUST skip `_meta`. No advisory id may be named `_meta`.
 
 ## Schema
 
@@ -30,9 +36,26 @@ Orient surfaces stack-aware advisories (install the Ruby language server, regist
 - **`last_shown`** — ISO date of the most recent surfacing.
 - **`signal`** — *the key field that makes "resurface if the stack changed" actually work.* A short, deterministic fingerprint of the stack indicators present when the advisory was last shown/declined. For a multi-indicator advisory like Ruby (`Gemfile` OR `*.rb`), the fingerprint records *which* indicators were present (e.g. `gemfile` vs `gemfile+rb`), so a later change is detectable. Without this stored snapshot, orient has only the *current* indicators and no baseline to diff against — which is the gap this schema closes.
 
-## The rules orient follows
+## Computing the signal (the indicator fingerprint)
+
+A signal is a deterministic fingerprint of the stack indicators present now. Two rules keep it stable:
+
+- **Sorted tokens.** A multi-indicator advisory joins its present indicators (e.g. Ruby = `gemfile`, `rb`, or `gemfile+rb`) **after sorting** them. Readdir order is not stable; without the sort, `gemfile+rb` and `rb+gemfile` would alternate and spuriously re-arm a declined advisory every session.
+- **Bounded stack scan.** Source-file indicators (`*.ts`, `*.py`, `*.rb`) are detected by a **depth-limited (≤3) walk** with a denylist (`node_modules`, `dist`, `build`, `vendor`, `coverage`, `target`, `out`, plus all dot-dirs) and **early-exit on first match** (existence only). A recursive walk would be pathological on the session-start critical path; a root-only scan would silently miss the common `src/**/*.ts` layout (a TS project with no root `tsconfig.json`).
+
+## The probe is tri-state (the fourth input state)
 
-Before surfacing any advisory, orient computes the advisory's **current signal** (fingerprint of the indicators present now) and reads the stored entry:
+The install-probe (`claude plugin list`) answers "is this plugin installed?" — but it can fail to answer (claude not on PATH, nonzero exit, timeout). Its result is therefore **`true | false | null`**, never a boolean. `null` ("unknown") is a distinct input state and is handled per advisory **kind**:
+
+- **probe-suppressed** (the LSP advisories): the signal is on disk (stack files); the probe only *suppresses* (confirms installed → terminal). `installed===null` → **still surface** from the signal/state rules; freeze only the `installed` transition.
+- **probe-gated** (`plugin:hookify`): the surfacing predicate *is* the probe ("hookify not installed"). `installed===null` → predicate unknowable → **suppress this session, do NOT increment count, do NOT write state** (freeze the entry untouched).
+- **no-probe** (`mcp:railway`, `briefing-file`, `registry-orphan`): pure filesystem/config signal; the probe is irrelevant.
+
+In all kinds, `installed===true` flips the entry to terminal `installed`.
+
+## The rules the advisory pass follows
+
+Before surfacing any advisory, the pass computes the advisory's **current signal** (fingerprint of the indicators present now) and reads the stored entry:
 
 1. **No entry / file absent** → surface it. Write `{status:"suggested", count:1, last_shown:today, signal:current}`.
 2. **`installed`** → never surface (terminal). (Re-probe may flip a `suggested`/`declined` entry to `installed`; never the reverse automatically.)
@@ -64,5 +87,9 @@ Document any new advisory's signal source here when you add it, and call out exp
 | `lsp:rust` | `Cargo.toml` | `/plugin install rust-analyzer-lsp` |
 | `lsp:go` | `go.mod` | `/plugin install gopls-lsp` |
 | `lsp:ruby` | `Gemfile` or `*.rb` | `/plugin install ruby-lsp@claude-plugins-official` (also needs `gem install ruby-lsp` AND `ENABLE_LSP_TOOL=1`) |
-| `mcp:railway` | `railway.toml` and no railway key in `~/.claude.json` | local: `railway setup agent -y` · remote: register `mcp.railway.com` (OAuth) |
-| `plugin:hookify` | `.claude/rules/enforcement-pipeline.md` exists and hookify not in `claude plugin list` (signal is **static**) | `/plugin install hookify` |
+| `mcp:railway` | `railway.toml` and no railway key in `~/.claude.json` (no-probe) | local: `railway setup agent -y` · remote: register `mcp.railway.com` (OAuth) |
+| `plugin:hookify` | `.claude/rules/enforcement-pipeline.md` exists and hookify not in `claude plugin list` (signal is **static**; probe-gated) | `/plugin install hookify` |
+| `briefing-file` | `.claude/briefing/_briefing.md` is **absent** (signal `missing`, **static**; no-probe) | run `/onboard` to create one |
+| `registry-orphan` | `~/.claude/cc-registry.json` lists project path(s) that no longer exist (signal = sorted orphan-name set, so it re-arms when the registry changes; no-probe) | remove the dead entr(y/ies) from `~/.claude/cc-registry.json` |
+
+> Note: `mcp:railway` keys on `railway.toml`, which Ring 1 also marker-checks for deploy detection — these are independent reads of the same file for different purposes; do not consolidate them (the advisory adds the `~/.claude.json` registration predicate Ring 1 lacks).

package/templates/cabinet/checklist-stats-schema.md

@@ -0,0 +1,104 @@
+# Checklist Stats — hit-rate sidecar schema and write protocol
+
+`.claude/cabinet/checklist-stats.json` records how the change-impact
+checklist (`qa-dimensions.yaml`) performs over time: which dimensions
+fire, which checks actually catch problems, and what pruning verdicts
+the operator has already given. It is the evidence base for the audit
+skill's `checklist-pruning` phase — without it, the checklist only ever
+grows (debrief's `checklist-feedback` is add-only by design) and decays
+into noise.
+
+**This file is RUNTIME STATE, generated on first write — never shipped
+as a template.** Shipping it would clobber accumulated stats on every
+reinstall (same rule as `advisories-state-schema.md`). And it never
+lives inside `qa-dimensions.yaml`: config files do not contain runtime
+state.
+
+## Who writes what
+
+| Writer | When | What |
+|--------|------|------|
+| `/execute` `post-impl-checklist` phase | every run past its no-op guard | increments `runs`; per triggered dimension increments `fires`, sets `last_fired` |
+| `/debrief` `checklist-feedback` phase | when a session bug WAS caught via a surfaced check | appends to that dimension's `catches` |
+| `/audit` `checklist-pruning` phase | every pruning verdict (including "keep") | appends to `pruning_reviews` |
+
+## Schema (`schema_version: 1`)
+
+```json
+{
+  "schema_version": 1,
+  "runs": 14,
+  "dimensions": {
+    "data-coherence": {
+      "fires": 12,
+      "last_fired": "2026-06-11",
+      "catches": [
+        {
+          "date": "2026-06-10",
+          "check": "[run] Run schema validation if any schema or migration file changed.",
+          "note": "caught missing FK backfill before commit"
+        }
+      ]
+    }
+  },
+  "pruning_reviews": [
+    {
+      "date": "2026-06-11",
+      "target": "test-staleness",
+      "verdict": "keep",
+      "note": "fires often, zero catches, but cheap insurance at moderate severity"
+    }
+  ]
+}
+```
+
+Field semantics:
+
+- **`runs`** — total executions of the post-impl-checklist phase that
+  passed its no-op guard, INCLUDING runs where zero dimensions
+  triggered. This is the denominator for "never fired in N runs."
+- **`dimensions.<name>.fires`** — number of runs in which the dimension
+  triggered (matched at least one changed path). Dimension-level, not
+  check-level: checks have no stable IDs, so firing is counted where it
+  happens (path match) and catching is attributed by quoting the check.
+- **`dimensions.<name>.catches`** — append-only evidence that a
+  surfaced check caught a real issue. `check` quotes the check text as
+  written in the yaml at the time.
+- **`pruning_reviews`** — append-only verdict log. `verdict` is one of
+  `removed | trimmed | paths-fixed | severity-changed | keep`. The
+  pruning phase skips candidates with any verdict in the last 90 days,
+  so a "keep" decision is not re-litigated at every audit.
+
+## Write protocol
+
+1. Read the file. If absent, bootstrap the skeleton
+   (`{"schema_version": 1, "runs": 0, "dimensions": {}, "pruning_reviews": []}`).
+   If present but unparseable, move it aside to
+   `checklist-stats.json.corrupt-<YYYY-MM-DD>` (never delete) and
+   bootstrap fresh.
+2. Modify in memory.
+3. Write to `checklist-stats.json.tmp`, then rename over the original
+   (atomic — safe under concurrent sessions).
+
+**Fail-open, always:** a stats read or write failure must never block
+the phase doing the recording. Emit one warning line and continue —
+losing a data point is fine; blocking an execute/debrief/audit run over
+bookkeeping is not.
+
+## Anti-trap rules
+
+- **Stats inform; the human decides.** Nothing auto-prunes from this
+  data, ever. Low hit-rate is evidence presented at audit, not a
+  trigger.
+- **Per-dimension judgment, not universal thresholds.** A high-severity
+  security check that fires often and never catches may still be cheap
+  insurance; an info-severity check with the same profile is noise.
+  The pruning phase presents severity alongside the numbers.
+- **Renames orphan stats.** If a dimension is renamed in
+  `qa-dimensions.yaml`, its stats entry goes stale. The pruning phase
+  reports entries with no matching dimension as orphans (offer to fold
+  or drop them); writers simply start a fresh entry under the new name.
+- **Counts are honest, not precise.** Concurrent sessions can lose an
+  increment to a race; the rename-based write keeps the file valid and
+  the trend signal is what matters. Do not build exact-count logic on
+  top of this file.

package/templates/cabinet/checkpoint-protocol.md

@@ -37,7 +37,7 @@ high-stakes reviews is to put judgment in front of the operator.
 | Mode | Where it runs | What a `stop`/`pause` does | Used by |
 |------|---------------|----------------------------|---------|
 | **Interactive CP** | Main session (skill level) | Surfaced to the operator, who decides (proceed / drop / override / abort). Never automatic. | `/execute-group` CP1 |
-| **Advisory CP** | Workflow | Recorded in the Completion Report as a concern. Never halts or reverts. The only automatic gate alongside it is `/validate`. | `/execute-group` CP3 |
+| **Advisory CP** | Workflow | Recorded in the Completion Report as a concern. Never halts or reverts. The only automatic gate alongside it is merge-delta `/validate` — new failures vs the group's pre-merge baseline; inherited debt is reported, not gated. | `/execute-group` CP3 |
 | **Full CP** | Main session or workflow | Halts on `stop`, escalates 3+ `pause` to a halt, requires explicit override. The classic gate. | `/execute` CP1/CP2/CP3 |
 
 **Why Interactive and Advisory exist.** `/execute-group` once ran CP1 and CP3
@@ -45,8 +45,20 @@ as autonomous gates inside a single workflow: a cabinet `stop` halted the run
 or reverted a merge with no human in the loop. False positives there cost real
 money (a CP1 halted twice consecutively — 1.6M+ tokens — on concerns the plan
 text already addressed). Moving CP1 to interactive (operator decides) and CP3
-to advisory (concerns recorded, `/validate` is the only hard gate) keeps the
-review signal while removing the destructive autonomous action.
+to advisory (concerns recorded, merge-delta `/validate` is the only hard
+gate) keeps the review signal while removing the destructive autonomous
+action.
+
+**The hard gate is merge-delta, not absolute.** `/execute-group` captures a
+`/validate` baseline on main before the group's first merge. Only failures
+NOT in that baseline (i.e. failures the group itself introduced) gate a merge
+or completion. Failures that pre-date the group are inherited debt: listed
+loudly in the Completion Report's `pre_existing_debt` section, never gated.
+This too is field-driven — two consecutive groups were gated on documented
+pre-existing main debt with zero merge-delta regressions, and the manual
+recovery (judge the delta by hand, close the plans) ran identically both
+times, so the delta judgment was promoted into the gate itself. The gate
+stays hard for new failures: the point is removing ritual, not weakening it.
 
 ### Interactive CP adds a required `addressed_by_plan` field
 
@@ -154,8 +166,8 @@ At **Interactive CP** (`/execute-group` CP1), add the required
 The escalation below is **Full CP** behavior (used by `/execute`). For
 **Interactive CP** the verdicts are surfaced to the operator severity-first
 and the operator decides — no automatic halt. For **Advisory CP** the concerns
-are recorded in the Completion Report and nothing halts or reverts; `/validate`
-is the only automatic gate. See "Checkpoint modes" above.
+are recorded in the Completion Report and nothing halts or reverts; merge-delta
+`/validate` is the only automatic gate. See "Checkpoint modes" above.
 
 Collect every verdict, then:
 

package/templates/cabinet/composition-patterns.md

@@ -107,9 +107,10 @@ to do its own work. One cabinet member consults another mid-evaluation.
 needs full conversation history) references another cabinet member's known
 findings — from memory, from audit history, or from prior session output.
 
-**Example:** During debrief, a historian cabinet member is activated to check:
-"Has this kind of change been done before? What happened? Are there
-lessons from prior sessions relevant to what was just completed?"
+**Example:** At session close (Ring 3's advisor pass), the historian is
+activated to check: "Has this kind of change been done before? What
+happened? Are there lessons from prior sessions relevant to what was
+just completed?"
 
 **Example:** During planning, the organized-mind cabinet member might need
 the historian's input: "Has this kind of information architecture been

package/templates/cabinet/qa-dimensions-template.yaml

@@ -11,6 +11,13 @@
 # and surfaces the matched dimensions' checks as context for the
 # pre-commit cabinet sweep (Checkpoint 3). QA is the primary consumer.
 #
+# The checklist learns in both directions: /debrief's checklist-feedback
+# phase ADDS checks when bugs slip through, and /audit's
+# checklist-pruning phase surfaces low-hit-rate dimensions for
+# human-approved REMOVAL (evidence lives in checklist-stats.json — see
+# cabinet/checklist-stats-schema.md; runtime state never lives in this
+# file).
+#
 # ── Schema ────────────────────────────────────────────────────────
 # dimensions:                  # top-level map; keys are dimension names
 #   <dimension-name>:

package/templates/cabinet/skill-output-conventions.md

@@ -133,7 +133,41 @@ that format here; reference it.
 user's actual situation. This applies whether the choice is rendered via
 AskUserQuestion or prose — the primitive changes, the posture doesn't.
 
-## 9. Calibration Examples
+## 9. Operator-Facing Register: Plain English by Default
+
+When a skill addresses the operator about substantial work — a plan, an
+audit finding, a checkpoint decision, a status report — there are **two
+readers, and they need two registers:**
+
+- **The filed artifact** (the plan in pib-db, the finding's record, the
+  report on disk) stays **technical and complete** — exact file paths,
+  function names, fids, acceptance criteria. A future session executes
+  from it cold, so precision is the whole point.
+- **What you SAY to the operator** is **plain English** — concept first,
+  the stakes spelled out, any decision framed as options with tradeoffs.
+  Keep file paths and symbol names out of the spoken prose; they live in
+  the filed artifact, reachable on request or behind a collapsed
+  "full detail" pointer.
+
+The operator is the director, not the implementer (see the user-role
+brief): they decide *what* and *why* and must be able to weigh in without
+parsing every technical detail. A wall of paths and identifiers is noise
+to that judgment — it buries the one thing they're being asked to decide.
+Lead with what changed and why it matters; keep the file-and-line
+narrative for the record.
+
+This is the **default register** for operator-facing skill output. It
+does NOT relax the filed artifact's rigor — a plan still files
+QA-compliant notes, an audit still records exact locations. The split is
+between the *record* (technical) and the *briefing* (plain). When in
+doubt, write the briefing as if explaining to a sharp colleague who
+hasn't seen the code.
+
+This is a *register* rule (how to phrase), distinct from §5 (prose vs
+dialog as the *primitive*) and §8 (present-don't-prescribe as the
+*posture*) — all three compose.
+
+## 10. Calibration Examples
 
 **Before/after — engagement decision items** (the Tier 1 conversion):