create-claude-cabinet 0.48.0 → 0.49.0

package/templates/mux/__tests__/worktree-status-clean.test.mjs

@@ -0,0 +1,89 @@
+// Guard test for act:c008862c (mux half, Lane E of grp:wt-noise-immunity) —
+// the worktree "MERGE OR LOSE" false-positive class.
+//
+// Drives worktree-status-clean.fixture.sh (throwaway repos under mktemp,
+// HOME + GIT_CONFIG_GLOBAL + XDG_CONFIG_HOME overridden — never touches a
+// live worktree or real git config).
+//
+// The rules under test:
+//   - a fresh mux worktree shows CLEAN git status: no .mcp.json/.claudeignore
+//     typechange (skip-worktree while the path is a mux symlink), no
+//     node_modules/pib.db symlink churn, no .claude/ infra (the per-worktree
+//     managed exclude is made LIVE via extensions.worktreeConfig +
+//     core.excludesFile — git never reads worktrees/<name>/info/exclude
+//     natively, which is why the old rules were silently dead)
+//   - `git add -A` stages nothing on a churn-only worktree (the ELOOP class)
+//   - authored .claude/ files and real commits still surface and still count
+//     (dirty-check: uncommitted/commits > 0 → dirty)
+//   - machine-written generated state (advisories-state.json,
+//     checklist-stats.json, verification/) inside tracked-holding .claude/
+//     dirs is churn, not work — hidden from status AND excluded from the
+//     dirty-check's authored re-count
+//   - a REAL .mcp.json edit is never frozen: the skip-worktree bit clears
+//     the moment the path holds a real file (the assume-unchanged lesson)
+//   - the user's global ignore patterns survive the excludesFile
+//     displacement (copied into the managed block each rebuild)
+
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixture = path.join(here, 'worktree-status-clean.fixture.sh');
+const repoRoot = path.resolve(here, '..', '..', '..');
+
+test('worktree MERGE-OR-LOSE noise immunity: clean status, honest dirt (sandboxed fixture suite)', () => {
+  const res = spawnSync('bash', [fixture], { encoding: 'utf8', timeout: 120_000 });
+  const output = `${res.stdout}\n${res.stderr}`;
+  assert.strictEqual(
+    res.status,
+    0,
+    `fixture suite reported failures:\n${output}`
+  );
+  assert.match(output, /RESULT: \d+ passed, 0 failed/);
+});
+
+// The generated-state name set is deliberately spelled in more than one
+// implementation (bash can't import the JS lib): the health script's managed
+// exclude block, the dirty-check's GENERATED_STATE_RE, and — once Lane A's
+// half of act:c008862c lands — watchtower-lib.mjs's disposable-churn
+// classification. Silent drift between them re-opens the MERGE-OR-LOSE
+// false-positive class, so the agreement is enforced here rather than by a
+// keep-in-step comment (the enforcement-pipeline lesson: a comment is the
+// weakest layer). The lib leg self-arms: it is asserted only once the lib
+// mentions the first name, so this test does not depend on lane ordering.
+test('generated-state names agree across their sibling implementations', () => {
+  const NAMES = [
+    '.claude/cabinet/advisories-state.json',
+    '.claude/cabinet/checklist-stats.json',
+    '.claude/verification/',
+    'e2e/.verify-progress.jsonl',
+  ];
+  const health = readFileSync(
+    path.join(repoRoot, 'templates/mux/config/worktree-session-health.sh'), 'utf8');
+  const dirty = readFileSync(
+    path.join(repoRoot, 'templates/mux/config/worktree-dirty-check.sh'), 'utf8');
+
+  for (const name of NAMES) {
+    assert.ok(health.includes(`'${name}'`),
+      `worktree-session-health.sh managed exclude block must carry ${name}`);
+  }
+  const reLine = dirty.match(/^GENERATED_STATE_RE='(.*)'$/m);
+  assert.ok(reLine, 'worktree-dirty-check.sh must define GENERATED_STATE_RE');
+  for (const short of ['advisories-state', 'checklist-stats', 'verification/', 'verify-progress']) {
+    assert.ok(reLine[1].includes(short),
+      `GENERATED_STATE_RE must cover ${short}`);
+  }
+
+  const lib = readFileSync(
+    path.join(repoRoot, 'templates/scripts/watchtower-lib.mjs'), 'utf8');
+  if (lib.includes('advisories-state')) {
+    for (const short of ['advisories-state', 'checklist-stats', 'verification', 'verify-progress']) {
+      assert.ok(lib.includes(short),
+        `watchtower-lib.mjs names generated state but is missing ${short} — the three sibling lists have drifted`);
+    }
+  }
+});

