switchroom 0.20.7 → 0.20.8

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.20.7", COMMIT_SHA = "bc107185";
+var VERSION = "0.20.8", COMMIT_SHA = "a6efc10f";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -14641,6 +14641,20 @@ var init_overlay_schema = __esm(() => {
 // src/config/overlay-loader.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "node:fs";
 import { basename, resolve as resolve2 } from "node:path";
+function recordReadFailure(agentCfg, failure) {
+  const node = agentCfg;
+  const existing = node[OVERLAY_READ_FAILURES];
+  if (Array.isArray(existing)) {
+    existing.push(failure);
+    return;
+  }
+  Object.defineProperty(agentCfg, OVERLAY_READ_FAILURES, {
+    value: [failure],
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+}
 function deriveOverlayTitle(raw, fileName) {
   const titleFromComment = raw.match(/^#[^\S\n]*name:[^\S\n]*(\S.*?)[^\S\n]*$/m)?.[1];
   if (titleFromComment)
@@ -14650,17 +14664,39 @@ function deriveOverlayTitle(raw, fileName) {
     return;
   return base.length > 0 ? base : undefined;
 }
+function readOverlayFile(agentName, file, agentCfg, warnings) {
+  try {
+    return readFileSync2(file, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT")
+      return;
+    const w = {
+      agent: agentName,
+      file,
+      reason: `read error: ${err.message}`,
+      code: code ?? "EUNKNOWN"
+    };
+    recordReadFailure(agentCfg, { file, code: w.code });
+    warnings.push(w);
+    console.warn(`[switchroom] overlay-loader: agent='${agentName}' file='${file}': ${w.reason}`);
+    return;
+  }
+}
 function overlayDirFor(agentName, subdir) {
   const base = resolveDualPath(`~/.switchroom/agents/${agentName}/${subdir}`);
   return resolve2(base);
 }
-function listYamlFiles(dir) {
+function listYamlFiles(dir, onUnreadableDir) {
   if (!existsSync3(dir))
     return [];
   let entries;
   try {
     entries = readdirSync(dir);
-  } catch {
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT")
+      onUnreadableDir?.(code ?? "EUNKNOWN");
     return [];
   }
   const out = [];
@@ -14698,12 +14734,24 @@ function applyAgentOverlays(config) {
   for (const [agentName, agentCfg] of Object.entries(agents)) {
     try {
       const scheduleDir = overlayDirFor(agentName, "schedule.d");
-      const files = listYamlFiles(scheduleDir);
+      const files = listYamlFiles(scheduleDir, (code) => {
+        const w = {
+          agent: agentName,
+          file: scheduleDir,
+          reason: `read error: cannot list overlay directory (${code})`,
+          code
+        };
+        recordReadFailure(agentCfg, { file: scheduleDir, code });
+        warnings.push(w);
+        console.warn(`[switchroom] overlay-loader: agent='${agentName}' file='${scheduleDir}': ${w.reason}`);
+      });
       if (files.length > 0) {
         const merged = [...agentCfg.schedule ?? []];
         for (const file of files) {
+          const raw = readOverlayFile(agentName, file, agentCfg, warnings);
+          if (raw === undefined)
+            continue;
           try {
-            const raw = readFileSync2(file, "utf-8");
             const parsed = import_yaml.parse(raw);
             const doc = OverlayDocSchema.parse(parsed);
             const title = deriveOverlayTitle(raw, basename(file));
@@ -14738,13 +14786,25 @@ function applyAgentOverlays(config) {
     }
     try {
       const skillsDir = overlayDirFor(agentName, "skills.d");
-      const skillFiles = listYamlFiles(skillsDir);
+      const skillFiles = listYamlFiles(skillsDir, (code) => {
+        const w = {
+          agent: agentName,
+          file: skillsDir,
+          reason: `read error: cannot list overlay directory (${code})`,
+          code
+        };
+        recordReadFailure(agentCfg, { file: skillsDir, code });
+        warnings.push(w);
+        console.warn(`[switchroom] overlay-loader: agent='${agentName}' file='${skillsDir}': ${w.reason}`);
+      });
       if (skillFiles.length === 0) {} else {
         const merged = [...agentCfg.skills ?? []];
         const seen = new Set(merged);
         for (const file of skillFiles) {
+          const raw = readOverlayFile(agentName, file, agentCfg, warnings);
+          if (raw === undefined)
+            continue;
           try {
-            const raw = readFileSync2(file, "utf-8");
             const parsed = import_yaml.parse(raw);
             const doc = OverlayDocSchema.parse(parsed);
             for (const skillName of doc.skills ?? []) {
@@ -14772,7 +14832,7 @@ function applyAgentOverlays(config) {
   }
   return { config, warnings };
 }
-var import_yaml, OVERLAY_SOURCE, OVERLAY_TITLE;
+var import_yaml, OVERLAY_SOURCE, OVERLAY_TITLE, OVERLAY_READ_FAILURES;
 var init_overlay_loader = __esm(() => {
   init_zod();
   init_overlay_schema();
@@ -14780,6 +14840,7 @@ var init_overlay_loader = __esm(() => {
   import_yaml = __toESM(require_dist(), 1);
   OVERLAY_SOURCE = Symbol.for("switchroom.config.overlay-source");
   OVERLAY_TITLE = Symbol.for("switchroom.config.overlay-title");
+  OVERLAY_READ_FAILURES = Symbol.for("switchroom.config.overlay-read-failures");
 });
 
 // src/config/merge.ts
@@ -20448,6 +20509,15 @@ var init_agent_uid = __esm(() => {
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync9, lstatSync as lstatSync2, readdirSync as readdirSync3, statSync as statSync6 } from "node:fs";
 import { join as join5 } from "node:path";
+function isChownVanishedRaceOnly(err) {
+  const e = err;
+  const raw = e?.stderr == null ? "" : e.stderr.toString();
+  const lines = raw.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  if (lines.length === 0)
+    return false;
+  return lines.every((l) => /: No such file or directory$/.test(l));
+}
 function scopedAssertCandidates(agentDir) {
   return [
     join5(agentDir, ".claude", "settings.json"),
@@ -20518,7 +20588,9 @@ var init_agent_owned_tree = __esm(() => {
   SCOPED_RECURSIVE_SUBDIRS = [
     ".claude",
     ".claude-cron",
-    "telegram"
+    "telegram",
+    "schedule.d",
+    "skills.d"
   ];
   SCOPED_TOP_LEVEL_CRITICAL = [
     "start.sh",
@@ -20530,15 +20602,26 @@ var init_agent_owned_tree = __esm(() => {
   ownershipRuntime = {
     geteuid: () => process.geteuid?.(),
     chownTree: (uid, gid, rootDir) => {
-      execFileSync3("chown", ["-h", "-R", `${uid}:${gid}`, rootDir], {
-        stdio: ["ignore", "ignore", "pipe"]
-      });
+      try {
+        execFileSync3("chown", ["-h", "-R", "--", `${uid}:${gid}`, rootDir], {
+          stdio: ["ignore", "ignore", "pipe"],
+          env: { ...process.env, LC_ALL: "C" },
+          maxBuffer: 64 * 1024 * 1024
+        });
+      } catch (err) {
+        const e = err;
+        if (e?.signal != null || typeof e?.status !== "number")
+          throw err;
+        if (!isChownVanishedRaceOnly(err))
+          throw err;
+      }
     },
     chownShallow: (uid, gid, paths) => {
       if (paths.length === 0)
         return;
-      execFileSync3("chown", ["-h", `${uid}:${gid}`, ...paths], {
-        stdio: ["ignore", "ignore", "pipe"]
+      execFileSync3("chown", ["-h", "--", `${uid}:${gid}`, ...paths], {
+        stdio: ["ignore", "ignore", "pipe"],
+        env: { ...process.env, LC_ALL: "C" }
       });
     },
     scopedSweepEnabled: () => process.env[SCOPED_SWEEP_ENV] === "1",
@@ -46933,7 +47016,6 @@ var ManifestSchema, WARN_ONLY_COMPONENTS;
 var init_manifest = __esm(() => {
   init_zod();
   ManifestSchema = exports_external.object({
-    switchroom_version: exports_external.string().min(1),
     tested_at: exports_external.string().min(1),
     runtime: exports_external.object({
       bun: exports_external.string().min(1),
@@ -65426,7 +65508,7 @@ async function checkManifestDrift(probers) {
       {
         name: "dependency manifest",
         status: "ok",
-        detail: `all versions match (manifest ${manifest.switchroom_version})`
+        detail: `all versions match (switchroom ${SWITCHROOM_VERSION})`
       }
     ];
   }
@@ -65812,6 +65894,7 @@ var init_doctor = __esm(() => {
   init_accounts();
   init_schema();
   init_manifest();
+  init_resolve_version();
   init_hindsight2();
   init_hindsight();
   init_host_capabilities();
@@ -85383,6 +85466,7 @@ Scaffolding agent: ${name}
         }
       } catch (err) {
         console.error(source_default.red(`Failed to restart ${n}: ${err.message}`));
+        process.exitCode = 1;
       }
     }
     if (sawAbort) {
@@ -113945,6 +114029,16 @@ async function executeRollout(steps, target, deps, execOpts = {}) {
               timedOut: true
             });
           }
+          if (restartRes.status !== 0) {
+            const gotAfterExit = deps.probeVersion(step.agent);
+            deps.log(`  \u2717 ${step.agent} \u2192 restart exited ${restartRes.status} ` + `(probe says ${gotAfterExit ?? "<unreachable>"}) \u2014 STOPPING`);
+            emit(isCanary ? { phase: "canary-fail", target, agent: step.agent, n: agentIndex, m: totalAgents } : { phase: "agent-done", target, agent: step.agent, n: agentIndex, m: totalAgents });
+            return fail4({
+              failedStep: "restart-agent",
+              failedAgent: step.agent,
+              got: gotAfterExit
+            });
+          }
           const got = deps.probeVersion(step.agent);
           if (got === null || normalizeVersion(got) !== targetNorm) {
             deps.log(`  \u2717 ${step.agent} \u2192 ${got ?? "<unreachable>"} (expected ${target}) \u2014 STOPPING`);
@@ -114635,6 +114729,7 @@ function registerRestartCommand(program3) {
         }
       } catch (err) {
         console.error(source_default.red(`  ${name}: restart failed: ${err.message}`));
+        process.exitCode = 1;
       }
     }
     console.log();
@@ -114645,6 +114740,7 @@ function registerRestartCommand(program3) {
 // src/cli/versions.ts
 init_source();
 init_manifest();
+init_resolve_version();
 function formatRow(component, declared, installed, isDrift, warnOnly) {
   const installedStr = installed ?? source_default.red("(not installed)");
   if (!isDrift) {
@@ -114674,7 +114770,7 @@ function registerVersionsCommand(program3) {
     const driftMap = new Map(report.drift.map((d) => [d.component, d]));
     console.log(source_default.bold(`
 Dependency manifest`));
-    console.log(source_default.gray(`  switchroom ${manifest.switchroom_version}  \u00b7  tested ${manifest.tested_at}`));
+    console.log(source_default.gray(`  switchroom ${SWITCHROOM_VERSION}  \u00b7  tested ${manifest.tested_at}`));
     console.log();
     const bunDrift = driftMap.get("bun");
     console.log(formatRow("bun", manifest.runtime.bun, bunDrift ? bunDrift.installed : manifest.runtime.bun, !!bunDrift, false));
@@ -117367,6 +117463,40 @@ function isEphemeralPath(path10) {
   }
   return false;
 }
+function pushStateFrom(opts) {
+  if (opts.detached)
+    return "detached";
+  if (!opts.upstream)
+    return "no-upstream";
+  if (opts.aheadCount < 0)
+    return "error";
+  if (opts.aheadCount > 0)
+    return "unpushed";
+  return "pushed";
+}
+function isStablePerRepoBranch(branch) {
+  return !!branch && /^agent\/[^/]+\/main$/.test(branch);
+}
+function classifyTaskTree(i2) {
+  if (i2.isRegistryClaimed || i2.isStablePerRepoTree || i2.isEphemeralPath) {
+    return "skip-protected";
+  }
+  if (i2.inUse === "unavailable")
+    return "skip-probe-unavailable";
+  if (i2.inUse === "in-use")
+    return "skip-in-use";
+  if (!i2.clean)
+    return "skip-dirty";
+  if (i2.pushed !== "pushed")
+    return "skip-unpushed";
+  if (!i2.idle)
+    return "skip-active";
+  if (i2.prSignal === "error")
+    return "skip-unknown";
+  if (i2.prSignal !== "merged" && i2.prSignal !== "closed")
+    return "skip-unmerged";
+  return "reap";
+}
 var defaultExec3 = (file, args, cwd) => execFileSync31(file, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).toString();
 function defaultPrSignal(repo, branch, exec) {
   try {
@@ -117399,10 +117529,28 @@ function defaultPrSignal(repo, branch, exec) {
     return "error";
   }
 }
+function defaultNewestTrackedMtimeMs(dir, exec) {
+  let out;
+  try {
+    out = exec("git", ["-C", dir, "ls-files", "-z"]);
+  } catch {
+    return Date.now();
+  }
+  const files = out.split("\x00").filter(Boolean);
+  let newest = 0;
+  for (const f of files) {
+    try {
+      const m = statSync52(join102(dir, f)).mtimeMs;
+      if (m > newest)
+        newest = m;
+    } catch {}
+  }
+  return newest || Date.now();
+}
 function trashRoot() {
   return resolve58(process.env.SWITCHROOM_WORKTREE_TRASH ?? join102(homedir55(), ".switchroom", "worktree-gc-trash"));
 }
-function planGc(roots, deps = {}) {
+function planGc(roots, deps = {}, taskTreeRoots = []) {
   const exists = deps.existsSync ?? existsSync100;
   const readDir = deps.readDir ?? ((p) => readdirSync33(p));
   const readFile4 = deps.readFile ?? ((p) => readFileSync90(p, "utf8"));
@@ -117411,6 +117559,11 @@ function planGc(roots, deps = {}) {
   const prSignal = deps.prSignal ?? ((repo, branch) => defaultPrSignal(repo, branch, exec));
   const stamp = deps.dateStamp ?? "undated";
   const trash = join102(trashRoot(), stamp);
+  const probeInUse = deps.probeInUse ?? probePathInUse;
+  const newestMtime = deps.newestTrackedMtimeMs ?? ((dir) => defaultNewestTrackedMtimeMs(dir, exec));
+  const idleDays = deps.idleDays ?? 14;
+  const nowMs = deps.nowMs ?? Date.now();
+  const escapeHatch = deps.escapeHatch ?? false;
   let claimed;
   try {
     claimed = new Set(listRecords().map((r) => resolve58(r.path)));
@@ -117522,11 +117675,137 @@ function planGc(roots, deps = {}) {
       registered.push({ path: wt.path, branch: wt.branch, verdict, prSignal: sig, repo });
     }
   }
+  const taskTrees = [];
+  for (const root of taskTreeRoots) {
+    if (!exists(root))
+      continue;
+    let entries;
+    try {
+      entries = readDir(root);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const dir = join102(root, name);
+      if (isEphemeralPath(dir))
+        continue;
+      const dotGit = join102(dir, ".git");
+      if (!exists(dotGit))
+        continue;
+      let shape;
+      try {
+        shape = stat3(dotGit).isDirectory() ? "clone" : "worktree";
+      } catch {
+        continue;
+      }
+      let remoteOk = false;
+      try {
+        remoteOk = isSwitchroomRemote(exec("git", ["-C", dir, "remote", "get-url", "origin"]));
+      } catch {
+        remoteOk = false;
+      }
+      if (!remoteOk) {
+        skipped.push({ dir, reason: "not a switchroom task tree" });
+        continue;
+      }
+      let ownerRepo = null;
+      if (shape === "worktree") {
+        try {
+          const ptr = parseGitdirPointer(readFile4(dotGit));
+          if (ptr)
+            ownerRepo = repoRootFromWorktreeGitdir(ptr);
+        } catch {
+          ownerRepo = null;
+        }
+      }
+      let branch = null;
+      let detached = false;
+      try {
+        const b = exec("git", ["-C", dir, "rev-parse", "--abbrev-ref", "HEAD"]).trim();
+        if (b === "HEAD")
+          detached = true;
+        else
+          branch = b;
+      } catch {
+        detached = true;
+      }
+      const claimedWt = claimed.has(resolve58(dir));
+      const stableTree = isStablePerRepoBranch(branch);
+      const ephemeral = isEphemeralPath(dir);
+      const protectedTree = claimedWt || stableTree || ephemeral;
+      let clean3 = false;
+      try {
+        clean3 = isEffectivelyClean(exec("git", ["-C", dir, "status", "--porcelain"]).split(`
+`));
+      } catch {
+        clean3 = false;
+      }
+      let upstream = null;
+      let aheadCount = 0;
+      if (!detached) {
+        try {
+          upstream = exec("git", ["-C", dir, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]).trim() || null;
+        } catch {
+          upstream = null;
+        }
+        if (upstream) {
+          try {
+            aheadCount = parseInt(exec("git", ["-C", dir, "rev-list", "--count", "@{upstream}..HEAD"]).trim(), 10);
+            if (!Number.isFinite(aheadCount))
+              aheadCount = -1;
+          } catch {
+            aheadCount = -1;
+          }
+        }
+      }
+      const pushed = pushStateFrom({ detached, upstream, aheadCount });
+      let idle = false;
+      try {
+        idle = (nowMs - newestMtime(dir)) / 86400000 >= idleDays;
+      } catch {
+        idle = false;
+      }
+      let inUse = "unavailable";
+      let sig = "error";
+      if (!protectedTree) {
+        inUse = probeInUse(dir);
+        if (inUse === "free" && clean3 && pushed === "pushed" && idle && branch) {
+          sig = prSignal(dir, branch);
+        }
+      }
+      const verdict = classifyTaskTree({
+        isRegistryClaimed: claimedWt,
+        isStablePerRepoTree: stableTree,
+        isEphemeralPath: ephemeral,
+        clean: clean3,
+        pushed,
+        prSignal: sig,
+        idle,
+        inUse
+      });
+      const willAct = verdict === "reap" || escapeHatch && idle && (verdict === "skip-dirty" || verdict === "skip-unpushed");
+      if (willAct && ownerRepo)
+        reposToPrune.add(ownerRepo);
+      taskTrees.push({
+        dir,
+        shape,
+        ownerRepo,
+        branch,
+        verdict,
+        prSignal: sig,
+        idle,
+        dest: join102(trash, name),
+        willAct
+      });
+    }
+  }
   return {
     roots,
+    taskTreeRoots,
     trashDir: trash,
     orphans,
     registered,
+    taskTrees,
     reposToPrune: [...reposToPrune],
     skipped
   };
@@ -117542,7 +117821,8 @@ function applyGc(plan, deps = {}) {
     }
   });
   const res = { quarantined: [], removed: [], branchesDeleted: [], pruned: [], errors: [] };
-  if (plan.orphans.length)
+  const taskTreeActions = (plan.taskTrees ?? []).filter((t) => t.willAct);
+  if (plan.orphans.length || taskTreeActions.length)
     mkdirp(plan.trashDir);
   for (const o of plan.orphans) {
     try {
@@ -117552,6 +117832,14 @@ function applyGc(plan, deps = {}) {
       res.errors.push(`quarantine ${o.dir}: ${e.message}`);
     }
   }
+  for (const t of taskTreeActions) {
+    try {
+      move(t.dir, t.dest);
+      res.quarantined.push(t.dir);
+    } catch (e) {
+      res.errors.push(`quarantine ${t.dir}: ${e.message}`);
+    }
+  }
   for (const r of plan.registered) {
     if (r.verdict !== "remove")
       continue;
@@ -117623,6 +117911,24 @@ function purgeTrash(paths) {
 function defaultRoots() {
   return [join102(homedir55(), "code")];
 }
+function defaultTaskTreeRoots() {
+  const agentsDir = join102(homedir55(), ".switchroom", "agents");
+  let names;
+  try {
+    names = readdirSync33(agentsDir);
+  } catch {
+    return [];
+  }
+  const roots = [];
+  for (const name of names.sort()) {
+    for (const sub of ["home/work", "home/workspace"]) {
+      const r = join102(agentsDir, name, sub);
+      if (existsSync100(r))
+        roots.push(r);
+    }
+  }
+  return roots;
+}
 
 // src/cli/worktree.ts
 function registerWorktreeCommand(program3) {
@@ -117756,10 +118062,13 @@ Skipped ${result.skipped.length} stale worktree(s) (kept for safety):`));
       }
     }
   });
-  worktree.command("gc").description(`Reclaim dev worktrees that outlived their PR.
+  worktree.command("gc").description(`Reclaim dev worktrees that outlived their PR, and per-agent task trees.
 ` + `Dry-run by default; pass --yes to act. Quarantines orphaned worktree
 ` + `directories (move, not delete) and removes registered worktrees whose
-` + "PR is MERGED and whose tree is clean.").option("--root <dir>", "Scan root (repeatable). Default: ~/code", (val, acc) => [...acc, val], []).option("--yes", "Actually act (default is dry-run)").option("--json", "Output raw JSON").option("--purge-trash", "Hard-delete quarantined dirs older than --older-than").option("--older-than <days>", "Age threshold for --purge-trash (default 14)", "14").action((opts) => {
+` + `PR is MERGED and whose tree is clean. Also sweeps per-agent home/work
+` + `task trees (all shapes) that are clean + pushed + idle + merged/closed;
+` + `dead-but-dirty/unpushed trees are surfaced and reclaimed only with
+` + "--reclaim-dirty (reversible quarantine).").option("--root <dir>", "Dev-worktree scan root (repeatable). Default: ~/code", (val, acc) => [...acc, val], []).option("--task-root <dir>", "Task-tree scan root (repeatable). Default: every agent's home/work + home/workspace", (val, acc) => [...acc, val], []).option("--no-task-roots", "Skip the per-agent task-tree sweep entirely").option("--idle-days <days>", "Idle threshold for task trees (default 14)", "14").option("--reclaim-dirty", "Operator escape hatch: quarantine IDLE dirty/unpushed task trees (reversible)").option("--yes", "Actually act (default is dry-run)").option("--json", "Output raw JSON").option("--purge-trash", "Hard-delete quarantined dirs older than --older-than").option("--older-than <days>", "Age threshold for --purge-trash (default 14)", "14").action((opts) => {
     if (opts.purgeTrash) {
       const parsed = Number(opts.olderThan);
       const olderThan = isNaN(parsed) ? 14 : parsed;
@@ -117790,9 +118099,14 @@ Re-run with --yes to delete.`));
       return;
     }
     const roots = opts.root.length > 0 ? opts.root : defaultRoots();
+    const taskTreeRoots = opts.taskRoots === false ? [] : opts.taskRoot.length > 0 ? opts.taskRoot : defaultTaskTreeRoots();
+    const parsedIdle = Number(opts.idleDays);
+    const idleDays = Number.isFinite(parsedIdle) && parsedIdle >= 0 ? parsedIdle : 14;
     const dateStamp = new Date().toISOString().slice(0, 10);
-    const plan = planGc(roots, { dateStamp });
+    const plan = planGc(roots, { dateStamp, idleDays, escapeHatch: opts.reclaimDirty }, taskTreeRoots);
     const toRemove = plan.registered.filter((r) => r.verdict === "remove");
+    const taskReap = plan.taskTrees.filter((t) => t.willAct);
+    const taskEscape = plan.taskTrees.filter((t) => !t.willAct && t.idle && (t.verdict === "skip-dirty" || t.verdict === "skip-unpushed"));
     if (!opts.yes) {
       if (opts.json) {
         console.log(JSON.stringify({ dryRun: true, plan }));
@@ -117814,21 +118128,45 @@ Kept (${skips.length}):`));
         for (const r of skips)
           console.log(source_default.dim(`  ${r.verdict.replace("skip-", "")}: ${r.path} [${r.branch}] (pr=${r.prSignal})`));
       }
+      if (taskTreeRoots.length) {
+        const label = opts.reclaimDirty ? "reclaim (reap + escape-hatch)" : "reap (clean + pushed + idle + merged/closed)";
+        console.log(`
+Task trees to ${label}: ${source_default.bold(taskReap.length)}`);
+        for (const t of taskReap)
+          console.log(`  ${t.dir}  ${source_default.dim(`[${t.branch ?? "detached"}] ${t.shape} ${t.verdict} \u2192 ${t.dest}`)}`);
+        if (taskEscape.length) {
+          console.log(source_default.yellow(`
+Dead-but-dirty/unpushed task trees kept (${taskEscape.length}) \u2014 reclaim with --reclaim-dirty:`));
+          for (const t of taskEscape)
+            console.log(source_default.dim(`  ${t.verdict.replace("skip-", "")}: ${t.dir} [${t.branch ?? "detached"}] ${t.shape}`));
+        }
+        const taskKept = plan.taskTrees.filter((t) => !t.willAct && !(t.idle && (t.verdict === "skip-dirty" || t.verdict === "skip-unpushed")) && t.verdict !== "skip-protected");
+        if (taskKept.length) {
+          console.log(source_default.dim(`
+Other task trees kept (${taskKept.length}):`));
+          for (const t of taskKept)
+            console.log(source_default.dim(`  ${t.verdict.replace("skip-", "")}: ${t.dir} [${t.branch ?? "detached"}] (pr=${t.prSignal})`));
+        }
+      }
       if (plan.skipped.length) {
         console.log(source_default.dim(`
 Ignored non-switchroom dirs: ${plan.skipped.length}`));
       }
       console.log(source_default.dim(`
-Re-run with --yes to act. Orphans are MOVED to the trash dir, not deleted.`));
+Re-run with --yes to act. Reclaimed trees are MOVED to the trash dir, not deleted.`));
       return;
     }
     const result = applyGc(plan);
     if (opts.json) {
       console.log(JSON.stringify(result));
     } else {
-      console.log(source_default.green(`Quarantined ${result.quarantined.length} orphan(s) \u2192 ${plan.trashDir}`));
+      console.log(source_default.green(`Quarantined ${result.quarantined.length} dir(s) \u2192 ${plan.trashDir}`));
       console.log(source_default.green(`Removed ${result.removed.length} merged worktree(s); deleted ${result.branchesDeleted.length} branch(es).`));
       console.log(source_default.dim(`Pruned metadata in ${result.pruned.length} repo(s).`));
+      if (taskEscape.length && !opts.reclaimDirty) {
+        console.log(source_default.yellow(`
+${taskEscape.length} dead-but-dirty/unpushed task tree(s) were kept. Reclaim reversibly with --reclaim-dirty.`));
+      }
       for (const e of result.errors)
         console.warn(source_default.yellow(e));
       console.log(source_default.dim(`
@@ -120405,6 +120743,7 @@ var import_yaml22 = __toESM(require_dist(), 1);
 // src/config/overlay-writer.ts
 init_paths();
 import {
+  chownSync as chownSync11,
   closeSync as closeSync18,
   existsSync as existsSync103,
   fsyncSync as fsyncSync8,
@@ -120481,6 +120820,21 @@ function withAgentLock(paths, fn) {
     } catch {}
   }
 }
+var overlayWriterRuntime = {
+  geteuid: () => process.geteuid?.(),
+  chown: (path10, uid, gid) => chownSync11(path10, uid, gid)
+};
+function alignStagedOwnerToDir(stagingPath, targetDir) {
+  try {
+    const euid = overlayWriterRuntime.geteuid();
+    if (euid === undefined)
+      return;
+    const dirStat = statSync54(targetDir);
+    if (dirStat.uid === euid)
+      return;
+    overlayWriterRuntime.chown(stagingPath, dirStat.uid, dirStat.gid);
+  } catch {}
+}
 function writeOverlayEntry(agent, slug, yamlText, opts = {}) {
   const paths = overlayPathsFor(agent, opts);
   return withAgentLock(paths, () => {
@@ -120494,6 +120848,7 @@ function writeOverlayEntry(agent, slug, yamlText, opts = {}) {
     } finally {
       closeSync18(fd);
     }
+    alignStagedOwnerToDir(stagingPath, paths.scheduleDir);
     renameSync27(stagingPath, finalPath);
     return finalPath;
   });
@@ -120511,6 +120866,7 @@ function writeSkillsOverlayEntry(agent, slug, yamlText, opts = {}) {
     } finally {
       closeSync18(fd);
     }
+    alignStagedOwnerToDir(stagingPath, paths.skillsDir);
     renameSync27(stagingPath, finalPath);
     return finalPath;
   });
@@ -123985,7 +124341,7 @@ init_source();
 init_helpers();
 init_operator_uid();
 init_compose();
-import { chownSync as chownSync11, existsSync as existsSync112, mkdirSync as mkdirSync65, writeFileSync as writeFileSync48, copyFileSync as copyFileSync15 } from "node:fs";
+import { chownSync as chownSync12, existsSync as existsSync112, mkdirSync as mkdirSync65, writeFileSync as writeFileSync48, copyFileSync as copyFileSync15 } from "node:fs";
 import { homedir as homedir62 } from "node:os";
 import { join as join115 } from "node:path";
 import { spawnSync as spawnSync27 } from "node:child_process";
@@ -124165,10 +124521,10 @@ async function doInstall2(opts, program3) {
   writeFileSync48(composePath, yaml, "utf8");
   try {
     if (typeof process.geteuid === "function" && process.geteuid() === 0) {
-      chownSync11(dir, operatorUid, operatorUid);
-      chownSync11(composePath, operatorUid, operatorUid);
+      chownSync12(dir, operatorUid, operatorUid);
+      chownSync12(composePath, operatorUid, operatorUid);
       if (bak)
-        chownSync11(bak, operatorUid, operatorUid);
+        chownSync12(bak, operatorUid, operatorUid);
     }
   } catch {}
   console.log(source_default.green(`  \u2713 Wrote ${composePath}`));