@mmerterden/multi-agent-pipeline 17.6.0 → 19.0.0

package/pipeline/scripts/diff-explain.mjs

@@ -3,7 +3,7 @@
 /**
  * @file diff-explain.mjs  -  v7.8.0 Paket B
  *
- * Bridges Phase 4 triage output to the actual git diff. For each accepted /
+ * Bridges Phase 3 triage output to the actual git diff. For each accepted /
  * deferred / rejected finding, locates the corresponding hunk in the branch's
  * diff against base and renders an annotated markdown report.
  *
@@ -31,9 +31,8 @@
  */
 
 import { readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
 import { execFileSync } from "child_process";
+import { resolveRunFile, taskIdVariants, logsRoot } from "./_run-paths.mjs";
 
 const argv = process.argv.slice(2);
 const flags = {};
@@ -71,14 +70,12 @@ Output:
 }
 
 function resolveStateByTaskId(id) {
-  const bare = String(id).replace(/^#/, "");
-  const logRoot = join(homedir(), ".claude", "logs", "multi-agent");
-  const candidates = [...new Set([String(id), bare, `task-${bare}`])].map((d) =>
-    join(logRoot, d, "agent-state.json"),
-  );
-  const found = candidates.find((p) => existsSync(p));
+  const found = resolveRunFile(id, "agent-state.json", flags.project);
   if (!found)
-    die(`no agent-state.json for task ${id} under ${logRoot} (tried ${candidates.join(", ")})`);
+    die(
+      `no agent-state.json for task ${id} under ${logsRoot()} ` +
+        `(tried ${taskIdVariants(id).join(", ")} in both layouts)`,
+    );
   return found;
 }
 

package/pipeline/scripts/diff-risk-score.mjs

@@ -369,8 +369,9 @@ function main() {
     files: TOP ? rows.slice(0, Number(TOP)) : rows,
   };
 
+  // Returning, not exiting: this payload carries a row per changed file and
+  // process.exit() would cut it at the pipe buffer.
   process.stdout.write(PRETTY ? JSON.stringify(out, null, 2) + "\n" : JSON.stringify(out) + "\n");
-  process.exit(0);
 }
 
 try {

package/pipeline/scripts/doctor.mjs

@@ -53,6 +53,7 @@ import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { runMain } from "../lib/fatal.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const HOME = homedir();
@@ -63,6 +64,12 @@ const JSON_OUT = argv.includes("--json");
 const PROBE = argv.includes("--probe");
 const EXPLAIN = argv.includes("--explain");
 const LIST = argv.includes("--list-checks");
+// `--profile server` adds checks that only matter when nobody is at the
+// keyboard. They are ADDITIVE: the default run is byte-for-byte what it was,
+// because a laptop being told it fails a server check would teach people to
+// ignore doctor.
+const profileFlag = argv.find((a) => a.startsWith("--profile="));
+const PROFILE = profileFlag ? profileFlag.slice("--profile=".length) : "";
 const taskFlag = argv.find((a) => a.startsWith("--task-tools="));
 const TASK_TOOLS = taskFlag ? taskFlag.split("=")[1] : null;
 
@@ -89,6 +96,15 @@ const CHECK_IDS = [
   "worktree-residue",
 ];
 
+// Only under `--profile server`. Kept in their own list so `--list-checks`
+// can say which ones a default run does not include.
+const SERVER_CHECK_IDS = [
+  "unattended-contract",
+  "unattended-permissions",
+  "scheduler",
+  "keychain-unlock",
+];
+
 // Only these six may return BLOCK. Enforced below, not merely documented: a
 // check that returns BLOCK without being listed here is downgraded and the
 // downgrade is reported, because an unenforced rule is a comment.
@@ -728,7 +744,7 @@ function checkDiskSpace() {
 }
 
 // A finished task removes its own worktree at PR time, but a run that dies
-// before Phase 6 never reaches that step and nothing else collects it: the
+// before Phase 4 never reaches that step and nothing else collects it: the
 // finalizer only runs on success and gc-worktrees only sweeps entries git no
 // longer knows about. So worktrees accumulate silently, and each one is a full
 // second checkout. Measured on one real iOS repo: 15 left behind, 11 GB.
@@ -772,7 +788,7 @@ function checkWorktreeResidue() {
     report(
       "worktree-residue",
       "WARN",
-      `${entries.length} worktree(s) left under ${wt}${size}; runs that stopped before Phase 6 are never collected`,
+      `${entries.length} worktree(s) left under ${wt}${size}; runs that stopped before Phase 4 are never collected`,
       "run /multi-agent:garbage-collect, or /multi-agent:kill for a task you know is dead",
     );
     return;
@@ -782,21 +798,138 @@ function checkWorktreeResidue() {
 
 /* ------------------------------------------------------------------ main -- */
 
+/**
+ * Checks that only matter when nobody is at the keyboard.
+ *
+ * Every one of them is a way a server run stops WITHOUT SAYING SO - the
+ * failure mode this whole profile exists for. A laptop hits none of them
+ * because a human is there to answer, unlock and restart, which is exactly why
+ * they are not in the default run.
+ *
+ * None may BLOCK: `MAY_BLOCK` is a closed set and these are readiness, not
+ * correctness. A machine that fails all four still runs the pipeline fine with
+ * someone watching it.
+ *
+ * @param {{root: string}|any} resolved the install layout from checkInstallPresent
+ */
+function checkServerProfile(resolved) {
+  const root = resolved?.root || join(homedir(), ".claude");
+
+  // 1. The contract exists on this machine. Without it nothing tells the
+  //    operator which entry points honour MULTI_AGENT_UNATTENDED.
+  const contract = join(root, "multi-agent-refs", "unattended-contract.md");
+  if (existsSync(contract)) {
+    ok("unattended-contract");
+  } else {
+    report(
+      "unattended-contract",
+      "WARN",
+      "unattended-contract.md is not installed, so nothing here documents what an unattended run resolves",
+      "run /multi-agent:update to refresh the reference tree",
+    );
+  }
+
+  // 2. The permission posture. autopilot spawns `claude --permission-prompts
+  //    none`, but the tools it then calls still have to be allowed somewhere,
+  //    and on a fresh machine they are not - the run stops at the first
+  //    prompt with nobody to answer it.
+  const settings = join(root, "settings.json");
+  let allow = [];
+  try {
+    allow = JSON.parse(readFileSync(settings, "utf-8"))?.permissions?.allow ?? [];
+  } catch {
+    allow = [];
+  }
+  const needed = ["Bash", "Edit", "Write"];
+  const missing = needed.filter((t) => !allow.some((a) => String(a).startsWith(t)));
+  if (!missing.length) {
+    ok("unattended-permissions");
+  } else {
+    report(
+      "unattended-permissions",
+      "WARN",
+      `permissions.allow does not cover ${missing.join(", ")}; an unattended run stops at the first prompt`,
+      "run /multi-agent:setup, or add them to permissions.allow in settings.json",
+      { settings, allow },
+    );
+  }
+
+  // 3. Something has to start the work. launchd is the only scheduler this
+  //    ships a template for; a server with no agent loaded runs nothing and
+  //    looks idle rather than broken.
+  let loaded = false;
+  try {
+    loaded = execFileSync("launchctl", ["list"], { encoding: "utf-8", timeout: 5000 }).includes(
+      "multi-agent",
+    );
+  } catch {
+    // launchctl absent or refusing: treat as "nothing is loaded", which is the
+    // conservative read - claiming a scheduler we could not see would be worse.
+  }
+  if (loaded) {
+    ok("scheduler");
+  } else {
+    report(
+      "scheduler",
+      "WARN",
+      "no multi-agent launchd agent is loaded, so nothing starts a queued run on its own",
+      "run /multi-agent:autopilot to install the agent, or schedule the runner yourself",
+    );
+  }
+
+  // 4. The keychain. Every credential this pipeline reads lives there, and a
+  //    LaunchDaemon started before login gets a LOCKED keychain: each fetch
+  //    fails, and the failures surface far away as 401s that blame the token.
+  //    Reading a real credential here would be a network call and a side
+  //    effect; the presence of a login-keychain path is the cheap proxy.
+  let keychain = "";
+  try {
+    keychain = execFileSync("security", ["default-keychain"], {
+      encoding: "utf-8",
+      timeout: 5000,
+    }).trim();
+  } catch {
+    // Same shape: unreachable reads as absent.
+  }
+  if (keychain) {
+    ok("keychain-unlock");
+  } else {
+    report(
+      "keychain-unlock",
+      "WARN",
+      "no default keychain is reachable from this session; a boot-time daemon sees a locked one and every credential read fails as a 401",
+      "run the LaunchAgent at login rather than a LaunchDaemon at boot (docs/server-readiness.md)",
+    );
+  }
+}
+
 function main() {
   if (LIST) {
+    // Lists what THIS invocation would run, which is what the name promises
+    // and what the registry gate compares against the output of a real run.
+    // Listing the server checks unconditionally made `--list-checks` disagree
+    // with a default run by four, and the gate that counts printed lines
+    // against listed checks caught it immediately.
     for (const id of CHECK_IDS) process.stdout.write(`${id}\n`);
+    if (PROFILE === "server") for (const id of SERVER_CHECK_IDS) process.stdout.write(`${id}\n`);
     return;
   }
   const unknown = argv.filter(
-    (a) => a.startsWith("--") && !/^--(probe|json|explain|list-checks|task-tools=)/.test(a),
+    (a) =>
+      a.startsWith("--") && !/^--(probe|json|explain|list-checks|task-tools=|profile=)/.test(a),
   );
   if (unknown.length) {
     process.stderr.write(
-      `usage: doctor.mjs [--probe] [--json] [--explain] [--task-tools=yes|no] | --list-checks\n`,
+      `usage: doctor.mjs [--probe] [--json] [--explain] [--task-tools=yes|no] [--profile=server] | --list-checks\n`,
     );
     process.exitCode = 3;
     return;
   }
+  if (PROFILE && PROFILE !== "server") {
+    process.stderr.write(`usage: --profile takes "server" (got "${PROFILE}")\n`);
+    process.exitCode = 3;
+    return;
+  }
   if (taskFlag && TASK_TOOLS !== "yes" && TASK_TOOLS !== "no") {
     process.stderr.write("usage: --task-tools takes yes or no\n");
     process.exitCode = 3;
@@ -837,6 +970,7 @@ function main() {
   checkMcpSurface();
   checkDiskSpace();
   checkWorktreeResidue();
+  if (PROFILE === "server") checkServerProfile(resolved);
 
   const blocked = results.filter((r) => r.severity === "BLOCK");
   const warned = results.filter((r) => r.severity === "WARN");
@@ -852,7 +986,7 @@ function main() {
   // Every check prints, in registry order, including the ones that found
   // nothing and the ones that were not run. A list that shows only problems
   // cannot be told apart from a list that was never produced.
-  for (const id of CHECK_IDS) {
+  for (const id of [...CHECK_IDS, ...SERVER_CHECK_IDS]) {
     const r = results.find((x) => x.id === id);
     if (!r) continue;
     if (r.severity === "OK") {
@@ -897,5 +1031,5 @@ function invokedDirectly() {
 }
 
 if (invokedDirectly()) {
-  main();
+  runMain("doctor", main);
 }

package/pipeline/scripts/evidence-gate.mjs

@@ -35,7 +35,7 @@
 //   1  -  pass claim is UNVERIFIED (no evidence / empty / shows failure / no success marker) -> caller must NOT record passed
 //   2  -  usage error
 
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 
 // Failure markers are kept DEFINITIVE (not broad) because failure now overrides
 // success (see the decision logic): a bare "error:" or stray "FAILED" in an
@@ -103,12 +103,18 @@ function parseArgs(argv) {
   return out;
 }
 
+// Both of these have to stop the run where they are called - the gate's whole
+// contract is "verdict, then nothing else happens" - so process.exit() stays.
+// What changes is the write: console.log to a pipe is asynchronous and exit
+// discards what has not drained, while writeFileSync to fd 1 returns only once
+// the bytes are gone. The verdict is short today; the verdict is also the only
+// thing a caller reads, so losing half of it is the one failure that matters.
 function fail(msg) {
-  console.log(JSON.stringify({ ok: false, code: 1, reason: msg }));
+  writeFileSync(1, `${JSON.stringify({ ok: false, code: 1, reason: msg })}\n`);
   process.exit(1);
 }
 function ok(msg) {
-  console.log(JSON.stringify({ ok: true, code: 0, reason: msg }));
+  writeFileSync(1, `${JSON.stringify({ ok: true, code: 0, reason: msg })}\n`);
   process.exit(0);
 }
 function usage(msg) {

package/pipeline/scripts/feedback-send.mjs

@@ -138,8 +138,10 @@ async function main() {
   };
 
   if (process.argv.includes("--dry-run")) {
+    // return, not process.exit(0): the whole point of --dry-run is to read this
+    // payload, and exiting truncates it whenever stdout is a pipe.
     process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-    process.exit(0);
+    return;
   }
 
   if (!endpointAllowed(endpoint)) {
@@ -180,4 +182,12 @@ async function main() {
   }
 }
 
-main();
+// `main()` is async, and calling it bare leaves any rejection it does not
+// handle itself as an unhandled rejection: Node prints its own stack trace and
+// exits 1, so the user of a feedback command sees a crash dump instead of the
+// one line this file writes for every other failure. The catch keeps the
+// failure in this file's own voice.
+main().catch((err) => {
+  process.stderr.write(`ERROR: feedback-send failed  -  ${err?.message ?? err}\n`);
+  process.exit(1);
+});

package/pipeline/scripts/gc-abandoned.sh

@@ -11,7 +11,7 @@
 # Three things keep this from being a foot-gun, and each is a rule rather than a
 # heuristic:
 #
-#   1. A run WAITING FOR YOU is never reaped. An open PR, Phase 6 or 7, or
+#   1. A run WAITING FOR YOU is never reaped. An open PR, Phase 4 or 7, or
 #      `status: awaiting_input` means the work landed and the pipeline is
 #      holding for an answer by design. That is finished work, not residue.
 #   2. A path that is not strictly inside `<repo>/.worktrees/` is never removed.
@@ -49,7 +49,7 @@
 #
 # State is moved to `<run-dir>/artifacts/` before the worktree goes, so the log,
 # the findings and the phase history survive the sweep. The same recovery
-# contract Phase 6 uses when it removes a finished worktree.
+# contract Phase 4 uses when it removes a finished worktree.
 #
 # SAFE BY DEFAULT: dry-run. Removes nothing until you pass --yes.
 #
@@ -64,7 +64,7 @@
 #
 # Exit: 0 on success (including "nothing to do"), 2 on usage error.
 
-set -uo pipefail
+set -euo pipefail
 
 LOGS="$HOME/.claude/logs/multi-agent"
 REPOS="$HOME"
@@ -121,20 +121,25 @@ HANDLED=""
 # sweep that walks one layout leaves the other copy claiming the run is live.
 while IFS= read -r state; do
   [ -f "$state" ] || continue
-  status=$(jq -r '.status // ""' "$state" 2>/dev/null)
+  # Every jq read in this loop is forgiven. A malformed state file is exactly
+  # what a sweep for abandoned runs expects to meet, and under `set -e` the
+  # first one would end the sweep - leaving every run AFTER it untouched and
+  # reporting a clean tree. An empty value already means "unknown", and the
+  # rules below refuse to delete on unknown.
+  status=$(jq -r '.status // ""' "$state" 2>/dev/null || true)
   # Only runs that CLAIM to be running. A file with no status is unknown, and
   # unknown is not a licence to delete.
   case "$status" in in_progress | paused | awaiting_input) ;; *) continue ;; esac
 
-  task=$(jq -r '.taskId // .jiraId // ""' "$state" 2>/dev/null)
+  task=$(jq -r '.taskId // .jiraId // ""' "$state" 2>/dev/null || true)
   [ -n "$task" ] || continue
-  phase=$(jq -r '.currentPhase // "?"' "$state" 2>/dev/null)
+  phase=$(jq -r '.currentPhase // "?"' "$state" 2>/dev/null || true)
   # `.pr` is an object in the schema and a bare URL string in three state files
   # on disk. `jq '.pr.url'` on a string errors, and with stderr suppressed that
   # reads as "no PR" - so a run whose PR is already open would be classed as dead
   # and reaped. Read the shape, do not assume it.
-  pr=$(jq -r 'if (.pr|type)=="string" then .pr elif (.pr|type)=="object" then (.pr.url // .pr.number // "") else "" end | tostring' "$state" 2>/dev/null)
-  wt=$(jq -r '.worktreePath // ""' "$state" 2>/dev/null)
+  pr=$(jq -r 'if (.pr|type)=="string" then .pr elif (.pr|type)=="object" then (.pr.url // .pr.number // "") else "" end | tostring' "$state" 2>/dev/null || true)
+  wt=$(jq -r '.worktreePath // ""' "$state" 2>/dev/null || true)
 
   # Rule 1: waiting for you is not residue.
   if [ "$status" = "awaiting_input" ] || [ -n "$pr" ] || [ "$phase" = "6" ] || [ "$phase" = "7" ]; then
@@ -142,7 +147,8 @@ while IFS= read -r state; do
     continue
   fi
 
-  mtime=$(_mtime "$state")
+  mtime=$(_mtime "$state" || true)
+  [ -n "$mtime" ] || continue
   age_days=$(((NOW - mtime) / 86400))
   if [ "$phase" = "0" ]; then
     limit="$PHASE0_DAYS"; kind="left at a Phase 0 question"
@@ -155,7 +161,8 @@ while IFS= read -r state; do
   # root recorded in worktreePath is the shape that would delete a checkout.
   safe_wt=""
   if [ -n "$wt" ] && [ -d "$wt" ] && [ ! -L "$wt" ]; then
-    real=$(cd "$wt" 2>/dev/null && pwd -P)
+    # A worktree path that no longer resolves is the ordinary case here.
+    real=$(cd "$wt" 2>/dev/null && pwd -P || true)
     case "$real" in
       */.worktrees/*) safe_wt="$real" ;;
       *) skipped_unsafe=$((skipped_unsafe + 1)) ;;
@@ -187,8 +194,11 @@ $safe_wt"
   fi
 
   run_dir=$(dirname "$state")
-  mkdir -p "$run_dir/artifacts" 2>/dev/null
-  cp "$state" "$run_dir/artifacts/agent-state.json" 2>/dev/null
+  # Forgiven, both of them: this is the salvage copy, and a run whose artefacts
+  # cannot be copied is still a run that has to be marked abandoned. Under
+  # `set -e` an unreadable state file here would end the entire sweep.
+  mkdir -p "$run_dir/artifacts" 2>/dev/null || true
+  cp "$state" "$run_dir/artifacts/agent-state.json" 2>/dev/null || true
   tmp="$state.tmp.$$"
   if jq --arg r "abandoned by gc-abandoned after ${age_days}d idle" \
     '.status = "failed" | .haltReason = $r' "$state" > "$tmp" 2>/dev/null; then
@@ -209,7 +219,8 @@ $safe_wt"
   if [ -n "$safe_wt" ]; then
     repo=${safe_wt%%/.worktrees/*}
     git -C "$repo" worktree remove --force "$safe_wt" >/dev/null 2>&1 || rm -rf "$safe_wt"
-    git -C "$repo" worktree prune >/dev/null 2>&1
+    # Forgiven: one flaky prune must not end the sweep before its summary line.
+    git -C "$repo" worktree prune >/dev/null 2>&1 || true
     printf '→ removed: %s (%s, idle %sd)\n' "$task" "$human" "$age_days"
     freed_kb=$((freed_kb + ${size_kb:-0}))
   else
@@ -233,7 +244,11 @@ if [ "$STATE_ONLY" -eq 0 ] && [ -d "$REPOS" ]; then
   # re-walk of the log tree for each of 28 directories.
   index=$(find "$LOGS" -name agent-state.json -type f -maxdepth 4 -not -path '*/artifacts/*' 2>/dev/null |
     while IFS= read -r f; do
-      jq -r '[(.worktreePath // ""), (.taskId // .jiraId // ""), (.status // ""), (if (.pr|type)=="string" then .pr elif (.pr|type)=="object" then (.pr.url // .pr.number // "") else "" end | tostring), ((.currentPhase // "") | tostring)] | @tsv' "$f" 2>/dev/null
+      # One malformed state file must not truncate the index: under `set -e`
+      # a jq failure inside this subshell ends the loop, and the entries after
+      # it would silently not exist - which reads as "no worktree matches" and
+      # protects nothing.
+      jq -r '[(.worktreePath // ""), (.taskId // .jiraId // ""), (.status // ""), (if (.pr|type)=="string" then .pr elif (.pr|type)=="object" then (.pr.url // .pr.number // "") else "" end | tostring), ((.currentPhase // "") | tostring)] | @tsv' "$f" 2>/dev/null || true
     done)
 
   for wtroot in "$REPOS"/*/.worktrees; do
@@ -256,7 +271,7 @@ if [ "$STATE_ONLY" -eq 0 ] && [ -d "$REPOS" ]; then
       ph=$(printf '%s' "$row" | cut -f5)
 
       # Rule 1 again: landed work is not residue, whichever pass finds it. Order
-      # matters here - the phase-6/7 test is a proxy for "still waiting", and a
+      # matters here - the phase-4/5 test is a proxy for "still waiting", and a
       # run whose status already says it FINISHED is not waiting for anyone. A
       # complete run sitting at phase 7 was read as waiting and never reaped,
       # which is how three finished worktrees held 5.1 GB indefinitely.
@@ -322,7 +337,8 @@ if [ "$STATE_ONLY" -eq 0 ] && [ -d "$REPOS" ]; then
         continue
       fi
       git -C "$repo" worktree remove --force "$real" >/dev/null 2>&1 || rm -rf "$real"
-      git -C "$repo" worktree prune >/dev/null 2>&1
+      # Same reason as the first pass: a failed prune is not a reason to stop.
+      git -C "$repo" worktree prune >/dev/null 2>&1 || true
       printf '→ removed worktree: %s (%s, %s, idle %sd)\n' "$id" "$why" "$human" "$age_days"
       freed_kb=$((freed_kb + ${size_kb:-0}))
       removed=$((removed + 1))

package/pipeline/scripts/gc-tmp.sh

@@ -107,7 +107,7 @@ NAME_ARGS=(
 # `complaint-analysis-*` needs its own entry: find matches the basename against
 # the whole glob, so `analysis-*` never matched it. Same for the other three,
 # which were writing into $ROOT with nothing sweeping them (phase-0-init.md,
-# phase-6-commit.md, generate-issue.md).
+# phase-4-commit.md, generate-issue.md).
 #
 # `*-wiki` is the one loose pattern here, and a suffix glob over $ROOT could
 # name something a person created. It is narrowed twice: `-type d` above, and

package/pipeline/scripts/gc-worktrees.sh

@@ -21,7 +21,7 @@
 #      `.pipeline/` left behind by a finished run stops reading as residue.
 #
 # Registered, healthy worktrees are NEVER touched. Finishing a task removes its
-# own worktree in Phase 6 (worktree-finalize, v14.1.0+); killing one is
+# own worktree in Phase 4 (worktree-finalize, v14.1.0+); killing one is
 # /multi-agent:kill. This sweep only reaps orphans neither of those left behind.
 #
 # SAFE BY DEFAULT: dry-run. Deletes nothing until you pass --yes.
@@ -34,7 +34,7 @@
 #
 # Exit: 0 on success (including "nothing to do"), 2 on usage error.
 
-set -uo pipefail
+set -euo pipefail
 
 REPO="$PWD"
 DELETE=0
@@ -69,7 +69,9 @@ if ! git -C "$REPO" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
   echo "gc-worktrees: $REPO is not a git work tree  -  nothing to do"
   exit 0
 fi
-REPO="$(cd "$REPO" && pwd -P)"
+# A repo path that cannot be entered is a usage error with a message, not a
+# silent exit 1 three lines before the message exists.
+REPO="$(cd "$REPO" && pwd -P)" || { echo "gc-worktrees: cannot enter $REPO" >&2; exit 2; }
 # Anchor on the MAIN worktree (first porcelain entry) so a run started from a
 # subdirectory OR from inside a linked worktree still targets
 # <main-repo>/.worktrees/ rather than a bogus <subdir>/.worktrees/ (which
@@ -107,7 +109,9 @@ EOF
   for d in "$WT_ROOT"/*/; do
     [ -d "$d" ] || continue
     [ -L "${d%/}" ] && continue  # never follow a symlinked entry out of the tree
-    dir="$(cd "$d" && pwd -P)"
+    # A directory that vanished between the glob and this line is ordinary on a
+    # machine where runs are finishing; skipping it is the answer, not aborting.
+    dir="$(cd "$d" && pwd -P)" || continue
     # Path guard: only ever consider dirs strictly inside <repo>/.worktrees/.
     case "$dir" in "$WT_ROOT"/*) ;; *) continue ;; esac
     if printf '%s\n' "$registered" | grep -qxF "$dir"; then
@@ -120,7 +124,10 @@ EOF
   done
 fi
 for dir in ${orphans+"${orphans[@]}"}; do
-  size=$(du -sh "$dir" 2>/dev/null | cut -f1)
+  # Cosmetic: the size goes in a report line and prints as "?" when du cannot
+  # read it. Under `set -e` with pipefail an unreadable directory would end the
+  # sweep instead.
+  size=$(du -sh "$dir" 2>/dev/null | cut -f1 || true)
   if [ "$DELETE" -eq 1 ]; then
     rm -rf "$dir" && { echo "→ removed orphan worktree dir: ${dir#"$REPO"/} (${size:-?})"; changed=$((changed + 1)); }
   else