package/templates/mux/bin/mux

@@ -284,6 +284,17 @@ worktree_health_check() {
   "${HOME}/.config/mux/worktree-session-health.sh" "$proj_path" "$wt_path" "$@" 2>&1
 }
 
+# Reap the lane's docker containers BEFORE the worktree dir (the compose
+# project name source) disappears. Single implementation in
+# worktree-session-health.sh --reap (exact compose-label match, containers
+# only, never volumes); the pane-exited worktree-cleanup.sh hook delegates to
+# the same mode, so every removal path reaps from one implementation.
+# Fail-open: a failed reap reports loudly but never blocks the removal.
+worktree_reap_containers() {
+  local proj_path="$1" wt_path="$2"
+  "${HOME}/.config/mux/worktree-session-health.sh" "$proj_path" "$wt_path" --reap 2>&1 || true
+}
+
 worktree_cleanup() {
   local project="$1" task_slug="$2"
   local proj_path
@@ -325,6 +336,7 @@ worktree_cleanup() {
   done
 
   if [[ "$verdict" == "clean" ]]; then
+    worktree_reap_containers "$proj_path" "$wt_path"
     git -C "$proj_path" worktree remove "$wt_path" 2>/dev/null || rm -rf "$wt_path"
     git -C "$proj_path" branch -d "$branch_name" 2>/dev/null || true
     worktree_registry_remove "$project" "$task_slug"
@@ -357,6 +369,7 @@ worktree_cleanup() {
       local main_branch
       main_branch=$(git -C "$proj_path" rev-parse --abbrev-ref HEAD)
       if git -C "$proj_path" merge "$branch_name" --no-edit 2>/dev/null; then
+        worktree_reap_containers "$proj_path" "$wt_path"
         git -C "$proj_path" worktree remove "$wt_path" 2>/dev/null || rm -rf "$wt_path"
         git -C "$proj_path" branch -d "$branch_name" 2>/dev/null || true
         worktree_registry_remove "$project" "$task_slug"
@@ -373,6 +386,7 @@ worktree_cleanup() {
         git -C "$wt_path" add -A
         git -C "$wt_path" commit -m "mux: parked work from ${task_slug} session"
       fi
+      worktree_reap_containers "$proj_path" "$wt_path"
       git -C "$proj_path" worktree remove "$wt_path" 2>/dev/null || rm -rf "$wt_path"
       worktree_registry_remove "$project" "$task_slug"
       echo "Branch '${branch_name}' parked."
@@ -384,6 +398,7 @@ worktree_cleanup() {
       read -r confirm
       case "$confirm" in
         y|Y)
+          worktree_reap_containers "$proj_path" "$wt_path"
           git -C "$proj_path" worktree remove --force "$wt_path" 2>/dev/null || rm -rf "$wt_path"
           git -C "$proj_path" branch -D "$branch_name" 2>/dev/null || true
           worktree_registry_remove "$project" "$task_slug"
@@ -402,7 +417,7 @@ worktree_cleanup() {
 }
 
 queue_claude_start() {
-  local target="$1" prompt="$2" win_path="$3" auto_orient="${4:-1}"
+  local target="$1" prompt="$2" win_path="$3"
   # Resolve window index immediately (names can be unreliable in background)
   local sess win_idx
   sess=$(tmux display-message -t "$target" -p '#{session_name}' 2>/dev/null)
@@ -410,6 +425,9 @@ queue_claude_start() {
   local stable="${sess}:${win_idx}"
   tmux set-window-option -t "$stable" @mux_claude 1 2>/dev/null || true
 
+  # No orient injection: /orient is retired. Session-start state loading is
+  # the watchtower SessionStart hook's job (ambient injection); mux launches
+  # the session and hands it the prompt, nothing more.
   if [[ -n "$prompt" ]]; then
     # Prompt-bearing launch: hand the prompt to the CLI as its INITIAL-PROMPT
     # argument (`claude "<prompt>"` — interactive session, submits on startup).
@@ -419,29 +437,15 @@ queue_claude_start() {
     # way a paste+Enter into a fallen-back shell prompt would be. The prompt
     # is staged in a per-window file and read by the PANE's shell via
     # $(cat …), so multi-line/quote-heavy content never passes through tmux
-    # key parsing. auto_orient=1 prepends the orient instruction INTO the same
-    # first message (one message, model-driven orient); auto_orient=0 trusts
-    # the prompt to orchestrate its own orient (e.g. `mux handoff`, whose seed
-    # runs /orient then the seeded thread — QA drains stay with window 1).
+    # key parsing.
     local seed_dir="${HOME}/.local/share/mux/seed-prompts"
     mkdir -p "$seed_dir" 2>/dev/null || true
     local pf="${seed_dir}/${sess}-${win_idx}.txt"
-    if [[ "$auto_orient" == "1" ]]; then
-      printf 'Run /orient-quick first to load state, then:\n\n%s' "$prompt" > "$pf"
-    else
-      printf '%s' "$prompt" > "$pf"
-    fi
+    printf '%s' "$prompt" > "$pf"
     tmux send-keys -t "$stable" "cd '${win_path}' && claude \"\$(cat '${pf}')\"" Enter
   else
-    # Empty-prompt launch (e.g. QA station relaunch): start plain. On the
-    # auto_orient path inject the canned /orient-quick after startup — a
-    # benign payload (a harmless command-not-found if it ever lands in a
-    # shell), the long-proven behavior, deliberately left unchanged.
+    # Empty-prompt launch (e.g. QA station relaunch): start plain.
     tmux send-keys -t "$stable" "cd '${win_path}' && claude" Enter
-    if [[ "$auto_orient" == "1" ]]; then
-      ( sleep 5; tmux send-keys -t "$stable" "/orient-quick" Enter ) &
-      disown
-    fi
   fi
 }
 
@@ -628,8 +632,8 @@ qa_inject() {
 }
 
 # Launch a fresh Claude in a bare-shell main window with the handoff as its
-# opening prompt. Reuses queue_claude_start (the same cd→claude→/orient-quick
-# →prompt sequence mux uses everywhere) — single source of truth for "start a
+# opening prompt. Reuses queue_claude_start (the same cd→claude→prompt
+# sequence mux uses everywhere) — single source of truth for "start a
 # Claude session with a prompt". C-u clears the shell line first.
 qa_launch_fresh() {
   local win="$1" prompt="$2" project="$3" path
@@ -1287,6 +1291,7 @@ cmd_worktree() {
       read -r confirm
       case "$confirm" in
         y|Y)
+          worktree_reap_containers "$proj_path" "$wt_path"
           git -C "$proj_path" worktree remove --force "$wt_path" 2>/dev/null || rm -rf "$wt_path"
           git -C "$proj_path" branch -D "$branch_name" 2>/dev/null || true
           worktree_registry_remove "$project" "$task"
@@ -1295,6 +1300,20 @@ cmd_worktree() {
         *) echo "Cancelled." ;;
       esac
       ;;
+    preflight)
+      # Verify main's environment BEFORE parallel lane spawns: every declared
+      # provision file exists in the main checkout and every declared
+      # `check:` command passes (.mux-worktree-provision at the project root).
+      # Exit code gates the spawn: 0 = sound, 1 = do not spawn lanes yet.
+      local project="${2:-}"
+      local proj_path
+      if [[ -n "$project" ]]; then
+        proj_path=$(project_path "$project") || die "Unknown project: $project"
+      else
+        proj_path=$(git rev-parse --show-toplevel 2>/dev/null) || die "Usage: mux worktree preflight <project> (or run inside a project)"
+      fi
+      "${HOME}/.config/mux/worktree-session-health.sh" "$proj_path" --preflight
+      ;;
     health)
       local project="${2:-}" task="${3:-}"
       if [[ -n "$project" && -n "$task" ]]; then
@@ -1355,7 +1374,7 @@ cmd_worktree() {
       fi
       ;;
     *)
-      echo "Usage: mux worktree [ls|cleanup|remove|health|refresh] [project] [task]"
+      echo "Usage: mux worktree [ls|cleanup|remove|health|refresh|preflight] [project] [task]"
       ;;
   esac
 }
@@ -1642,9 +1661,8 @@ qa_cmd_clear() {
 # merge to the live QA station). /session-handoff persists the seed to disk and
 # only calls this on approval, so a launch failure can't lose the seed.
 #
-# Why a new window on MAIN (not a worktree): the seed tells the next session to
-# run /orient then `mux qa drain`, and acting on drained QA (e2e / publish /
-# deploy) needs the main checkout. The window is named by work-context, NEVER
+# Why a new window on MAIN (not a worktree): acting on drained QA (e2e /
+# publish / deploy) needs the main checkout. The window is named by work-context, NEVER
 # by the prompt (cmd_new's prompt path slugifies prompt→name + forces a
 # worktree — the wrong path; we deliberately don't use it).
 #
@@ -1716,8 +1734,6 @@ cmd_handoff() {
 
   # -P -F gives an unambiguous session:index target (window names can
   # collide — option-setting by NAME hits the first match, act:c6f6bfd1).
-  # queue_claude_start with auto_orient=0: inject only the seed; the seed
-  # itself runs /orient.
   local target
   target=$(tmux new-window -t "=$project" -n "$name" -c "$win_path" -P -F '#{session_name}:#{window_index}')
   [[ -n "$target" ]] || die "mux handoff: couldn't open a window on ${project} — seed is saved; open the desk and paste it."
@@ -1725,8 +1741,8 @@ cmd_handoff() {
     tmux set-window-option -t "$target" @mux_worktree 1 2>/dev/null || true
     tmux set-window-option -t "$target" @wt_healthy 1 2>/dev/null || true
   fi
-  queue_claude_start "=$target" "$prompt" "$win_path" 0
-  echo "✓ Next session launched: window '${name}' on ${where}, seeded (it will /orient, then pick up the seeded work thread; it merges to main when done — QA handoffs and main-only tail work stay with window 1)."
+  queue_claude_start "=$target" "$prompt" "$win_path"
+  echo "✓ Next session launched: window '${name}' on ${where}, seeded (watchtower loads its state at session start, then it picks up the seeded work thread; it merges to main when done — QA handoffs and main-only tail work stay with window 1)."
 }
 
 cmd_setup() {

package/templates/mux/config/worktree-cleanup.sh

@@ -57,11 +57,28 @@ if [[ "$verdict" == "clean" ]]; then
   wt_slug=$(echo "$wt_path" | sed 's|[/.]|-|g')
   [[ -L "$projects_dir/$wt_slug" ]] && rm -f "$projects_dir/$wt_slug"
 
+  # Reap the lane's docker containers BEFORE the worktree dir (the compose
+  # project name source) disappears — single implementation in
+  # worktree-session-health.sh --reap, same mode bin/mux's removal paths use.
+  # Guarded: fail-open under set -e, a failed reap never blocks the removal.
+  # This hook's stdout goes nowhere (tmux discards it), so an incomplete
+  # reap routes to the desk's sticky-note channel — a leak on the unattended
+  # path must never be silent.
+  HEALTH_CHECK="${HOME}/.config/mux/worktree-session-health.sh"
+  if [[ -x "$HEALTH_CHECK" ]]; then
+    reap_out=$("$HEALTH_CHECK" "$proj_path" "$wt_path" --reap 2>/dev/null) || reap_out=""
+    if [[ "$reap_out" == *"reap INCOMPLETE"* || "$reap_out" == *"daemon unreachable"* ]]; then
+      python3 "${HOME}/.config/mux/manage-notes.py" add "$SESSION" \
+        "⚠ Container reap incomplete for closed worktree '${WINDOW}'. Check: docker ps --filter label=com.docker.compose.project=$(basename "$wt_path" | tr '[:upper:]' '[:lower:]')" \
+        2>/dev/null || true
+    fi
+  fi
+
   git -C "$proj_path" worktree remove "$wt_path" 2>/dev/null || rm -rf "$wt_path"
   git -C "$proj_path" branch -d "$branch_name" 2>/dev/null || true
   python3 "$MUX_LIB" worktree-remove "$SESSION" "$WINDOW" 2>/dev/null || true
 else
-  # Dirty — create urgent watchtower inbox item + sticky note.
+  # Dirty — create watchtower inbox item + sticky note.
   # Counts may be "?" when the check could not determine them (fail-DIRTY).
   detail=""
   if [[ "$has_uncommitted" != "0" && "$has_uncommitted" != "?" ]]; then
@@ -74,12 +91,39 @@ else
     detail="changes the dirty-check could not verify (treated as dirty)"
   fi
 
+  # Earned-urgency split, mirroring ring1's worktree-unmerged registers
+  # (noise-immunity merge-tail reconciliation): data-loss urgency is earned
+  # by unmerged COMMITS; a fully-merged branch with only uncommitted files
+  # is a normal review nudge. An unverifiable commit count ("?") stays
+  # urgent — fail toward attention, never toward silence.
+  if [[ "$has_commits" == "0" ]]; then
+    wt_urgency="normal"
+    wt_unmerged="false"
+    wt_title="Worktree \"${branch_name}\" closed with uncommitted files"
+    wt_summary="Window closed with ${detail}. The branch itself is fully merged — review or commit the files. Run: mux worktree cleanup ${SESSION} ${WINDOW}"
+  else
+    wt_urgency="urgent"
+    wt_unmerged="true"
+    wt_title="Worktree \"${branch_name}\" closed with unmerged work"
+    wt_summary="Window closed with ${detail}. Merge to main or the work may be lost. Run: mux worktree cleanup ${SESSION} ${WINDOW}"
+  fi
+
   # Watchtower inbox item (if watchtower is installed)
   WATCHTOWER_QUEUE="${HOME}/.claude-cabinet/watchtower/scripts/watchtower-queue.mjs"
   WATCHTOWER_LIB="${HOME}/.claude-cabinet/watchtower/scripts/watchtower-lib.mjs"
   if [[ -f "$WATCHTOWER_QUEUE" ]]; then
     NODE_BIN="${WATCHTOWER_NODE_PATH:-$(command -v node 2>/dev/null || true)}"
     if [[ -n "$NODE_BIN" ]]; then
+      # All dynamic values reach node via ENV, never spliced into the JS
+      # source: an apostrophe in a window/desk/branch name was a silent
+      # SyntaxError (the '|| true' swallowed it — the urgent item never
+      # filed, only the sticky note survived), and a crafted name was JS
+      # injection. Same class ring1's CP3 commit closed for filenames
+      # (QA drain 2026-07-13). Only $HOME-derived import paths are spliced.
+      MUX_PROJ_PATH="$proj_path" MUX_SESSION="$SESSION" MUX_WINDOW="$WINDOW" \
+      MUX_BRANCH="$branch_name" MUX_WT_PATH="$wt_path" \
+      MUX_URGENCY="$wt_urgency" MUX_TITLE="$wt_title" MUX_SUMMARY="$wt_summary" \
+      MUX_UNMERGED="$wt_unmerged" \
       "$NODE_BIN" --input-type=module -e "
         import { createItem, listPending } from '${WATCHTOWER_QUEUE}';
         // project must be the watchtower config key, not the mux desk name —
@@ -95,25 +139,26 @@ else
         try { ({ resolveProjectIdentity, loadConfig } = await import('${WATCHTOWER_LIB}')); } catch {}
         let config = null;
         try { config = loadConfig?.() ?? null; } catch {}
-        const identity = resolveProjectIdentity?.('${proj_path}', config) ?? null;
+        const env = process.env;
+        const identity = resolveProjectIdentity?.(env.MUX_PROJ_PATH, config) ?? null;
         const existing = listPending({ category: 'worktree-unmerged' });
         const isDup = existing.some(i =>
-          i.evidence?.branch === '${branch_name}' &&
-          i.evidence?.worktree_path === '${wt_path}'
+          i.evidence?.branch === env.MUX_BRANCH &&
+          i.evidence?.worktree_path === env.MUX_WT_PATH
         );
         if (!isDup) {
           createItem({
-            project: identity?.name || '${SESSION}',
-            project_path: identity?.path || '${proj_path}',
-            desk: '${SESSION}',
+            project: identity?.name || env.MUX_SESSION,
+            project_path: identity?.path || env.MUX_PROJ_PATH,
+            desk: env.MUX_SESSION,
             ...(identity ? {} : { project_unresolved: true }),
             filed_by: 'pane-close',
             category: 'worktree-unmerged',
-            urgency: 'urgent',
-            title: 'Worktree \"${branch_name}\" closed with unmerged work',
-            summary: 'Window closed with ${detail}. Run: mux worktree cleanup ${SESSION} ${WINDOW}',
-            context_anchor: 'git log main..${branch_name} in ${wt_path}',
-            evidence: { branch: '${branch_name}', worktree_path: '${wt_path}', window: '${WINDOW}' },
+            urgency: env.MUX_URGENCY,
+            title: env.MUX_TITLE,
+            summary: env.MUX_SUMMARY,
+            context_anchor: 'git log main..' + env.MUX_BRANCH + ' in ' + env.MUX_WT_PATH,
+            evidence: { branch: env.MUX_BRANCH, worktree_path: env.MUX_WT_PATH, window: env.MUX_WINDOW, unmerged: env.MUX_UNMERGED === 'true' },
             options: [
               { key: 'merge', label: 'Merge to main now' },
               { key: 'keep', label: 'Keep branch for later' },

package/templates/mux/config/worktree-dirty-check.sh

@@ -64,6 +64,38 @@
 #      changes also touch package.json (which counts as dirty); without this
 #      exclusion every npm-touching worktree is immortal.
 #
+#   5. UNTRACKED identity symlinks (`?? .mcp.json`, `?? .claudeignore`,
+#      `?? pib.db`) — in a project that doesn't track these files, the mux
+#      identity symlink shows as untracked instead of a typechange
+#      (act:c008862c). Same manufactured churn, same exclusion — but ONLY
+#      while the path is actually a symlink (checked live below): a REAL
+#      user-created file at the same path (a lazily created pib.db holding
+#      recorded actions, a hand-authored .mcp.json) is real work and counts
+#      as dirty. A MODIFIED tracked copy (` M`) still counts as dirty,
+#      exactly as in point 2.
+#
+#   5b. SKIP-WORKTREE'd paths are absent from porcelain BY DESIGN while
+#      they are mux symlinks (worktree-session-health.sh hides the
+#      typechange that way). If such a path now holds a REAL file (an
+#      atomic temp+rename replaced the symlink mid-session, before any
+#      health run could clear the bit), the hidden state may be a real
+#      edit — counted as dirty here so a clean-verdict deletion can never
+#      race the health heal (fail-DIRTY).
+#
+#   6. GENERATED STATE inside otherwise-authored .claude/ dirs — machine-
+#      written runtime state (advisories-state.json, checklist-stats.json,
+#      .claude/verification/) lives under top-level entries that also hold
+#      tracked files, so the authored re-count below would claim it as real
+#      work and a fully-merged worktree read "MERGE OR LOSE" (act:c008862c,
+#      live specimen 2026-07-12). Untracked generated state is excluded from
+#      the authored re-count; a TRACKED-and-modified copy still counts as
+#      dirty (fail-safe — untracking live consumers is operator-gated).
+#      The names must stay in step with watchtower-lib.mjs
+#      (authoredClaudeDirs / claudeChurnIsDisposable consumers) and the
+#      exclude block in worktree-session-health.sh — the noise-immunity
+#      program's merge tail diffs these lists (two implementations, one
+#      concept).
+#
 # JS-SIDE PARALLEL: the watchtower ring scripts (.mjs) carry their own
 # porcelain dirty checks with their own exclusion sets. They are a parallel
 # implementation owned by a separate plan and intentionally NOT consolidated
@@ -85,6 +117,21 @@ fi
 
 # Known CC-infrastructure churn (see EXCLUSION CONTRACT above).
 INFRA_CHURN_RE='^\?\? \.claude/?$|^\?\? \.claude/|^.T \.mcp\.json$|^.T \.claudeignore$|^\?\? node_modules/?$|^[M ][M ] (.*/)?(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb)$'
+# Point 5: untracked identity names are churn ONLY while the path is a live
+# symlink — a real file there is real work (fail-DIRTY when in doubt).
+for _f in .mcp.json .claudeignore pib.db; do
+  if [[ -n "$wt_path" && -L "$wt_path/$_f" ]]; then
+    INFRA_CHURN_RE="${INFRA_CHURN_RE}|^\?\? ${_f//./\\.}\$"
+  fi
+done
+# Machine-written generated state (EXCLUSION CONTRACT point 6) — excluded
+# from BOTH counting passes (non-churn and the authored re-count); keep in
+# step with watchtower-lib.mjs GENERATED_STATE_PATTERNS and
+# worktree-session-health.sh (merge-tail list diff; drift test in
+# worktree-status-clean.test.mjs). e2e/.verify-progress.jsonl sits outside
+# .claude/, so the blanket untracked-.claude churn rule never covers it —
+# it must be excluded here or a /verify-touched worktree is immortal.
+GENERATED_STATE_RE='^\?\? (\.claude/(cabinet/(advisories-state|checklist-stats)\.json|verification/)|e2e/\.verify-progress\.jsonl$)'
 # Authored records re-included after the untracked-.claude exclusion
 # (ERE has no negative lookahead, so this is a second counting pass).
 # Any top-level .claude/ entry holding tracked files is authored; the static
@@ -114,10 +161,33 @@ if [[ -d "$wt_path" ]] && git -C "$wt_path" rev-parse --git-dir >/dev/null 2>&1;
     if [[ -z "$porcelain" ]]; then
       uncommitted=0
     else
-      non_churn=$(grep -cvE "$INFRA_CHURN_RE" <<<"$porcelain") || true
-      authored=$(grep -cE "$AUTHORED_RECORD_RE" <<<"$porcelain") || true
+      non_churn=$(grep -vE "$INFRA_CHURN_RE" <<<"$porcelain" | grep -cvE "$GENERATED_STATE_RE") || true
+      authored=$(grep -E "$AUTHORED_RECORD_RE" <<<"$porcelain" | grep -cvE "$GENERATED_STATE_RE") || true
       uncommitted=$(( ${non_churn:-0} + ${authored:-0} ))
     fi
+    # Point 5b: skip-worktree'd paths never reach porcelain — count any
+    # whose worktree path is NOT currently a symlink (a real file may be
+    # hiding behind the bit; the health heal unhides it, but a deletion
+    # must never race that heal).
+    sw_real=0
+    while IFS= read -r sw_line; do
+      sw_file="${sw_line#S }"
+      [[ -n "$sw_file" && ! -L "$wt_path/$sw_file" ]] && sw_real=$((sw_real+1))
+    done < <(git -C "$wt_path" ls-files -v 2>/dev/null | grep '^S ' || true)
+    # Point 5c: the UNTRACKED twin of 5b — a real file at an identity path
+    # that porcelain can't see because a stale managed-exclude line (written
+    # while the path was still a symlink) hides it until the next health
+    # rebuild. Real file + untracked + absent from porcelain = hidden work.
+    for _f in .mcp.json .claudeignore pib.db; do
+      if [[ -e "$wt_path/$_f" && ! -L "$wt_path/$_f" ]] \
+        && ! git -C "$wt_path" ls-files --error-unmatch "$_f" >/dev/null 2>&1 \
+        && ! grep -qE "^.. ${_f//./\\.}\$" <<<"$porcelain"; then
+        sw_real=$((sw_real+1))
+      fi
+    done
+    if [[ "$sw_real" -gt 0 ]]; then
+      uncommitted=$(( ${uncommitted:-0} + sw_real ))
+    fi
   fi
 fi