create-claude-cabinet 0.44.0 → 0.45.0

package/README.md

@@ -241,8 +241,13 @@ npx create-claude-cabinet --yes                   # Accept all defaults
 npx create-claude-cabinet --yes --no-db           # All defaults, skip database
 npx create-claude-cabinet --dry-run               # Preview without writing files
 npx create-claude-cabinet --modules verify --yes  # Add an opt-in module (merges, doesn't replace)
+npx create-claude-cabinet --frontier-model claude-fable-5  # Designate your frontier model (watchdog)
 ```
 
+### Frontier-model watchdog
+
+`--frontier-model <model>` records, once, which model your heavy thinking is supposed to run on. The designation is per-operator (stored in `~/.claude/cc-registry.json` under `frontierModel`, not per-project), and the installer prints the effective value on every run. From then on, `/orient` — and, on watchtower installs, the SessionStart hook — compares the session's actual model against it and leads the briefing with a loud warning on mismatch. The key can be an exact model ID (`claude-fable-5`, exact match required) or a family alias (`fable`, matches any model ID containing it). This is **visibility only**: nothing is pinned, blocked, or rerouted — it just makes "you're accidentally on the wrong model" impossible to miss. A stale key after a model-family transition nags loudly by design; update it with the same flag.
+
 ## What Gets Installed
 
 Everything goes into `.claude/` or `scripts/`. Nothing touches your

package/lib/cli.js

@@ -3,7 +3,7 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const crypto = require('crypto');
-const { copyTemplates } = require('./copy');
+const { copyTemplates, recordSkip } = require('./copy');
 const { mergeSettings, healUserSettings, mergeWatchtowerHooks, mergeMuxHooks, mergeBashCompressHooks } = require('./settings-merge');
 const { create: createMetadata, read: readMetadata } = require('./metadata');
 const { setupDb } = require('./db-setup');
@@ -460,11 +460,13 @@ const MODULES = {
       'skills/orient-quick',
       'skills/debrief',
       'skills/debrief-quick',
+      'skills/session-handoff',
       // Instruction phases — always ship, overriding the default skip-phases rule in copy.js
       'skills/debrief/phases/audit-pattern-capture.md',
       'skills/debrief/phases/methodology-capture.md',
       'skills/debrief/phases/record-lessons.md',
       'skills/debrief/phases/upstream-feedback.md',
+      'skills/debrief/phases/qa-handoff-sweep.md',
       'skills/menu',
     ],
   },
@@ -491,7 +493,7 @@ const MODULES = {
     mandatory: false,
     default: true,
     lean: true,
-    templates: ['skills/plan', 'skills/execute', 'skills/execute/phases/post-impl-checklist.md', 'skills/debrief/phases/checklist-feedback.md', 'skills/checklist-discover', 'skills/generate-plan-groups', 'skills/execute-group', 'workflows/execute-group-implement.js', 'workflows/execute-group-complete.js', 'skills/investigate', 'cabinet/checkpoint-protocol.md', 'cabinet/elicitation-methods.md', 'cabinet/qa-dimensions-template.yaml', 'scripts/qa-dimensions-validator.cjs', 'skills/orient/phases/checklist-status.md'],
+    templates: ['skills/plan', 'skills/execute', 'skills/execute/phases/post-impl-checklist.md', 'skills/debrief/phases/checklist-feedback.md', 'skills/checklist-discover', 'skills/generate-plan-groups', 'skills/execute-group', 'workflows/execute-group-implement.js', 'workflows/execute-group-complete.js', 'skills/investigate', 'cabinet/checkpoint-protocol.md', 'cabinet/elicitation-methods.md', 'cabinet/qa-dimensions-template.yaml', 'cabinet/checklist-stats-schema.md', 'scripts/qa-dimensions-validator.cjs', 'skills/orient/phases/checklist-status.md', 'skills/audit/phases/checklist-pruning.md'],
   },
   'compliance': {
     name: 'Compliance Stack (rules + enforcement)',
@@ -750,6 +752,14 @@ function parseArgs(argv) {
     else if (arg === '--modules' && i + 1 < args.length) {
       flags.modules = args[++i].split(',').map(s => s.trim()).filter(Boolean);
     }
+    else if (arg === '--frontier-model' && i + 1 < args.length) {
+      // Empty/whitespace values are treated as absent: '' is a substring of
+      // every model ID, which would match everything and leave the watchdog
+      // permanently silent while appearing configured.
+      const value = args[++i].trim();
+      if (value) flags.frontierModel = value;
+      else flags.frontierModelEmpty = true;
+    }
     else if (!arg.startsWith('-')) flags.targetDir = arg;
   }
 
@@ -775,6 +785,11 @@ function printHelp() {
                   disables omega hooks/MCP. Idempotent — safe to re-run.
                   Pair with --dry-run to preview.
     --unmigrate-memory   Roll back --migrate-memory using its backup dir.
+    --frontier-model <model>  Designate your frontier model (user-level, stored
+                  in ~/.claude/cc-registry.json). Visibility only: /orient and
+                  the watchtower SessionStart hook warn loudly when a session
+                  runs a different model. Does NOT pin or route anything.
+                  Accepts an exact ID (claude-fable-5) or a family alias (fable).
     --help, -h    Show this help
 
   Examples:
@@ -1214,7 +1229,7 @@ async function run() {
           const existingContent = fs.readFileSync(destPath, 'utf8');
           if (existingContent === incoming) {
             totalSkipped++;
-            allManifest[mPath] = incomingHash;
+            recordSkip(allManifest, mPath, { identical: true, incomingHash });
             continue;
           }
 
@@ -1230,7 +1245,9 @@ async function run() {
           if (isPhaseFile && !isInstructionPhase && existingContent.trim() !== '' && existingContent.trim() !== incoming.trim()) {
             console.log(`  Preserved customized phase: ${tmpl}`);
             totalSkipped++;
-            allManifest[mPath] = hashContent(existingContent);
+            // Customized phase = project-owned content → omit from manifest
+            // (recordSkip in copy.js — omission means "not ours").
+            recordSkip(allManifest, mPath);
             continue;
           }
 
@@ -1240,10 +1257,19 @@ async function run() {
             if (existingManifest[mPath]) {
               if (!flags.dryRun) fs.copyFileSync(srcPath, destPath);
               totalOverwritten++;
+              // Log single-file overwrites too — the directory path (copy.js)
+              // already does. Without this, scripts/ updates are invisible in
+              // install output, masking whether a changed script propagated.
+              console.log(`  Updated: ${path.relative(projectDir, destPath)}`);
+              allManifest[mPath] = incomingHash;
             } else {
               totalSkipped++;
+              // Project-created file → omit from manifest entirely. Ownership
+              // classification is manifest-PRESENCE-based, so recording ANY
+              // hash here would mark the file upstream-owned and the NEXT
+              // install would silently overwrite it (act:bf21c95b).
+              recordSkip(allManifest, mPath);
             }
-            allManifest[mPath] = incomingHash;
           } else {
             const response = await prompts({
               type: 'select',
@@ -1258,10 +1284,13 @@ async function run() {
             if (response.action === 'overwrite') {
               if (!flags.dryRun) fs.copyFileSync(srcPath, destPath);
               totalOverwritten++;
+              allManifest[mPath] = incomingHash;
             } else {
               totalSkipped++;
+              // Keep: the user claimed this file → project-owned → omit from
+              // the manifest so it is never mistaken for upstream content.
+              recordSkip(allManifest, mPath);
             }
-            allManifest[mPath] = incomingHash;
           }
         } else {
           if (!flags.dryRun) fs.copyFileSync(srcPath, destPath);
@@ -1610,6 +1639,18 @@ async function run() {
         // Register with folder name. /onboard fills in name and description later.
         registry.projects.push(entry);
       }
+      // --- Frontier-model designation (visibility watchdog) ---
+      // User-level, per-operator key. Read-preserve-rewrite: only the
+      // frontierModel key is touched; every other key rides through.
+      if (flags.frontierModelEmpty) {
+        console.log('  ⚠ Ignoring empty --frontier-model value (an empty key would match every model and silence the watchdog)');
+      }
+      if (flags.frontierModel) {
+        registry.frontierModel = flags.frontierModel;
+      } else if (typeof registry.frontierModel === 'string' && !registry.frontierModel.trim()) {
+        // Heal a hand-edited empty key — treat as absent (see parseArgs note).
+        delete registry.frontierModel;
+      }
       fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\n');
       const otherCount = registry.projects.filter(p => p.path !== projectDir).length;
       if (otherCount > 0) {
@@ -1617,6 +1658,10 @@ async function run() {
       } else {
         console.log('  📋 Registered in project registry');
       }
+      // Self-announcing: print the effective designation on every run.
+      if (registry.frontierModel) {
+        console.log(`  🛰  Frontier model: ${registry.frontierModel} (visibility watchdog — /orient + SessionStart warn on mismatch; nothing is pinned)`);
+      }
     } catch (err) {
       // Non-fatal — registry is nice-to-have
     }

package/lib/copy.js

@@ -7,6 +7,49 @@ function hashContent(content) {
   return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
 }
 
+/**
+ * Record the manifest consequence of SKIPPING a file at install time
+ * (act:bf21c95b). The single shared rule for ALL skip sites in BOTH
+ * install code paths (lib/copy.js and the single-file branches in
+ * lib/cli.js):
+ *
+ *   - A skipped file whose on-disk content differs from the incoming
+ *     template is NOT upstream content — it is project-owned
+ *     (project-created, user-kept, or a customized phase). It must be
+ *     OMITTED from the manifest entirely. An absent entry means "not
+ *     ours". Recording any hash for it poisons the manifest: ownership
+ *     classification is manifest-PRESENCE-based, so the next install
+ *     would classify the file upstream-owned and silently overwrite it
+ *     (and cc-upstream-guard / cc-drift-check would false-positive on it).
+ *   - The one exception: a skipped file byte-identical to the incoming
+ *     template is indistinguishable from upstream content and stays
+ *     tracked under the template hash.
+ *
+ * Omission only — never a marker value or an alternate manifest value
+ * shape (lesson_shared_json_shape_drift). All manifest consumers
+ * (ownership classification, cleanup loop, key migration, cc-drift-check,
+ * cc-upstream-guard, lib/reset.js) treat an absent key as "not ours" and
+ * leave the file alone.
+ *
+ * Known limitation (documented, not solved here): manifests already
+ * poisoned by past installs cannot retroactively distinguish a recorded
+ * project-created file from genuine upstream content. This helper only
+ * prevents NEW poisoning.
+ *
+ * @param {object} manifest      manifest object being built for this install
+ * @param {string} key           manifest key for the skipped file
+ * @param {object} [opts]
+ * @param {boolean} [opts.identical]    on-disk content === incoming template
+ * @param {string}  [opts.incomingHash] hash of the incoming template content
+ */
+function recordSkip(manifest, key, { identical = false, incomingHash = null } = {}) {
+  if (identical && incomingHash) {
+    manifest[key] = incomingHash;
+  } else {
+    delete manifest[key];
+  }
+}
+
 /**
  * Recursively copy files from src to dest, surfacing conflicts.
  * Returns { copied: string[], skipped: string[], overwritten: string[] }
@@ -55,7 +98,8 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
             const trimmedExisting = existing.trim();
             if (trimmedExisting !== '' && trimmedExisting !== incoming.trim()) {
               results.skipped.push(relPath);
-              results.manifest[relPath] = hashContent(existing);
+              // Customized phase = project-owned content → omit from manifest.
+              recordSkip(results.manifest, relPath);
               console.log(`  Preserved customized phase: ${displayPath}`);
               continue;
             }
@@ -64,7 +108,7 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
 
         if (existing === incoming) {
           results.skipped.push(relPath);
-          results.manifest[relPath] = incomingHash;
+          recordSkip(results.manifest, relPath, { identical: true, incomingHash });
           continue;
         }
 
@@ -82,9 +126,8 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
             console.log(`  Updated: ${displayPath}`);
           } else {
             results.skipped.push(relPath);
-            // Record the hash of what's actually on disk, not the template —
-            // otherwise the manifest lies about file content after a skip.
-            results.manifest[relPath] = hashContent(existing);
+            // Project-created file → omit from manifest ("not ours").
+            recordSkip(results.manifest, relPath);
           }
           continue;
         }
@@ -101,9 +144,9 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
         });
 
         if (!response.action) {
-          // User cancelled
+          // User cancelled → file kept as-is → project-owned → omit.
           results.skipped.push(relPath);
-          results.manifest[relPath] = incomingHash;
+          recordSkip(results.manifest, relPath);
           continue;
         }
 
@@ -118,17 +161,20 @@ async function walkAndCopy(srcRoot, destRoot, currentSrc, results, dryRun, skipC
           if (followUp.overwrite && !dryRun) {
             fs.copyFileSync(srcPath, destPath);
             results.overwritten.push(relPath);
+            results.manifest[relPath] = incomingHash;
           } else {
+            // Diff shown, user kept their file → project-owned → omit.
             results.skipped.push(relPath);
+            recordSkip(results.manifest, relPath);
           }
-          results.manifest[relPath] = incomingHash;
         } else if (response.action === 'overwrite') {
           if (!dryRun) fs.copyFileSync(srcPath, destPath);
           results.overwritten.push(relPath);
           results.manifest[relPath] = incomingHash;
         } else {
+          // 'Keep existing' → project-owned → omit from manifest.
           results.skipped.push(relPath);
-          results.manifest[relPath] = incomingHash;
+          recordSkip(results.manifest, relPath);
         }
       } else {
         if (!dryRun) {
@@ -169,4 +215,4 @@ function showDiff(existing, incoming, relPath) {
   console.log('');
 }
 
-module.exports = { copyTemplates };
+module.exports = { copyTemplates, recordSkip };

package/lib/mux-setup.js

@@ -45,6 +45,7 @@ const MANAGED_FILES = [
   { src: 'config/worktree-session-health.sh', dest: path.join(os.homedir(), '.config', 'mux', 'worktree-session-health.sh'), mode: 0o755 },
   { src: 'config/worktree-health-popup.sh', dest: path.join(os.homedir(), '.config', 'mux', 'worktree-health-popup.sh'), mode: 0o755 },
   { src: 'config/worktree-cleanup.sh', dest: path.join(os.homedir(), '.config', 'mux', 'worktree-cleanup.sh'), mode: 0o755 },
+  { src: 'config/worktree-dirty-check.sh', dest: path.join(os.homedir(), '.config', 'mux', 'worktree-dirty-check.sh'), mode: 0o755 },
   { src: 'config/mux.tmux.conf', dest: path.join(os.homedir(), '.config', 'mux', 'mux.tmux.conf') },
   { src: 'config/unwrap-copy.py', dest: path.join(os.homedir(), '.config', 'mux', 'unwrap-copy.py'), mode: 0o755 },
   { src: 'config/screenshot-to-clipboard.sh', dest: path.join(os.homedir(), '.config', 'mux', 'screenshot-to-clipboard.sh'), mode: 0o755 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-cabinet",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "Claude Cabinet — opinionated process scaffolding for Claude Code projects",
   "bin": {
     "create-claude-cabinet": "bin/create-claude-cabinet.js"

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/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/watchtower-contracts.md

@@ -58,6 +58,44 @@ attention window. If content exceeds 30 lines, truncation order:
 2. Drop Portfolio Pulse detail for quiet projects
 3. Never truncate "What Needs Attention" or "Where You Left Off"
 
+## Project State Section Ownership
+
+`state/projects/<slug>.md` is written by two rings. Every section has
+exactly ONE owner; a ring must never rebuild a section the other ring
+owns. The merge that enforces this is `preserveRing3LastSession()` in
+`watchtower-lib.mjs`, applied by Ring 1 before each per-project write.
+
+| Section              | Owner  | Notes                                  |
+|----------------------|--------|----------------------------------------|
+| `# <name>` header    | Ring 1 | Timestamp refreshed every run          |
+| `## Active Plans`    | Ring 1 | Rebuilt from pib-db every run          |
+| `## Last Session`    | Ring 3 | Once authored — see below              |
+| `## Standing Issues` | Ring 1 | Rebuilt every run                      |
+| `## Tech Stack`      | Ring 1 | Rebuilt every run                      |
+
+Ring 3's sessionSummary writes the rich Last Session summary with an
+`_<date> (<session-id>)_` attribution line directly under the header.
+That attribution line IS the ownership marker: until Ring 3 has authored
+the section, Ring 1 writes its own ephemeral fallback ("Active: …" /
+last-commit line) and rebuilds it freely; once the marker is present,
+Ring 1 must carry the existing section forward verbatim. Without this,
+Ring 1's full-file rebuild deterministically clobbers Ring 3's summary
+within one cron tick (~5 minutes).
+
+### Thread File Durability (disk wins over model)
+
+`state/threads/<slug>.json` carries the sibling rule: **disk wins over
+model**. If the thread file exists, Ring 3 ALWAYS appends to
+`cursor_history` — the LLM's `is_new` field is advisory naming metadata
+only, never an authorization to fresh-write over an existing file. One
+hallucinated `is_new: true` must not wipe an append-only history. The
+canonical implementation is `updateThreadFile()` in `watchtower-lib.mjs`.
+
+Corrupt thread files are never silently replaced: the corrupt file is
+backed up aside as `<slug>.json.corrupt-<ts>`, a fresh file is written,
+and the recovery is logged loudly. Per-thread writes are isolated — one
+bad thread file must not abort writes for the remaining threads.
+
 ## Enrichment Directory
 
 Per-item enrichment lives in `queue/items/<id>/enrichment/`. Four

package/templates/engagement/pib-db-patches/pib-db-lib.mjs

@@ -210,7 +210,10 @@ function validateSurfaceArea(notes) {
   }
 
   // Extract everything after ## Surface Area until the next ## or end
-  const sectionMatch = notes.match(/^## Surface Area[^\n]*\n([\s\S]*?)(?=\n## |\n*$)/m);
+  // Lookahead ends only at the next "## " header or absolute end-of-string.
+  // A bare `\n*$` here terminated the match at a blank line right after the
+  // header, yielding an empty capture for standard markdown spacing.
+  const sectionMatch = notes.match(/^## Surface Area[^\n]*\n([\s\S]*?)(?=\n## |$(?![\s\S]))/m);
   const sectionBody = sectionMatch ? sectionMatch[1] : '';
   const hasEntry = /^- (?:files|dirs):/m.test(sectionBody);
   if (!hasEntry) {

package/templates/hooks/action-completion-gate.sh

@@ -20,7 +20,19 @@ if [ -z "$FID" ]; then
   exit 0
 fi
 
+# Resolve the MAIN checkout: /execute and /execute-group write completion
+# artifacts (breadcrumbs, group Completion Reports) to the MAIN checkout's
+# .claude/verification/ — a session running in a linked/mux worktree must read
+# the same files, not the worktree's disposable gitignored copy. Fail open to
+# the cwd-relative path when not in a git repo (or git < 2.31).
 VERIFY_DIR=".claude/verification"
+COMMON_DIR=$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)
+if [ -n "$COMMON_DIR" ] && [ -d "$COMMON_DIR" ]; then
+  MAIN_CHECKOUT=$(dirname "$COMMON_DIR")
+  if [ -d "$MAIN_CHECKOUT" ]; then
+    VERIFY_DIR="$MAIN_CHECKOUT/.claude/verification"
+  fi
+fi
 BREADCRUMB="$VERIFY_DIR/$FID.json"
 
 if [ ! -f "$BREADCRUMB" ]; then
@@ -56,7 +68,12 @@ fi
 #
 # Tag lookup is best-effort: if pib.db can't be read, GRP_LABEL is empty and
 # this gate is skipped — the base breadcrumb gate above still applies.
+# Same worktree resolution for the db: a worktree without its own pib.db
+# falls back to the main checkout's, so the grp gate doesn't silently skip.
 DB_PATH="${PIB_DB_PATH:-pib.db}"
+if [ ! -f "$DB_PATH" ] && [ -z "$PIB_DB_PATH" ] && [ -n "$MAIN_CHECKOUT" ] && [ -f "$MAIN_CHECKOUT/pib.db" ]; then
+  DB_PATH="$MAIN_CHECKOUT/pib.db"
+fi
 TAGS=$(python3 -c "
 import sqlite3, sys
 try:

package/templates/hooks/watchtower-session-start.sh

@@ -5,6 +5,12 @@
 # a state summary, then outputs it as hookSpecificOutput for Claude's
 # additionalContext.
 #
+# Also runs the frontier-model watchdog: the SessionStart payload (stdin
+# JSON, per the CC hook contract) carries the session's `model` id. If
+# ~/.claude/cc-registry.json designates a frontierModel and this session
+# runs a different model, a loud warning is prepended to the injected
+# context. Visibility only — never blocks anything.
+#
 # If watchtower is not installed (no config.json), exits silently.
 # If the context builder produces no output, exits silently.
 #
@@ -13,16 +19,85 @@
 
 command -v jq >/dev/null 2>&1 || exit 0
 
+# Hook payload arrives on stdin (.tool_input-style JSON; never an env var).
+# Guard against interactive invocation where stdin is a tty.
+PAYLOAD=""
+if [ ! -t 0 ]; then
+  PAYLOAD=$(cat)
+fi
+
 WATCHTOWER_DIR="${HOME}/.claude-cabinet/watchtower"
 PROJECT_PATH="$(pwd)"
 
-# No config → watchtower not installed → exit silently
-if [ ! -f "${WATCHTOWER_DIR}/config.json" ]; then
-  exit 0
+# --- Frontier-model watchdog -------------------------------------------------
+# Canonical match rule lives in the orient skill (templates/skills/orient/
+# SKILL.md, "Frontier-Model Watchdog") — this is a reference implementation
+# of that rule, not a second definition:
+#   - key starting with "claude-" AND containing a digit => exact model ID,
+#     exact case-insensitive match required
+#   - anything else => family alias, case-insensitive containment
+#   - absent/empty/whitespace key => silent no-op ('' would match everything
+#     and silence the watchdog while appearing configured)
+FRONTIER_WARNING=""
+SESSION_MODEL=""
+if [ -n "${PAYLOAD}" ]; then
+  SESSION_MODEL=$(printf '%s' "${PAYLOAD}" | jq -r '.model // empty' 2>/dev/null)
+fi
+REGISTRY="${HOME}/.claude/cc-registry.json"
+FRONTIER_KEY=""
+if [ -f "${REGISTRY}" ]; then
+  FRONTIER_KEY=$(jq -r '.frontierModel // empty' "${REGISTRY}" 2>/dev/null | tr -d '[:space:]')
+fi
+if [ -n "${FRONTIER_KEY}" ] && [ -z "${SESSION_MODEL}" ]; then
+  # A key is configured but the payload exposed no model id (field absent,
+  # renamed, or reshaped by a future CC release). Say so instead of going
+  # silent — silence here is indistinguishable from "model matches".
+  FRONTIER_WARNING="ℹ FRONTIER WATCHDOG: a frontier model is designated (${FRONTIER_KEY}) but the SessionStart payload exposed no session model id — the early-boundary check was SKIPPED, not passed. The /orient watchdog phase remains the boundary."
+fi
+if [ -n "${SESSION_MODEL}" ] && [ -n "${FRONTIER_KEY}" ]; then
+  key_lc=$(printf '%s' "${FRONTIER_KEY}" | tr '[:upper:]' '[:lower:]')
+  model_lc=$(printf '%s' "${SESSION_MODEL}" | tr '[:upper:]' '[:lower:]')
+  # Session model ids may carry a bracketed runtime suffix (e.g.
+  # claude-fable-5[1m]); strip it before exact comparison — the suffix is
+  # session configuration, not model identity.
+  model_base_lc="${model_lc%%\[*}"
+  matched=0
+  case "${key_lc}" in
+    claude-*[0-9]*)
+      # Exact model ID — require identity against the suffix-stripped id.
+      [ "${model_base_lc}" = "${key_lc}" ] && matched=1
+      ;;
+    *)
+      # Family alias — containment.
+      case "${model_lc}" in
+        *"${key_lc}"*) matched=1 ;;
+      esac
+      ;;
+  esac
+  if [ "${matched}" -eq 0 ]; then
+    FRONTIER_WARNING="⚠ FRONTIER WATCHDOG: this session runs ${SESSION_MODEL}; your designated frontier model is ${FRONTIER_KEY} — switch with /model or relaunch. Surface this warning to the user as the FIRST line of any briefing. (Visibility only; nothing is blocked. Update the key with: npx create-claude-cabinet --frontier-model <model>)"
+  fi
+fi
+# -----------------------------------------------------------------------------
+
+# No config → watchtower not installed → still emit a frontier warning if
+# one fired (the hook only registers on watchtower installs, but a torn-down
+# config should not eat the watchdog), otherwise exit silently.
+CONTEXT=""
+if [ -f "${WATCHTOWER_DIR}/config.json" ]; then
+  # Build context. Suppress stderr to avoid noise on missing files.
+  CONTEXT=$(node "${WATCHTOWER_DIR}/scripts/watchtower-build-context.mjs" --project-path "${PROJECT_PATH}" 2>/dev/null)
 fi
 
-# Build context. Suppress stderr to avoid noise on missing files.
-CONTEXT=$(node "${WATCHTOWER_DIR}/scripts/watchtower-build-context.mjs" --project-path "${PROJECT_PATH}" 2>/dev/null)
+if [ -n "${FRONTIER_WARNING}" ]; then
+  if [ -n "${CONTEXT}" ]; then
+    CONTEXT="${FRONTIER_WARNING}
+
+${CONTEXT}"
+  else
+    CONTEXT="${FRONTIER_WARNING}"
+  fi
+fi
 
 # Empty context → nothing to inject
 if [ -z "${CONTEXT}" ]; then