@cnwenf/occ 2.1.253 → 2.1.254

package/dist/cli.js

@@ -57636,10 +57636,15 @@ var init_env = __esm(() => {
   init_which();
   getGlobalClaudeFile = memoize_default(() => {
     if (getFsImplementation().existsSync(join16(getClaudeConfigHomeDir(), ".config.json"))) {
+      process.stderr.write(`[DIAGCFG] getGlobalClaudeFile -> legacy .config.json at ${join16(getClaudeConfigHomeDir(), ".config.json")}
+`);
       return join16(getClaudeConfigHomeDir(), ".config.json");
     }
     const filename = `.claude${fileSuffixForOauthConfig()}.json`;
-    return join16(process.env.CLAUDE_CONFIG_DIR || homedir7(), filename);
+    const p = join16(process.env.CLAUDE_CONFIG_DIR || homedir7(), filename);
+    process.stderr.write(`[DIAGCFG] getGlobalClaudeFile -> ${p} (homedir=${homedir7()} CLAUDE_CONFIG_DIR=${process.env.CLAUDE_CONFIG_DIR ?? "unset"})
+`);
+    return p;
   });
   hasInternetAccess = memoize_default(async () => {
     try {
@@ -363766,10 +363771,10 @@ function parseSource(source, timeoutMs) {
     stopToken: null
   };
   try {
-    const program = parseProgram(P2);
+    const program2 = parseProgram(P2);
     if (P2.aborted)
       return null;
-    return program;
+    return program2;
   } catch {
     return null;
   }
@@ -650450,13 +650455,331 @@ var init_chromeNativeHost = __esm(() => {
   }).passthrough());
 });
 
+// src/daemon/process.ts
+import { execFileSync as execFileSync5 } from "child_process";
+function isPidAlive(pid) {
+  if (!pid || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err2) {
+    return err2?.code === "EPERM";
+  }
+}
+function getProcessStartMs(pid) {
+  if (!pid || pid <= 0)
+    return null;
+  let out;
+  try {
+    out = execFileSync5("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2000
+    }).trim();
+  } catch {
+    return null;
+  }
+  if (!out)
+    return null;
+  const ms = Date.parse(out);
+  return Number.isFinite(ms) ? ms : null;
+}
+function pidRecycled(pid, startedAt) {
+  if (!isPidAlive(pid)) {
+    return false;
+  }
+  const actualStart = getProcessStartMs(pid);
+  if (actualStart === null) {
+    return false;
+  }
+  const tolerance = 2000;
+  return actualStart > startedAt + tolerance;
+}
+function sigtermWorker(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureZombieKill(pid, graceMs = 3000) {
+  if (!isPidAlive(pid))
+    return true;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {}
+  const deadline = Date.now() + graceMs;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(pid))
+      return true;
+    await new Promise((r4) => setTimeout(r4, 150));
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {}
+  await new Promise((r4) => setTimeout(r4, 200));
+  return !isPidAlive(pid);
+}
+var init_process = () => {};
+
 // src/daemon/workerRegistry.ts
 var exports_workerRegistry = {};
 __export(exports_workerRegistry, {
-  runDaemonWorker: () => runDaemonWorker
+  validateDaemonJsonWorkers: () => validateDaemonJsonWorkers,
+  sweepWorkers: () => sweepWorkers,
+  stopAllWorkers: () => stopAllWorkers,
+  spawnWorker: () => spawnWorker,
+  settleWorker: () => settleWorker,
+  runDaemonWorker: () => runDaemonWorker,
+  readDaemonJson: () => readDaemonJson,
+  listWorkers: () => listWorkers,
+  getWorker: () => getWorker,
+  getDaemonJsonPath: () => getDaemonJsonPath,
+  forceRespawnWorker: () => forceRespawnWorker,
+  eStale: () => eStale,
+  DEFAULT_PREWARM_PER_SWEEP: () => DEFAULT_PREWARM_PER_SWEEP
+});
+import { spawn as spawn13 } from "child_process";
+import { existsSync as existsSync15, readFileSync as readFileSync26 } from "fs";
+import { join as join156 } from "path";
+function getDaemonJsonPath() {
+  return join156(getClaudeConfigHomeDir(), "daemon.json");
+}
+function nextWorkerId() {
+  return `w${_nextId++}`;
+}
+function readDaemonJson() {
+  const path28 = getDaemonJsonPath();
+  if (!existsSync15(path28)) {
+    return { prewarmPerSweep: DEFAULT_PREWARM_PER_SWEEP };
+  }
+  let raw;
+  try {
+    raw = readFileSync26(path28, { encoding: "utf-8" });
+  } catch {
+    return { prewarmPerSweep: DEFAULT_PREWARM_PER_SWEEP };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    console.error("daemon.json is malformed \u2014 ignoring worker config");
+    logEvent("daemon_json_malformed", {});
+    return { prewarmPerSweep: DEFAULT_PREWARM_PER_SWEEP };
+  }
+  const config7 = {
+    workers: Array.isArray(parsed?.workers) ? parsed.workers : undefined,
+    scheduled: Array.isArray(parsed?.scheduled) ? parsed.scheduled : undefined,
+    prewarmPerSweep: typeof parsed?.prewarmPerSweep === "number" ? parsed.prewarmPerSweep : DEFAULT_PREWARM_PER_SWEEP
+  };
+  return config7;
+}
+function validateDaemonJsonWorkers(config7) {
+  const warnings = [];
+  if (!config7.workers || config7.workers.length === 0)
+    return warnings;
+  const knownKinds = new Set(["default", "prewarm", "remote_control"]);
+  for (const w3 of config7.workers) {
+    if (!w3?.kind || !knownKinds.has(w3.kind)) {
+      warnings.push(`has configured workers but they do not match a known kind: ${w3?.kind ?? "(missing)"}`);
+    }
+  }
+  return warnings;
+}
+function getCliVersion() {
+  const macro = globalThis.MACRO;
+  return macro?.VERSION ?? "unknown";
+}
+function spawnWorker(kind, opts) {
+  const id = opts?.id ?? nextWorkerId();
+  const cwd2 = opts?.cwd ?? getCwd();
+  const entry = process.argv[1] ?? "dist/cli.js";
+  const existing = registry2.get(id);
+  if (existing && isPidAlive(existing.pid)) {
+    sigtermWorker(existing.pid);
+  }
+  const child = spawn13(process.execPath, [entry, "--daemon-worker", kind], {
+    cwd: cwd2,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false,
+    env: {
+      ...process.env,
+      CLAUDE_CODE_DAEMON_WORKER: "1",
+      CLAUDE_CODE_DAEMON_WORKER_KIND: kind
+    }
+  });
+  const record3 = {
+    pid: child.pid ?? -1,
+    outcome: "running",
+    cliVersion: getCliVersion(),
+    startedAt: Date.now(),
+    cwd: cwd2,
+    restart: existing?.restart ?? 0,
+    kind,
+    id
+  };
+  registry2.set(id, record3);
+  children2.set(id, child);
+  child.on("exit", (code, signal) => {
+    const rec = registry2.get(id);
+    if (!rec)
+      return;
+    rec.exitCode = code ?? undefined;
+    if (signal === "SIGTERM")
+      rec.outcome = "sigterm";
+    else if (signal === "SIGKILL")
+      rec.outcome = "sigkill";
+    else if (code === 0)
+      rec.outcome = "exited_clean";
+    else
+      rec.outcome = "exited_error";
+    children2.delete(id);
+  });
+  child.on("error", () => {
+    const rec = registry2.get(id);
+    if (rec)
+      rec.outcome = "exited_error";
+    children2.delete(id);
+  });
+  return record3;
+}
+async function settleWorker(id, graceMs = 3000) {
+  const rec = registry2.get(id);
+  if (!rec)
+    return;
+  const child = children2.get(id);
+  if (child && isPidAlive(rec.pid)) {
+    sigtermWorker(rec.pid);
+    const deadline = Date.now() + graceMs;
+    while (Date.now() < deadline) {
+      if (!isPidAlive(rec.pid))
+        break;
+      await new Promise((r4) => setTimeout(r4, 100));
+    }
+  }
+  if (rec && isPidAlive(rec.pid)) {
+    rec.outcome = "stalled";
+  }
+}
+function listWorkers() {
+  return Array.from(registry2.values());
+}
+function getWorker(id) {
+  return registry2.get(id);
+}
+async function sweepWorkers(config7) {
+  const prewarmPerSweep = config7.prewarmPerSweep ?? DEFAULT_PREWARM_PER_SWEEP;
+  let alive = 0;
+  for (const rec of registry2.values()) {
+    if (rec.outcome !== "running")
+      continue;
+    if (!isPidAlive(rec.pid)) {
+      rec.outcome = "exited_clean";
+      continue;
+    }
+    if (pidRecycled(rec.pid, rec.startedAt)) {
+      rec.outcome = "stalled";
+      eStale(rec, "pid_recycled");
+      continue;
+    }
+    alive++;
+  }
+  const prewarmAlive = Array.from(registry2.values()).filter((w3) => w3.kind === "prewarm" && w3.outcome === "running" && isPidAlive(w3.pid)).length;
+  const toPrewarm = Math.max(0, prewarmPerSweep - prewarmAlive);
+  for (let i6 = 0;i6 < toPrewarm; i6++) {
+    const rec = spawnWorker("prewarm");
+    logEvent("tengu_bg_prewarm_per_sweep", {
+      kind: "prewarm",
+      pid: rec.pid
+    });
+  }
+  if (config7.workers) {
+    for (const w3 of config7.workers) {
+      const kind = w3.kind;
+      const has2 = Array.from(registry2.values()).some((r4) => r4.kind === kind && r4.outcome === "running" && isPidAlive(r4.pid));
+      if (!has2) {
+        spawnWorker(kind, { cwd: w3?.["cwd"] });
+      }
+    }
+  }
+  return alive;
+}
+function eStale(rec, reason) {
+  rec.outcome = "stalled";
+  logEvent("tengu_bg_worker_stale", {
+    kind: rec.kind,
+    reason,
+    pid: rec.pid,
+    restart: rec.restart
+  });
+  const fresh = spawnWorker(rec.kind, { cwd: rec.cwd });
+  fresh.restart = rec.restart + 1;
+  registry2.set(fresh.id, fresh);
+}
+async function stopAllWorkers(graceMs = 3000) {
+  const ids = Array.from(registry2.keys());
+  await Promise.all(ids.map((id) => settleWorker(id, graceMs)));
+  registry2.clear();
+  children2.clear();
+}
+function forceRespawnWorker(id) {
+  const rec = registry2.get(id);
+  if (!rec)
+    return null;
+  if (isPidAlive(rec.pid)) {
+    try {
+      process.kill(rec.pid, "SIGKILL");
+    } catch {}
+  }
+  const fresh = spawnWorker(rec.kind, { cwd: rec.cwd, id });
+  fresh.restart = rec.restart + 1;
+  registry2.set(id, fresh);
+  return fresh;
+}
+var DEFAULT_PREWARM_PER_SWEEP = 3, registry2, children2, _nextId = 1, runDaemonWorker = async (workerId) => {
+  const kind = workerId || process.env.CLAUDE_CODE_DAEMON_WORKER_KIND || "default";
+  const startMs = Date.now();
+  const parentPpid = process.ppid;
+  console.log(`[daemon-worker] kind=${kind} pid=${process.pid} parent=${parentPpid} ready`);
+  let settling = false;
+  const shutdown = async (signal) => {
+    if (settling)
+      return;
+    settling = true;
+    console.log(`[daemon-worker] kind=${kind} received ${signal}, settling`);
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  const orphanWatch = setInterval(() => {
+    if (!isPidAlive(parentPpid)) {
+      console.log(`orphan watchdog: ppid ${parentPpid}\u2192process.ppid, no client found`);
+      console.log("parent supervisor gone \u2014 exiting");
+      clearInterval(orphanWatch);
+      process.exit(0);
+    }
+  }, 5000);
+  const idleCapMs = 30 * 60 * 1000;
+  const idleDeadline = startMs + idleCapMs;
+  while (!settling) {
+    const now2 = Date.now();
+    if (now2 > idleDeadline) {
+      console.log(`[daemon-worker] kind=${kind} idle cap reached, exiting`);
+      process.exit(0);
+    }
+    await new Promise((r4) => setTimeout(r4, 1000));
+  }
+};
+var init_workerRegistry = __esm(() => {
+  init_envUtils();
+  init_cwd2();
+  init_analytics();
+  init_process();
+  registry2 = new Map;
+  children2 = new Map;
 });
-var runDaemonWorker = () => Promise.resolve();
-var init_workerRegistry = () => {};
 
 // src/bridge/bridgeUI.ts
 async function generateQr(url3) {
@@ -651034,10 +651357,10 @@ var init_pollConfig = __esm(() => {
 });
 
 // src/bridge/sessionRunner.ts
-import { spawn as spawn13 } from "child_process";
+import { spawn as spawn14 } from "child_process";
 import { createWriteStream as createWriteStream4 } from "fs";
 import { tmpdir as tmpdir14 } from "os";
-import { dirname as dirname67, join as join156 } from "path";
+import { dirname as dirname67, join as join157 } from "path";
 import { createInterface as createInterface2 } from "readline";
 function safeFilenameId(id) {
   return id.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -651170,12 +651493,12 @@ function createSessionSpawner(deps) {
           debugFile = `${deps.debugFile}-${safeId}`;
         }
       } else if (deps.verbose || process.env.USER_TYPE === "ant") {
-        debugFile = join156(tmpdir14(), "claude", `bridge-session-${safeId}.log`);
+        debugFile = join157(tmpdir14(), "claude", `bridge-session-${safeId}.log`);
       }
       let transcriptStream = null;
       let transcriptPath;
       if (deps.debugFile) {
-        transcriptPath = join156(dirname67(deps.debugFile), `bridge-transcript-${safeId}.jsonl`);
+        transcriptPath = join157(dirname67(deps.debugFile), `bridge-transcript-${safeId}.jsonl`);
         transcriptStream = createWriteStream4(transcriptPath, { flags: "a" });
         transcriptStream.on("error", (err2) => {
           deps.onDebug(`[bridge:session] Transcript write error: ${err2.message}`);
@@ -651216,7 +651539,7 @@ function createSessionSpawner(deps) {
       if (debugFile) {
         deps.onDebug(`[bridge:session] Debug log: ${debugFile}`);
       }
-      const child = spawn13(deps.execPath, args, {
+      const child = spawn14(deps.execPath, args, {
         cwd: dir,
         stdio: ["pipe", "pipe", "pipe"],
         env: env6,
@@ -651449,9 +651772,9 @@ __export(exports_bridgePointer, {
   BRIDGE_POINTER_TTL_MS: () => BRIDGE_POINTER_TTL_MS
 });
 import { mkdir as mkdir54, readFile as readFile62, stat as stat49, unlink as unlink25, writeFile as writeFile56 } from "fs/promises";
-import { dirname as dirname68, join as join157 } from "path";
+import { dirname as dirname68, join as join158 } from "path";
 function getBridgePointerPath(dir) {
-  return join157(getProjectsDir(), sanitizePath2(dir), "bridge-pointer.json");
+  return join158(getProjectsDir(), sanitizePath2(dir), "bridge-pointer.json");
 }
 async function writeBridgePointer(dir, pointer) {
   const path28 = getBridgePointerPath(dir);
@@ -651553,12 +651876,12 @@ var init_bridgePointer = __esm(() => {
 });
 
 // src/utils/errorLogSink.ts
-import { dirname as dirname69, join as join158 } from "path";
+import { dirname as dirname69, join as join159 } from "path";
 function getErrorsPath() {
-  return join158(CACHE_PATHS.errors(), DATE + ".jsonl");
+  return join159(CACHE_PATHS.errors(), DATE + ".jsonl");
 }
 function getMCPLogsPath(serverName) {
-  return join158(CACHE_PATHS.mcpLogs(serverName), DATE + ".jsonl");
+  return join159(CACHE_PATHS.mcpLogs(serverName), DATE + ".jsonl");
 }
 function createJsonlWriter(options) {
   const writer = createBufferedWriter(options);
@@ -651714,7 +652037,7 @@ __export(exports_bridgeMain, {
 });
 import { randomUUID as randomUUID41 } from "crypto";
 import { hostname as hostname4, tmpdir as tmpdir15 } from "os";
-import { basename as basename49, join as join159, resolve as resolve49 } from "path";
+import { basename as basename49, join as join160, resolve as resolve49 } from "path";
 async function isMultiSessionSpawnEnabled() {
   return checkGate_CACHED_OR_BLOCKING("tengu_ccr_bridge_multi_session");
 }
@@ -651845,7 +652168,7 @@ async function runBridgeLoop(config7, environmentId, environmentSecret, api4, sp
       const ext = config7.debugFile.lastIndexOf(".");
       debugGlob = ext > 0 ? `${config7.debugFile.slice(0, ext)}-*${config7.debugFile.slice(ext)}` : `${config7.debugFile}-*`;
     } else {
-      debugGlob = join159(tmpdir15(), "claude", "bridge-session-*.log");
+      debugGlob = join160(tmpdir15(), "claude", "bridge-session-*.log");
     }
     logger30.setDebugLogPath(debugGlob);
   }
@@ -652236,7 +652559,7 @@ async function runBridgeLoop(config7, environmentId, environmentSecret, api4, sp
               sessionDebugFile = `${config7.debugFile}-${safeId}`;
             }
           } else if (config7.verbose || process.env.USER_TYPE === "ant") {
-            sessionDebugFile = join159(tmpdir15(), "claude", `bridge-session-${safeId}.log`);
+            sessionDebugFile = join160(tmpdir15(), "claude", `bridge-session-${safeId}.log`);
           }
           if (sessionDebugFile) {
             logger30.logVerbose(`Debug log: ${sessionDebugFile}`);
@@ -653335,24 +653658,833 @@ var init_bridgeMain = __esm(() => {
   };
 });
 
+// src/daemon/lockfile.ts
+import { open as open15, readFile as readFile63, unlink as unlink26 } from "fs/promises";
+import { existsSync as existsSync16, statSync as statSync15 } from "fs";
+import { join as join161 } from "path";
+function getDaemonLockfilePath() {
+  return join161(getClaudeConfigHomeDir(), "daemon.lock");
+}
+async function readLockfile() {
+  const path28 = getDaemonLockfilePath();
+  if (!existsSync16(path28)) {
+    return null;
+  }
+  try {
+    const raw = await readFile63(path28, { encoding: "utf-8" });
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.supervisorPid !== "number" || typeof parsed?.supervisorProcStart !== "number") {
+      return null;
+    }
+    return {
+      supervisorPid: parsed.supervisorPid,
+      supervisorProcStart: parsed.supervisorProcStart,
+      holderPid: typeof parsed.holderPid === "number" ? parsed.holderPid : parsed.supervisorPid
+    };
+  } catch {
+    return null;
+  }
+}
+async function acquireLockfile(identity8) {
+  const path28 = getDaemonLockfilePath();
+  const { mkdir: mkdir55 } = await import("fs/promises");
+  await mkdir55(getClaudeConfigHomeDir(), { recursive: true }).catch(() => {});
+  if (!existsSync16(path28)) {
+    try {
+      const fh = await open15(path28, "ax");
+      const contents = {
+        supervisorPid: identity8.supervisorPid,
+        supervisorProcStart: identity8.supervisorProcStart,
+        holderPid: identity8.supervisorPid
+      };
+      await fh.writeFile(JSON.stringify(contents), { encoding: "utf-8" });
+      await fh.close();
+      return true;
+    } catch (err2) {
+      if (err2?.code !== "EEXIST") {
+        return false;
+      }
+    }
+  }
+  const existing = await readLockfile();
+  if (!existing) {
+    try {
+      await unlink26(path28);
+    } catch {}
+    return acquireLockfile(identity8);
+  }
+  if (existing.supervisorPid === identity8.supervisorPid && existing.supervisorProcStart === identity8.supervisorProcStart) {
+    return true;
+  }
+  const holderAlive = isPidAlive(existing.supervisorPid);
+  const holderStartMs = getProcessStartMs(existing.supervisorPid);
+  const startMatches = holderStartMs !== null && Math.abs(holderStartMs - existing.supervisorProcStart) < 2000;
+  if (holderAlive && startMatches) {
+    console.log(`lockfile now held by pid=${existing.supervisorPid} \u2014 displaced, yielding`);
+    return false;
+  }
+  try {
+    await unlink26(path28);
+  } catch {}
+  try {
+    const fh = await open15(path28, "ax");
+    const contents = {
+      supervisorPid: identity8.supervisorPid,
+      supervisorProcStart: identity8.supervisorProcStart,
+      holderPid: identity8.supervisorPid
+    };
+    await fh.writeFile(JSON.stringify(contents), { encoding: "utf-8" });
+    await fh.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function releaseLockfile(identity8) {
+  const existing = await readLockfile();
+  if (!existing)
+    return;
+  if (existing.supervisorPid === identity8.supervisorPid && existing.supervisorProcStart === identity8.supervisorProcStart) {
+    try {
+      await unlink26(getDaemonLockfilePath());
+    } catch {}
+  }
+}
+async function displaceHolder() {
+  const existing = await readLockfile();
+  if (!existing) {
+    return { displaced: false, holder: null };
+  }
+  const holderStartMs = getProcessStartMs(existing.supervisorPid);
+  const startMatches = holderStartMs !== null && Math.abs(holderStartMs - existing.supervisorProcStart) < 2000;
+  if (!isPidAlive(existing.supervisorPid) || !startMatches) {
+    await releaseLockfile({
+      supervisorPid: existing.supervisorPid,
+      supervisorProcStart: existing.supervisorProcStart
+    }).catch(() => {});
+    return { displaced: true, holder: existing };
+  }
+  try {
+    process.kill(existing.supervisorPid, "SIGTERM");
+  } catch {}
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(existing.supervisorPid))
+      break;
+    await new Promise((r4) => setTimeout(r4, 200));
+  }
+  if (isPidAlive(existing.supervisorPid)) {
+    try {
+      process.kill(existing.supervisorPid, "SIGKILL");
+    } catch {}
+    await new Promise((r4) => setTimeout(r4, 300));
+  }
+  await releaseLockfile({
+    supervisorPid: existing.supervisorPid,
+    supervisorProcStart: existing.supervisorProcStart
+  }).catch(() => {});
+  return { displaced: true, holder: existing };
+}
+function lockfileMtime() {
+  try {
+    return statSync15(getDaemonLockfilePath()).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+var init_lockfile = __esm(() => {
+  init_envUtils();
+  init_process();
+});
+
+// src/daemon/respawn.ts
+import { execFileSync as execFileSync6 } from "child_process";
+function findOrphanedWorkers() {
+  let out;
+  try {
+    out = execFileSync6("ps", ["-e", "-o", "pid=,ppid=,command="], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3000
+    });
+  } catch {
+    return [];
+  }
+  const orphans = [];
+  for (const line of out.split(`
+`)) {
+    const m5 = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+    if (!m5)
+      continue;
+    const pid = Number(m5[1]);
+    const ppid = Number(m5[2]);
+    const cmd = m5[3];
+    if (!cmd.includes("--daemon-worker"))
+      continue;
+    if (pid === process.pid)
+      continue;
+    if (!isPidAlive(ppid)) {
+      orphans.push({ pid, ppid, cmd });
+    }
+  }
+  return orphans;
+}
+function recoverOrphanedWorkers() {
+  const orphans = findOrphanedWorkers();
+  if (orphans.length > 0) {
+    console.log("background agent(s) orphaned by previous process exit");
+    console.log(`[print.ts] ${orphans.length} orphaned background task(s) after restart`);
+    logEvent("tengu_bg_orphan_recovery", { count: orphans.length });
+    for (const o5 of orphans) {
+      console.log(`orphan watchdog: ppid ${o5.ppid}\u2192process.ppid, no client found (pid=${o5.pid})`);
+      try {
+        process.kill(o5.pid, "SIGTERM");
+      } catch {}
+    }
+  }
+  return orphans.length;
+}
+var init_respawn = __esm(() => {
+  init_analytics();
+  init_process();
+  init_workerRegistry();
+});
+
+// src/daemon/install.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11, unlinkSync as unlinkSync5 } from "fs";
+import { homedir as homedir40 } from "os";
+import { join as join162 } from "path";
+import { spawnSync as spawnSync9 } from "child_process";
+function detectInstallPlatform() {
+  if (process.platform === "darwin") {
+    return existsSync17("/bin/launchctl") ? "launchd" : "unsupported";
+  }
+  if (process.platform === "linux") {
+    return existsSync17("/bin/systemctl") || existsSync17("/usr/bin/systemctl") ? "systemd" : "unsupported";
+  }
+  return "unsupported";
+}
+function cliEntry() {
+  return process.argv[1] ?? "dist/cli.js";
+}
+function launchdPlistPath() {
+  return join162(homedir40(), "Library", "LaunchAgents", "com.anthropic.claude.daemon.plist");
+}
+function systemdUnitPath() {
+  return join162(homedir40(), ".config", "systemd", "user", "claude-daemon.service");
+}
+function installPersistentService() {
+  const plat = detectInstallPlatform();
+  if (plat === "unsupported") {
+    const msg = `claude daemon install isn't available on ${process.platform} (no launchd/systemd)`;
+    logEvent("daemon_install_unsupported", { platform: process.platform });
+    return msg;
+  }
+  if (plat === "launchd") {
+    return installLaunchd();
+  }
+  return installSystemd();
+}
+function installLaunchd() {
+  const plistPath = launchdPlistPath();
+  mkdirSync11(join162(plistPath, ".."), { recursive: true });
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.anthropic.claude.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${process.execPath}</string>
+    <string>${cliEntry()}</string>
+    <string>daemon</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join162(homedir40(), ".claude", "daemon.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join162(homedir40(), ".claude", "daemon.log")}</string>
+</dict>
+</plist>
+`;
+  writeFileSync11(plistPath, plist, { encoding: "utf-8" });
+  spawnSync9("launchctl", ["unload", plistPath], { stdio: "ignore" });
+  const res = spawnSync9("launchctl", ["load", plistPath], { encoding: "utf-8" });
+  logEvent("daemon_install_launchd", { ok: res.status === 0 });
+  return res.status === 0 ? `launchd unit installed at ${plistPath}` : `launchd install failed: ${res.stderr?.trim() ?? "unknown error"}`;
+}
+function installSystemd() {
+  const unitPath = systemdUnitPath();
+  mkdirSync11(join162(unitPath, ".."), { recursive: true });
+  const unit = `[Unit]
+Description=Claude Code background-agent daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${cliEntry()} daemon start
+Restart=on-failure
+RestartSec=2
+StandardOutput=append:${join162(homedir40(), ".claude", "daemon.log")}
+StandardError=append:${join162(homedir40(), ".claude", "daemon.log")}
+
+[Install]
+WantedBy=default.target
+`;
+  writeFileSync11(unitPath, unit, { encoding: "utf-8" });
+  spawnSync9("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+  spawnSync9("systemctl", ["--user", "enable", "claude-daemon.service"], { stdio: "ignore" });
+  spawnSync9("loginctl", ["enable-linger", process.env.USER ?? "root"], {
+    stdio: "ignore"
+  });
+  logEvent("daemon_install_systemd", {});
+  return `systemd unit installed at ${unitPath} (enable-linger ${process.env.USER ?? "root"})`;
+}
+function uninstallPersistentService() {
+  const plat = detectInstallPlatform();
+  if (plat === "launchd") {
+    const plistPath = launchdPlistPath();
+    spawnSync9("launchctl", ["unload", plistPath], { stdio: "ignore" });
+    try {
+      unlinkSync5(plistPath);
+    } catch {}
+    logEvent("daemon_uninstall_launchd", {});
+    return `launchd unit removed`;
+  }
+  if (plat === "systemd") {
+    spawnSync9("systemctl", ["--user", "disable", "claude-daemon.service"], {
+      stdio: "ignore"
+    });
+    try {
+      unlinkSync5(systemdUnitPath());
+    } catch {}
+    spawnSync9("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+    logEvent("daemon_uninstall_systemd", {});
+    return `systemd unit removed`;
+  }
+  return `claude daemon uninstall isn't available on ${process.platform} (no launchd/systemd)`;
+}
+var init_install = __esm(() => {
+  init_analytics();
+});
+
+// src/daemon/supervisor.ts
+import { existsSync as existsSync18, statSync as statSync16 } from "fs";
+function buildIdentity() {
+  return {
+    supervisorPid: process.pid,
+    supervisorProcStart: Date.now()
+  };
+}
+function getDaemonColdStart() {
+  const env6 = process.env.CLAUDE_CODE_DAEMON_COLD_START;
+  if (env6 === "transient" || env6 === "ask")
+    return env6;
+  const fromConfig = getGlobalConfig().daemonColdStart;
+  if (fromConfig === "transient" || fromConfig === "ask")
+    return fromConfig;
+  return "transient";
+}
+function checkBinaryIdentity() {
+  const execPath2 = process.execPath;
+  const entry = process.argv[1];
+  try {
+    if (!execPath2 || !existsSync18(execPath2)) {
+      return "binary identity unresolvable";
+    }
+    statSync16(execPath2);
+  } catch {
+    return "binary identity unresolvable";
+  }
+  if (entry) {
+    try {
+      if (!existsSync18(entry)) {
+        return `binary at ${entry} was deleted`;
+      }
+    } catch {
+      return `binary at ${entry} was deleted`;
+    }
+  }
+  return null;
+}
+async function holderRefusesToYield() {
+  const existing = await readLockfile();
+  if (!existing)
+    return false;
+  return isPidAlive(existing.supervisorPid);
+}
+async function stopExistingSupervisor() {
+  const existing = await readLockfile();
+  if (!existing) {
+    return { stopped: false, holder: null, eperm: false };
+  }
+  if (!isPidAlive(existing.supervisorPid)) {
+    await releaseLockfile({
+      supervisorPid: existing.supervisorPid,
+      supervisorProcStart: existing.supervisorProcStart
+    }).catch(() => {});
+    return { stopped: true, holder: existing, eperm: false };
+  }
+  let eperm = false;
+  try {
+    process.kill(existing.supervisorPid, "SIGTERM");
+  } catch (err2) {
+    if (err2?.code === "EPERM") {
+      eperm = true;
+      console.error("could not restart supervisor (EPERM)");
+      await ensureZombieKill(existing.supervisorPid, 4000);
+    }
+  }
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(existing.supervisorPid))
+      break;
+    await new Promise((r4) => setTimeout(r4, 200));
+  }
+  if (isPidAlive(existing.supervisorPid)) {
+    console.error("existing daemon refused to yield");
+    return { stopped: false, holder: existing, eperm };
+  }
+  await releaseLockfile({
+    supervisorPid: existing.supervisorPid,
+    supervisorProcStart: existing.supervisorProcStart
+  }).catch(() => {});
+  return { stopped: true, holder: existing, eperm };
+}
+async function displaceAny() {
+  return displaceHolder();
+}
+async function runSupervisor(args) {
+  const sub = args[0] ?? "start";
+  const identity8 = buildIdentity();
+  logEvent("tengu_bg_supervisor_start", {
+    sub,
+    coldStart: getDaemonColdStart()
+  });
+  const binaryErr = checkBinaryIdentity();
+  if (binaryErr) {
+    console.error(binaryErr);
+    logEvent("tengu_bg_supervisor_binary_bad", { reason: binaryErr });
+    process.exit(1);
+  }
+  const acquired = await acquireLockfile(identity8);
+  if (!acquired) {
+    if (await holderRefusesToYield()) {
+      console.error("existing daemon refused to yield");
+    }
+    process.exit(0);
+  }
+  const orphanCount = recoverOrphanedWorkers();
+  const config7 = readDaemonJson();
+  const warnings = validateDaemonJsonWorkers(config7);
+  for (const w3 of warnings) {
+    console.warn(w3);
+  }
+  let shutdownCause = null;
+  const handleSignal = (signal, cause) => {
+    if (shutdownCause)
+      return;
+    shutdownCause = cause;
+    shutdown(cause).catch(() => process.exit(0));
+  };
+  process.on("SIGTERM", () => handleSignal("SIGTERM", "sigterm"));
+  process.on("SIGINT", () => handleSignal("SIGINT", "sigint"));
+  running = true;
+  const startedAt = Date.now();
+  let lastActivityAt = startedAt;
+  let lastSweepAt = 0;
+  console.log(`[daemon] supervisor pid=${identity8.supervisorPid} start=${identity8.supervisorProcStart} coldStart=${getDaemonColdStart()}`);
+  while (running) {
+    const now2 = Date.now();
+    if (now2 - lastSweepAt >= SWEEP_INTERVAL_MS) {
+      lastSweepAt = now2;
+      const alive = await sweepWorkers(config7);
+      if (alive > 0) {
+        lastActivityAt = now2;
+      }
+      const idleMs = now2 - lastActivityAt;
+      if (alive === 0 && idleMs >= IDLE_SHUTDOWN_MS) {
+        const idleSec = Math.round(idleMs / 1000);
+        console.log(`idle ${idleSec}s with no workers`);
+        await shutdown("idle");
+        break;
+      }
+    }
+    await new Promise((r4) => setTimeout(r4, 500));
+  }
+  async function shutdown(cause) {
+    running = false;
+    const uptime = Date.now() - startedAt;
+    const uptimeS = Math.round(uptime / 1000);
+    console.log(`shutting down (cause=${cause}, uptime=${uptimeS}s)`);
+    logEvent("tengu_bg_supervisor_shutdown", {
+      cause,
+      uptimeS
+    });
+    await stopAllWorkers(3000);
+    await releaseLockfile({
+      supervisorPid: identity8.supervisorPid,
+      supervisorProcStart: identity8.supervisorProcStart
+    }).catch(() => {});
+    process.exit(0);
+  }
+}
+async function daemonInstall() {
+  const msg = installPersistentService();
+  console.log(msg);
+}
+async function daemonUninstall() {
+  await stopExistingSupervisor().catch(() => {});
+  const msg = uninstallPersistentService();
+  console.log(msg);
+}
+async function daemonRestart() {
+  await stopExistingSupervisor().catch(() => {});
+  console.log("supervisor restarting");
+  process.exit(0);
+}
+var IDLE_SHUTDOWN_MS = 60000, SWEEP_INTERVAL_MS = 5000, running = false;
+var init_supervisor = __esm(() => {
+  init_analytics();
+  init_config4();
+  init_lockfile();
+  init_process();
+  init_respawn();
+  init_workerRegistry();
+  init_install();
+});
+
+// src/cli/handlers/daemon.ts
+var exports_daemon = {};
+__export(exports_daemon, {
+  stopHandler: () => stopHandler,
+  logsHandler: () => logsHandler,
+  daemonSubcommand: () => daemonSubcommand,
+  attachHandler: () => attachHandler,
+  appendDaemonLog: () => appendDaemonLog
+});
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync27, writeFileSync as writeFileSync12, appendFileSync as appendFileSync4 } from "fs";
+import { join as join163 } from "path";
+import { execSync as execSync2 } from "child_process";
+function daemonLogPath() {
+  return join163(getClaudeConfigHomeDir(), "daemon.log");
+}
+function scheduledStatusPath() {
+  return join163(getClaudeConfigHomeDir(), "daemon.scheduled.status.json");
+}
+function printDaemonUsage() {
+  console.log(`Usage: claude daemon <subcommand>
+
+Subcommands:
+  start              Start the supervisor (default)
+  stop [--any]       Stop the supervisor (or displace any holder with --any)
+  restart            Restart the supervisor
+  status             Show supervisor + worker status
+  logs               Tail the daemon log
+  install            Install a persistent service (launchd/systemd)
+  uninstall          Remove the persistent service
+  scheduled add|rm   Manage scheduled tasks
+  remote-control     Configure the remote-control daemon worker
+  hub                Interactive daemon hub (TTY)
+  --help             Show this help
+`);
+}
+async function daemonSubcommand(sub, args) {
+  switch (sub) {
+    case "start":
+      await runSupervisor(["start", ...args]);
+      return;
+    case "stop": {
+      const any3 = args.includes("--any") || args.includes("-a");
+      if (any3) {
+        const res = await displaceAny();
+        if (res.displaced && res.holder) {
+          console.log(`Stopped background sessions held by pid=${res.holder.supervisorPid}.`);
+        } else if (!res.holder) {
+          console.log("No background sessions found.");
+        }
+      } else {
+        const res = await stopExistingSupervisor();
+        if (res.holder && !res.stopped) {
+          console.error("Run `claude daemon stop --any` to stop any background sessions and report on the holder");
+          process.exitCode = 1;
+        } else if (res.stopped && res.holder) {
+          console.log(`Stopped daemon (pid=${res.holder.supervisorPid}).`);
+        } else {
+          console.log("No daemon running.");
+        }
+      }
+      break;
+    }
+    case "restart":
+      await daemonRestart();
+      break;
+    case "status":
+      await statusHandler();
+      break;
+    case "logs":
+      await logsHandlerDaemon();
+      break;
+    case "install":
+      await daemonInstall();
+      break;
+    case "uninstall":
+      await daemonUninstall();
+      break;
+    case "scheduled":
+      await scheduledHandler(args);
+      break;
+    case "remote-control":
+      console.log("remote-control daemon worker: configured via the remoteControlAtStartup setting (B7 follow-up).");
+      logEvent("daemon_remote_control_cli", {});
+      break;
+    case "hub":
+      await renderDaemonHubStandalone();
+      break;
+    case "--help":
+    case "-h":
+    case "help":
+      printDaemonUsage();
+      break;
+    default:
+      console.error(`Unknown daemon subcommand: ${sub}`);
+      printDaemonUsage();
+      process.exitCode = 1;
+  }
+  process.exit(process.exitCode ?? 0);
+}
+async function statusHandler() {
+  const lf = await readLockfile();
+  const mtime = lockfileMtime();
+  const cold = getDaemonColdStart();
+  const workers = listWorkers();
+  console.log("Daemon status");
+  if (!lf) {
+    console.log("  supervisor: not running (no lockfile)");
+  } else {
+    const alive = isPidAlive(lf.supervisorPid);
+    console.log(`  supervisor: pid=${lf.supervisorPid} ${alive ? "running" : "dead"} start=${new Date(lf.supervisorProcStart).toISOString()}${mtime ? ` (lockfile mtime=${new Date(mtime).toISOString()})` : ""}`);
+  }
+  console.log(`  coldStart: ${cold}`);
+  console.log(`  daemon.json: ${getDaemonJsonPath()} (${existsSync19(getDaemonJsonPath()) ? "present" : "absent"})`);
+  console.log(`  workers: ${workers.length}`);
+  for (const w3 of workers) {
+    const alive = isPidAlive(w3.pid);
+    console.log(`    id=${w3.id} kind=${w3.kind} pid=${w3.pid} ${alive ? "alive" : "dead"} outcome=${w3.outcome} restart=${w3.restart} started=${new Date(w3.startedAt).toISOString()}`);
+  }
+}
+async function logsHandlerDaemon() {
+  const path28 = daemonLogPath();
+  if (!existsSync19(path28)) {
+    console.log(`No daemon log at ${path28}`);
+    return;
+  }
+  try {
+    const out = execSync2(`tail -n 200 ${JSON.stringify(path28)}`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    process.stdout.write(out);
+  } catch (err2) {
+    const raw = readFileSync27(path28, { encoding: "utf-8" });
+    const lines2 = raw.split(`
+`).slice(-200).join(`
+`);
+    process.stdout.write(lines2);
+  }
+}
+async function scheduledHandler(args) {
+  const op = args[0];
+  if (op !== "add" && op !== "remove" && op !== "rm" && op !== "list") {
+    console.error("Usage: claude daemon scheduled add|remove <task-id> [--schedule <cron>] [--prompt <text>]");
+    process.exitCode = 1;
+    return;
+  }
+  const config7 = readScheduledConfig();
+  if (op === "list") {
+    console.log("Scheduled tasks:");
+    for (const t4 of config7) {
+      console.log(`  ${t4.id}  ${t4.schedule}  ${t4.enabled ? "enabled" : "disabled"}  "${t4.prompt}"`);
+    }
+    return;
+  }
+  const taskId = args[1];
+  if (!taskId) {
+    console.error("task-id required");
+    process.exitCode = 1;
+    return;
+  }
+  if (op === "add") {
+    const schedule = flagValue(args, "--schedule") ?? "0 * * * *";
+    const prompt = flagValue(args, "--prompt") ?? "";
+    const task = { id: taskId, schedule, prompt, enabled: true };
+    const idx = config7.findIndex((t4) => t4.id === taskId);
+    if (idx >= 0)
+      config7[idx] = task;
+    else
+      config7.push(task);
+    writeScheduledConfig(config7);
+    logEvent("daemon_scheduled_add", { taskId });
+    console.log(`Scheduled task ${taskId} added.`);
+  } else {
+    const idx = config7.findIndex((t4) => t4.id === taskId);
+    if (idx < 0) {
+      console.error(`Scheduled task ${taskId} not found.`);
+      process.exitCode = 1;
+      return;
+    }
+    config7.splice(idx, 1);
+    writeScheduledConfig(config7);
+    logEvent("daemon_scheduled_remove", { taskId });
+    console.log(`Scheduled task ${taskId} removed.`);
+  }
+}
+function flagValue(args, flag) {
+  const i6 = args.indexOf(flag);
+  return i6 >= 0 && i6 + 1 < args.length ? args[i6 + 1] : undefined;
+}
+function readScheduledConfig() {
+  const path28 = getDaemonJsonPath();
+  if (!existsSync19(path28))
+    return [];
+  try {
+    const parsed = JSON.parse(readFileSync27(path28, { encoding: "utf-8" }));
+    return Array.isArray(parsed?.scheduled) ? parsed.scheduled : [];
+  } catch {
+    return [];
+  }
+}
+function writeScheduledConfig(tasks2) {
+  const path28 = getDaemonJsonPath();
+  let current = {};
+  if (existsSync19(path28)) {
+    try {
+      current = JSON.parse(readFileSync27(path28, { encoding: "utf-8" }));
+    } catch {
+      current = {};
+    }
+  }
+  current.scheduled = tasks2;
+  mkdirSync12(join163(path28, ".."), { recursive: true });
+  writeFileSync12(path28, JSON.stringify(current, null, 2), { encoding: "utf-8" });
+  writeFileSync12(scheduledStatusPath(), JSON.stringify({ tasks: tasks2, updatedAt: Date.now() }, null, 2), {
+    encoding: "utf-8"
+  });
+}
+async function renderDaemonHubStandalone() {
+  console.log("Claude daemon hub");
+  await statusHandler();
+  console.log(`
+(Press q to quit \u2014 interactive hub is a follow-up.)`);
+}
+async function stopHandler(id) {
+  const w3 = getWorker(id);
+  if (!w3) {
+    const pid = Number(id);
+    if (Number.isFinite(pid) && isPidAlive(pid)) {
+      try {
+        process.kill(pid, "SIGTERM");
+        console.log(`Sent SIGTERM to pid ${pid}.`);
+        process.exit(0);
+      } catch {}
+    }
+    console.error(`No background session "${id}" found.`);
+    process.exitCode = 1;
+    process.exit(process.exitCode ?? 1);
+    return;
+  }
+  await settleWorker(id, 3000);
+  console.log(`Stopped background session ${id} (pid=${w3.pid}).`);
+  process.exit(process.exitCode ?? 0);
+}
+async function attachHandler(id) {
+  const w3 = getWorker(id);
+  if (!w3) {
+    console.error(`No background session "${id}" found.`);
+    process.exitCode = 1;
+    process.exit(process.exitCode ?? 1);
+    return;
+  }
+  console.log(`Background session ${id}: kind=${w3.kind} pid=${w3.pid} outcome=${w3.outcome} started=${new Date(w3.startedAt).toISOString()}`);
+  console.log(`Log: ${daemonLogPath()}`);
+  console.log("(Interactive attach is a follow-up.)");
+  process.exit(process.exitCode ?? 0);
+}
+async function logsHandler(id) {
+  const path28 = daemonLogPath();
+  if (!existsSync19(path28)) {
+    console.log(`No daemon log at ${path28}`);
+    process.exit(0);
+  }
+  const w3 = getWorker(id);
+  const pid = w3?.pid ?? Number(id);
+  try {
+    const grep = Number.isFinite(pid) ? `grep -F "[pid=${pid}]" ${JSON.stringify(path28)} || true` : null;
+    const cmd = grep ? `${grep} | tail -n 200` : `tail -n 200 ${JSON.stringify(path28)}`;
+    const out = execSync2(cmd, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+    process.stdout.write(out);
+  } catch {
+    const raw = readFileSync27(path28, { encoding: "utf-8" });
+    process.stdout.write(raw.split(`
+`).slice(-200).join(`
+`));
+  }
+  process.exit(process.exitCode ?? 0);
+}
+function appendDaemonLog(line) {
+  try {
+    mkdirSync12(join163(daemonLogPath(), ".."), { recursive: true });
+    appendFileSync4(daemonLogPath(), line.endsWith(`
+`) ? line : line + `
+`, {
+      encoding: "utf-8"
+    });
+  } catch {}
+}
+var init_daemon = __esm(() => {
+  init_envUtils();
+  init_analytics();
+  init_supervisor();
+  init_lockfile();
+  init_workerRegistry();
+  init_process();
+});
+
 // src/daemon/main.ts
 var exports_main = {};
 __export(exports_main, {
+  runSupervisor: () => runSupervisor,
   daemonMain: () => daemonMain
 });
-var daemonMain = () => Promise.resolve();
-var init_main3 = () => {};
+var daemonMain = async (args) => {
+  const sub = args[0] ?? "start";
+  if (sub === "start" || sub === undefined) {
+    await runSupervisor(args.length > 0 ? args.slice(1) : ["start"]);
+    return;
+  }
+  const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+  await daemonSubcommand2(sub, args.slice(1));
+};
+var init_main3 = __esm(() => {
+  init_supervisor();
+  init_supervisor();
+});
 
 // src/cli/bg.ts
 var exports_bg = {};
 __export(exports_bg, {
   psHandler: () => psHandler,
-  logsHandler: () => logsHandler,
+  logsHandler: () => logsHandler2,
   killHandler: () => killHandler,
   handleBgFlag: () => handleBgFlag,
-  attachHandler: () => attachHandler
+  attachHandler: () => attachHandler2
 });
-var psHandler = async () => {}, logsHandler = async () => {}, attachHandler = async () => {}, killHandler = async () => {}, handleBgFlag = async () => {};
+var psHandler = async () => {}, logsHandler2 = async () => {}, attachHandler2 = async () => {}, killHandler = async () => {}, handleBgFlag = async () => {};
 var init_bg2 = () => {};
 
 // src/cli/handlers/templateJobs.ts
@@ -655431,11 +656563,11 @@ var require_extra_typings = __commonJS((exports, module) => {
 });
 
 // node_modules/.bun/@commander-js+extra-typings@14.0.0+1cee9bec6fc8d393/node_modules/@commander-js/extra-typings/esm.mjs
-var import__6, program, createCommand, createArgument, createOption, CommanderError, InvalidArgumentError, InvalidOptionArgumentError, Command, Argument, Option, Help;
+var import__6, program2, createCommand, createArgument, createOption, CommanderError, InvalidArgumentError, InvalidOptionArgumentError, Command, Argument, Option, Help;
 var init_esm26 = __esm(() => {
   import__6 = __toESM(require_extra_typings(), 1);
   ({
-    program,
+    program: program2,
     createCommand,
     createArgument,
     createOption,
@@ -656024,9 +657156,9 @@ __export(exports_upstreamproxy, {
   getUpstreamProxyEnv: () => getUpstreamProxyEnv,
   SESSION_TOKEN_PATH: () => SESSION_TOKEN_PATH
 });
-import { mkdir as mkdir55, readFile as readFile63, unlink as unlink26, writeFile as writeFile57 } from "fs/promises";
-import { homedir as homedir40 } from "os";
-import { join as join160 } from "path";
+import { mkdir as mkdir55, readFile as readFile64, unlink as unlink27, writeFile as writeFile58 } from "fs/promises";
+import { homedir as homedir41 } from "os";
+import { join as join164 } from "path";
 async function initUpstreamProxy(opts) {
   if (!isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) {
     return state3;
@@ -656047,7 +657179,7 @@ async function initUpstreamProxy(opts) {
   }
   setNonDumpable();
   const baseUrl = opts?.ccrBaseUrl ?? process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com";
-  const caBundlePath = opts?.caBundlePath ?? join160(homedir40(), ".ccr", "ca-bundle.crt");
+  const caBundlePath = opts?.caBundlePath ?? join164(homedir41(), ".ccr", "ca-bundle.crt");
   const caOk = await downloadCaBundle(baseUrl, opts?.systemCaPath ?? SYSTEM_CA_BUNDLE, caBundlePath);
   if (!caOk)
     return state3;
@@ -656057,7 +657189,7 @@ async function initUpstreamProxy(opts) {
     registerCleanup(async () => relay.stop());
     state3 = { enabled: true, port: relay.port, caBundlePath };
     logForDebugging(`[upstreamproxy] enabled on 127.0.0.1:${relay.port}`);
-    await unlink26(tokenPath).catch(() => {
+    await unlink27(tokenPath).catch(() => {
       logForDebugging("[upstreamproxy] token file unlink failed", {
         level: "warn"
       });
@@ -656105,7 +657237,7 @@ function resetUpstreamProxyForTests() {
 }
 async function readToken(path28) {
   try {
-    const raw = await readFile63(path28, "utf8");
+    const raw = await readFile64(path28, "utf8");
     return raw.trim() || null;
   } catch (err2) {
     if (isENOENT(err2))
@@ -656146,9 +657278,9 @@ async function downloadCaBundle(baseUrl, systemCaPath, outPath) {
       return false;
     }
     const ccrCa = await resp.text();
-    const systemCa = await readFile63(systemCaPath, "utf8").catch(() => "");
-    await mkdir55(join160(outPath, ".."), { recursive: true });
-    await writeFile57(outPath, systemCa + `
+    const systemCa = await readFile64(systemCaPath, "utf8").catch(() => "");
+    await mkdir55(join164(outPath, ".."), { recursive: true });
+    await writeFile58(outPath, systemCa + `
 ` + ccrCa, "utf8");
     return true;
   } catch (err2) {
@@ -656609,15 +657741,15 @@ function FpsMetricsProvider(t0) {
   const $4 = import_compiler_runtime258.c(3);
   const {
     getFpsMetrics,
-    children: children2
+    children: children3
   } = t0;
   let t1;
-  if ($4[0] !== children2 || $4[1] !== getFpsMetrics) {
+  if ($4[0] !== children3 || $4[1] !== getFpsMetrics) {
     t1 = /* @__PURE__ */ jsx_dev_runtime351.jsxDEV(FpsMetricsContext.Provider, {
       value: getFpsMetrics,
-      children: children2
+      children: children3
     }, undefined, false, undefined, this);
-    $4[0] = children2;
+    $4[0] = children3;
     $4[1] = getFpsMetrics;
     $4[2] = t1;
   } else {
@@ -656720,7 +657852,7 @@ function StatsProvider(t0) {
   const $4 = import_compiler_runtime259.c(7);
   const {
     store: externalStore,
-    children: children2
+    children: children3
   } = t0;
   let t1;
   if ($4[0] === Symbol.for("react.memo_cache_sentinel")) {
@@ -656759,12 +657891,12 @@ function StatsProvider(t0) {
   }
   import_react190.useEffect(t22, t32);
   let t4;
-  if ($4[4] !== children2 || $4[5] !== store) {
+  if ($4[4] !== children3 || $4[5] !== store) {
     t4 = /* @__PURE__ */ jsx_dev_runtime352.jsxDEV(StatsContext.Provider, {
       value: store,
-      children: children2
+      children: children3
     }, undefined, false, undefined, this);
-    $4[4] = children2;
+    $4[4] = children3;
     $4[5] = store;
     $4[6] = t4;
   } else {
@@ -656928,16 +658060,16 @@ function App2(t0) {
     getFpsMetrics,
     stats,
     initialState,
-    children: children2
+    children: children3
   } = t0;
   let t1;
-  if ($4[0] !== children2 || $4[1] !== initialState) {
+  if ($4[0] !== children3 || $4[1] !== initialState) {
     t1 = /* @__PURE__ */ jsx_dev_runtime353.jsxDEV(AppStateProvider, {
       initialState,
       onChangeAppState,
-      children: children2
+      children: children3
     }, undefined, false, undefined, this);
-    $4[0] = children2;
+    $4[0] = children3;
     $4[1] = initialState;
     $4[2] = t1;
   } else {
@@ -657208,7 +658340,7 @@ var init_IdleReturnDialog = __esm(() => {
 });
 
 // src/services/preventSleep.ts
-import { spawn as spawn14 } from "child_process";
+import { spawn as spawn15 } from "child_process";
 function startPreventSleep() {
   refCount++;
   if (refCount === 1) {
@@ -657266,7 +658398,7 @@ function spawnCaffeinate() {
     });
   }
   try {
-    caffeinateProcess = spawn14("caffeinate", ["-i", "-t", String(CAFFEINATE_TIMEOUT_SECONDS)], {
+    caffeinateProcess = spawn15("caffeinate", ["-i", "-t", String(CAFFEINATE_TIMEOUT_SECONDS)], {
       stdio: "ignore"
     });
     caffeinateProcess.unref();
@@ -661882,8 +663014,8 @@ __export(exports_inboundAttachments, {
   extractInboundAttachments: () => extractInboundAttachments
 });
 import { randomUUID as randomUUID46 } from "crypto";
-import { mkdir as mkdir56, writeFile as writeFile58 } from "fs/promises";
-import { basename as basename50, join as join161 } from "path";
+import { mkdir as mkdir56, writeFile as writeFile59 } from "fs/promises";
+import { basename as basename50, join as join165 } from "path";
 function debug4(msg) {
   logForDebugging(`[bridge:inbound-attach] ${msg}`);
 }
@@ -661899,7 +663031,7 @@ function sanitizeFileName(name3) {
   return base2 || "attachment";
 }
 function uploadsDir() {
-  return join161(getClaudeConfigHomeDir(), "uploads", getSessionId());
+  return join165(getClaudeConfigHomeDir(), "uploads", getSessionId());
 }
 async function resolveOne(att) {
   const token = getBridgeAccessToken();
@@ -661928,10 +663060,10 @@ async function resolveOne(att) {
   const safeName = sanitizeFileName(att.file_name);
   const prefix = (att.file_uuid.slice(0, 8) || randomUUID46().slice(0, 8)).replace(/[^a-zA-Z0-9_-]/g, "_");
   const dir = uploadsDir();
-  const outPath = join161(dir, `${prefix}-${safeName}`);
+  const outPath = join165(dir, `${prefix}-${safeName}`);
   try {
     await mkdir56(dir, { recursive: true });
-    await writeFile58(outPath, data);
+    await writeFile59(outPath, data);
   } catch (e4) {
     debug4(`write ${outPath} failed: ${e4}`);
     return;
@@ -668396,16 +669528,16 @@ function DiffBody(t0) {
 function DiffFrame(t0) {
   const $4 = import_compiler_runtime274.c(5);
   const {
-    children: children2,
+    children: children3,
     placeholder
   } = t0;
   let t1;
-  if ($4[0] !== children2 || $4[1] !== placeholder) {
+  if ($4[0] !== children3 || $4[1] !== placeholder) {
     t1 = placeholder ? /* @__PURE__ */ jsx_dev_runtime369.jsxDEV(ThemedText, {
       dimColor: true,
       children: "\u2026"
-    }, undefined, false, undefined, this) : children2;
-    $4[0] = children2;
+    }, undefined, false, undefined, this) : children3;
+    $4[0] = children3;
     $4[1] = placeholder;
     $4[2] = t1;
   } else {
@@ -668927,8 +670059,8 @@ var init_ShowInIDEPrompt = __esm(() => {
 });
 
 // src/components/permissions/FilePermissionDialog/permissionOptions.tsx
-import { homedir as homedir41 } from "os";
-import { basename as basename54, join as join162, sep as sep39 } from "path";
+import { homedir as homedir42 } from "os";
+import { basename as basename54, join as join166, sep as sep39 } from "path";
 function isInClaudeFolder(filePath) {
   const absolutePath = expandPath(filePath);
   const claudeFolderPath = expandPath(`${getOriginalCwd()}/.claude`);
@@ -668938,7 +670070,7 @@ function isInClaudeFolder(filePath) {
 }
 function isInGlobalClaudeFolder(filePath) {
   const absolutePath = expandPath(filePath);
-  const globalClaudeFolderPath = join162(homedir41(), ".claude");
+  const globalClaudeFolderPath = join166(homedir42(), ".claude");
   const normalizedAbsolutePath = normalizeCaseForComparison2(absolutePath);
   const normalizedGlobalClaudeFolderPath = normalizeCaseForComparison2(globalClaudeFolderPath);
   return normalizedAbsolutePath.startsWith(normalizedGlobalClaudeFolderPath + sep39.toLowerCase()) || normalizedAbsolutePath.startsWith(normalizedGlobalClaudeFolderPath + "/");
@@ -686092,8 +687224,8 @@ function findTextObject(text2, offset, objectType2, isInner) {
     return findWordObject(text2, offset, isInner, (ch2) => !isVimWhitespace(ch2));
   const pair = PAIRS[objectType2];
   if (pair) {
-    const [open15, close] = pair;
-    return open15 === close ? findQuoteObject(text2, offset, open15, isInner) : findBracketObject(text2, offset, open15, close, isInner);
+    const [open16, close] = pair;
+    return open16 === close ? findQuoteObject(text2, offset, open16, isInner) : findBracketObject(text2, offset, open16, close, isInner);
   }
   return null;
 }
@@ -686168,13 +687300,13 @@ function findQuoteObject(text2, offset, quote2, isInner) {
   }
   return null;
 }
-function findBracketObject(text2, offset, open15, close, isInner) {
+function findBracketObject(text2, offset, open16, close, isInner) {
   let depth = 0;
   let start = -1;
   for (let i6 = offset;i6 >= 0; i6--) {
     if (text2[i6] === close && i6 !== offset)
       depth++;
-    else if (text2[i6] === open15) {
+    else if (text2[i6] === open16) {
       if (depth === 0) {
         start = i6;
         break;
@@ -686187,7 +687319,7 @@ function findBracketObject(text2, offset, open15, close, isInner) {
   depth = 0;
   let end = -1;
   for (let i6 = start + 1;i6 < text2.length; i6++) {
-    if (text2[i6] === open15)
+    if (text2[i6] === open16)
       depth++;
     else if (text2[i6] === close) {
       if (depth === 0) {
@@ -688660,18 +689792,18 @@ function SummaryPill(t0) {
   const {
     selected,
     onClick,
-    children: children2
+    children: children3
   } = t0;
   const [hover, setHover] = import_react247.useState(false);
   const t1 = selected || hover;
   let t22;
-  if ($4[0] !== children2 || $4[1] !== t1) {
+  if ($4[0] !== children3 || $4[1] !== t1) {
     t22 = /* @__PURE__ */ jsx_dev_runtime418.jsxDEV(ThemedText, {
       color: "background",
       inverse: t1,
-      children: children2
+      children: children3
     }, undefined, false, undefined, this);
-    $4[0] = children2;
+    $4[0] = children3;
     $4[1] = t1;
     $4[2] = t22;
   } else {
@@ -694358,9 +695490,9 @@ function initSkillImprovement() {
 async function applySkillImprovement(skillName, updates) {
   if (!skillName)
     return;
-  const { join: join163 } = await import("path");
+  const { join: join167 } = await import("path");
   const fs19 = await import("fs/promises");
-  const filePath = join163(getCwd(), ".claude", "skills", skillName, "SKILL.md");
+  const filePath = join167(getCwd(), ".claude", "skills", skillName, "SKILL.md");
   let currentContent;
   try {
     currentContent = await fs19.readFile(filePath, "utf-8");
@@ -696492,13 +697624,13 @@ var require_polyfill = __commonJS((exports, module) => {
     readlink: readlink3,
     stat: stat50,
     symlink: symlink6,
-    unlink: unlink27,
+    unlink: unlink28,
     utimes: utimes3
   } = __require("fs/promises");
   var {
     dirname: dirname70,
     isAbsolute: isAbsolute29,
-    join: join163,
+    join: join167,
     parse: parse17,
     resolve: resolve51,
     sep: sep42,
@@ -696690,7 +697822,7 @@ var require_polyfill = __commonJS((exports, module) => {
   }
   async function mayCopyFile(srcStat, src, dest, opts) {
     if (opts.force) {
-      await unlink27(dest);
+      await unlink28(dest);
       return _copyFile(srcStat, src, dest, opts);
     } else if (opts.errorOnExist) {
       throw new ERR_FS_CP_EEXIST({
@@ -696747,8 +697879,8 @@ var require_polyfill = __commonJS((exports, module) => {
     const dir = await readdir36(src);
     for (let i6 = 0;i6 < dir.length; i6++) {
       const item = dir[i6];
-      const srcItem = join163(src, item);
-      const destItem = join163(dest, item);
+      const srcItem = join167(src, item);
+      const destItem = join167(dest, item);
       const { destStat } = await checkPaths(srcItem, destItem, opts);
       await startCopy(destStat, srcItem, destItem, opts);
     }
@@ -696793,7 +697925,7 @@ var require_polyfill = __commonJS((exports, module) => {
     return copyLink(resolvedSrc, dest);
   }
   async function copyLink(resolvedSrc, dest) {
-    await unlink27(dest);
+    await unlink28(dest);
     return symlink6(resolvedSrc, dest);
   }
   module.exports = cp;
@@ -696817,7 +697949,7 @@ var require_cp = __commonJS((exports, module) => {
 
 // node_modules/.bun/@npmcli+fs@5.0.0/node_modules/@npmcli/fs/lib/with-temp-dir.js
 var require_with_temp_dir = __commonJS((exports, module) => {
-  var { join: join163, sep: sep42 } = __require("path");
+  var { join: join167, sep: sep42 } = __require("path");
   var getOptions2 = require_get_options();
   var { mkdir: mkdir57, mkdtemp: mkdtemp4, rm: rm13 } = __require("fs/promises");
   var withTempDir = async (root3, fn, opts) => {
@@ -696825,7 +697957,7 @@ var require_with_temp_dir = __commonJS((exports, module) => {
       copy: ["tmpPrefix"]
     });
     await mkdir57(root3, { recursive: true });
-    const target = await mkdtemp4(join163(`${root3}${sep42}`, options.tmpPrefix || ""));
+    const target = await mkdtemp4(join167(`${root3}${sep42}`, options.tmpPrefix || ""));
     let err2;
     let result;
     try {
@@ -696847,13 +697979,13 @@ var require_with_temp_dir = __commonJS((exports, module) => {
 // node_modules/.bun/@npmcli+fs@5.0.0/node_modules/@npmcli/fs/lib/readdir-scoped.js
 var require_readdir_scoped = __commonJS((exports, module) => {
   var { readdir: readdir36 } = __require("fs/promises");
-  var { join: join163 } = __require("path");
+  var { join: join167 } = __require("path");
   var readdirScoped = async (dir) => {
     const results = [];
     for (const item of await readdir36(dir)) {
       if (item.startsWith("@")) {
-        for (const scopedItem of await readdir36(join163(dir, item))) {
-          results.push(join163(item, scopedItem));
+        for (const scopedItem of await readdir36(join167(dir, item))) {
+          results.push(join167(item, scopedItem));
         }
       } else {
         results.push(item);
@@ -696866,7 +697998,7 @@ var require_readdir_scoped = __commonJS((exports, module) => {
 
 // node_modules/.bun/@npmcli+fs@5.0.0/node_modules/@npmcli/fs/lib/move-file.js
 var require_move_file = __commonJS((exports, module) => {
-  var { dirname: dirname70, join: join163, resolve: resolve51, relative: relative37, isAbsolute: isAbsolute29 } = __require("path");
+  var { dirname: dirname70, join: join167, resolve: resolve51, relative: relative37, isAbsolute: isAbsolute29 } = __require("path");
   var fs19 = __require("fs/promises");
   var pathExists2 = async (path31) => {
     try {
@@ -696895,7 +698027,7 @@ var require_move_file = __commonJS((exports, module) => {
         const sourceStat = await fs19.lstat(source);
         if (sourceStat.isDirectory()) {
           const files3 = await fs19.readdir(source);
-          await Promise.all(files3.map((file2) => moveFile(join163(source, file2), join163(destination, file2), options, false, symlinks)));
+          await Promise.all(files3.map((file2) => moveFile(join167(source, file2), join167(destination, file2), options, false, symlinks)));
         } else if (sourceStat.isSymbolicLink()) {
           symlinks.push({ source, destination });
         } else {
@@ -697084,10 +698216,10 @@ var require_entry_index = __commonJS((exports, module) => {
   var {
     appendFile: appendFile8,
     mkdir: mkdir57,
-    readFile: readFile64,
+    readFile: readFile65,
     readdir: readdir36,
     rm: rm13,
-    writeFile: writeFile59
+    writeFile: writeFile60
   } = __require("fs/promises");
   var { Minipass } = require_commonjs();
   var path31 = __require("path");
@@ -697141,7 +698273,7 @@ var require_entry_index = __commonJS((exports, module) => {
       }
     };
     const write = async (tmp2) => {
-      await writeFile59(tmp2.target, newIndex, { flag: "wx" });
+      await writeFile60(tmp2.target, newIndex, { flag: "wx" });
       await mkdir57(path31.dirname(bucket), { recursive: true });
       await moveFile(tmp2.target, bucket);
       tmp2.moved = true;
@@ -697257,7 +698389,7 @@ ${hashEntry(stringified)}	${stringified}`);
   }
   exports.bucketEntries = bucketEntries;
   async function bucketEntries(bucket, filter2) {
-    const data = await readFile64(bucket, "utf8");
+    const data = await readFile65(bucket, "utf8");
     return _bucketEntries(data, filter2);
   }
   function _bucketEntries(data) {
@@ -702263,11 +703395,11 @@ var require_rm2 = __commonJS((exports, module) => {
 var require_verify2 = __commonJS((exports, module) => {
   var {
     mkdir: mkdir57,
-    readFile: readFile64,
+    readFile: readFile65,
     rm: rm13,
     stat: stat50,
     truncate: truncate3,
-    writeFile: writeFile59
+    writeFile: writeFile60
   } = __require("fs/promises");
   var contentPath = require_path2();
   var fsm = require_lib19();
@@ -702460,11 +703592,11 @@ var require_verify2 = __commonJS((exports, module) => {
   async function writeVerifile(cache9, opts) {
     const verifile = path31.join(cache9, "_lastverified");
     opts.log.silly("verify", "writing verifile to " + verifile);
-    return writeFile59(verifile, `${Date.now()}`);
+    return writeFile60(verifile, `${Date.now()}`);
   }
   module.exports.lastRun = lastRun;
   async function lastRun(cache9) {
-    const data = await readFile64(path31.join(cache9, "_lastverified"), { encoding: "utf8" });
+    const data = await readFile65(path31.join(cache9, "_lastverified"), { encoding: "utf8" });
     return new Date(+data);
   }
 });
@@ -702507,8 +703639,8 @@ var require_lib20 = __commonJS((exports, module) => {
 
 // src/utils/cleanup.ts
 import * as fs19 from "fs/promises";
-import { homedir as homedir42 } from "os";
-import { join as join163 } from "path";
+import { homedir as homedir43 } from "os";
+import { join as join167 } from "path";
 function getCutoffDate() {
   const settings = getSettings_DEPRECATED() || {};
   const cleanupPeriodDays = settings.cleanupPeriodDays ?? DEFAULT_CLEANUP_PERIOD_DAYS;
@@ -702533,7 +703665,7 @@ async function cleanupOldFilesInDirectory(dirPath, cutoffDate, isMessagePath) {
       try {
         const timestamp2 = convertFileNameToDate(file2.name);
         if (timestamp2 < cutoffDate) {
-          await getFsImplementation().unlink(join163(dirPath, file2.name));
+          await getFsImplementation().unlink(join167(dirPath, file2.name));
           if (isMessagePath) {
             result.messages++;
           } else {
@@ -702564,7 +703696,7 @@ async function cleanupOldMessageFiles() {
     } catch {
       return result;
     }
-    const mcpLogDirs = dirents.filter((dirent) => dirent.isDirectory() && dirent.name.startsWith("mcp-logs-")).map((dirent) => join163(baseCachePath, dirent.name));
+    const mcpLogDirs = dirents.filter((dirent) => dirent.isDirectory() && dirent.name.startsWith("mcp-logs-")).map((dirent) => join167(baseCachePath, dirent.name));
     for (const mcpLogDir of mcpLogDirs) {
       result = addCleanupResults(result, await cleanupOldFilesInDirectory(mcpLogDir, cutoffDate, true));
       await tryRmdir(mcpLogDir, fsImpl);
@@ -702603,7 +703735,7 @@ async function cleanupOldSessionFiles() {
   for (const projectDirent of projectDirents) {
     if (!projectDirent.isDirectory())
       continue;
-    const projectDir = join163(projectsDir, projectDirent.name);
+    const projectDir = join167(projectsDir, projectDirent.name);
     let entries;
     try {
       entries = await fsImpl.readdir(projectDir);
@@ -702617,15 +703749,15 @@ async function cleanupOldSessionFiles() {
           continue;
         }
         try {
-          if (await unlinkIfOld(join163(projectDir, entry.name), cutoffDate, fsImpl)) {
+          if (await unlinkIfOld(join167(projectDir, entry.name), cutoffDate, fsImpl)) {
             result.messages++;
           }
         } catch {
           result.errors++;
         }
       } else if (entry.isDirectory()) {
-        const sessionDir = join163(projectDir, entry.name);
-        const toolResultsDir = join163(sessionDir, TOOL_RESULTS_SUBDIR);
+        const sessionDir = join167(projectDir, entry.name);
+        const toolResultsDir = join167(sessionDir, TOOL_RESULTS_SUBDIR);
         let toolDirs;
         try {
           toolDirs = await fsImpl.readdir(toolResultsDir);
@@ -702636,14 +703768,14 @@ async function cleanupOldSessionFiles() {
         for (const toolEntry of toolDirs) {
           if (toolEntry.isFile()) {
             try {
-              if (await unlinkIfOld(join163(toolResultsDir, toolEntry.name), cutoffDate, fsImpl)) {
+              if (await unlinkIfOld(join167(toolResultsDir, toolEntry.name), cutoffDate, fsImpl)) {
                 result.messages++;
               }
             } catch {
               result.errors++;
             }
           } else if (toolEntry.isDirectory()) {
-            const toolDirPath = join163(toolResultsDir, toolEntry.name);
+            const toolDirPath = join167(toolResultsDir, toolEntry.name);
             let toolFiles;
             try {
               toolFiles = await fsImpl.readdir(toolDirPath);
@@ -702654,7 +703786,7 @@ async function cleanupOldSessionFiles() {
               if (!tf.isFile())
                 continue;
               try {
-                if (await unlinkIfOld(join163(toolDirPath, tf.name), cutoffDate, fsImpl)) {
+                if (await unlinkIfOld(join167(toolDirPath, tf.name), cutoffDate, fsImpl)) {
                   result.messages++;
                 }
               } catch {
@@ -702686,7 +703818,7 @@ async function cleanupSingleDirectory(dirPath, extension, removeEmptyDir = true)
     if (!dirent.isFile() || !dirent.name.endsWith(extension))
       continue;
     try {
-      if (await unlinkIfOld(join163(dirPath, dirent.name), cutoffDate, fsImpl)) {
+      if (await unlinkIfOld(join167(dirPath, dirent.name), cutoffDate, fsImpl)) {
         result.messages++;
       }
     } catch {
@@ -702699,7 +703831,7 @@ async function cleanupSingleDirectory(dirPath, extension, removeEmptyDir = true)
   return result;
 }
 function cleanupOldPlanFiles() {
-  const plansDir = join163(getClaudeConfigHomeDir(), "plans");
+  const plansDir = join167(getClaudeConfigHomeDir(), "plans");
   return cleanupSingleDirectory(plansDir, ".md");
 }
 async function cleanupOldFileHistoryBackups() {
@@ -702708,14 +703840,14 @@ async function cleanupOldFileHistoryBackups() {
   const fsImpl = getFsImplementation();
   try {
     const configDir = getClaudeConfigHomeDir();
-    const fileHistoryStorageDir = join163(configDir, "file-history");
+    const fileHistoryStorageDir = join167(configDir, "file-history");
     let dirents;
     try {
       dirents = await fsImpl.readdir(fileHistoryStorageDir);
     } catch {
       return result;
     }
-    const fileHistorySessionsDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join163(fileHistoryStorageDir, dirent.name));
+    const fileHistorySessionsDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join167(fileHistoryStorageDir, dirent.name));
     await Promise.all(fileHistorySessionsDirs.map(async (fileHistorySessionDir) => {
       try {
         const stats = await fsImpl.stat(fileHistorySessionDir);
@@ -702742,14 +703874,14 @@ async function cleanupOldSessionEnvDirs() {
   const fsImpl = getFsImplementation();
   try {
     const configDir = getClaudeConfigHomeDir();
-    const sessionEnvBaseDir = join163(configDir, "session-env");
+    const sessionEnvBaseDir = join167(configDir, "session-env");
     let dirents;
     try {
       dirents = await fsImpl.readdir(sessionEnvBaseDir);
     } catch {
       return result;
     }
-    const sessionEnvDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join163(sessionEnvBaseDir, dirent.name));
+    const sessionEnvDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join167(sessionEnvBaseDir, dirent.name));
     for (const sessionEnvDir of sessionEnvDirs) {
       try {
         const stats = await fsImpl.stat(sessionEnvDir);
@@ -702771,7 +703903,7 @@ async function cleanupOldDebugLogs() {
   const cutoffDate = getCutoffDate();
   const result = { messages: 0, errors: 0 };
   const fsImpl = getFsImplementation();
-  const debugDir = join163(getClaudeConfigHomeDir(), "debug");
+  const debugDir = join167(getClaudeConfigHomeDir(), "debug");
   let dirents;
   try {
     dirents = await fsImpl.readdir(debugDir);
@@ -702783,7 +703915,7 @@ async function cleanupOldDebugLogs() {
       continue;
     }
     try {
-      if (await unlinkIfOld(join163(debugDir, dirent.name), cutoffDate, fsImpl)) {
+      if (await unlinkIfOld(join167(debugDir, dirent.name), cutoffDate, fsImpl)) {
         result.messages++;
       }
     } catch {
@@ -702797,12 +703929,12 @@ async function cleanupOldMiscConfigDirs() {
   const configDir = getClaudeConfigHomeDir();
   let result = { messages: 0, errors: 0 };
   for (const subdir of ["tasks", "shell-snapshots", "backups"]) {
-    result = addCleanupResults(result, await cleanupOldFilesInDirectory(join163(configDir, subdir), cutoffDate, false));
+    result = addCleanupResults(result, await cleanupOldFilesInDirectory(join167(configDir, subdir), cutoffDate, false));
   }
   return result;
 }
 async function cleanupNpmCacheForAnthropicPackages() {
-  const markerPath = join163(getClaudeConfigHomeDir(), ".npm-cache-cleanup");
+  const markerPath = join167(getClaudeConfigHomeDir(), ".npm-cache-cleanup");
   try {
     const stat51 = await fs19.stat(markerPath);
     if (Date.now() - stat51.mtimeMs < ONE_DAY_MS) {
@@ -702817,7 +703949,7 @@ async function cleanupNpmCacheForAnthropicPackages() {
     return;
   }
   logForDebugging("npm cache cleanup: starting");
-  const npmCachePath = join163(homedir42(), ".npm", "_cacache");
+  const npmCachePath = join167(homedir43(), ".npm", "_cacache");
   const NPM_CACHE_RETENTION_COUNT = 5;
   const startTime = Date.now();
   try {
@@ -702872,7 +704004,7 @@ async function cleanupNpmCacheForAnthropicPackages() {
   }
 }
 async function cleanupOldVersionsThrottled() {
-  const markerPath = join163(getClaudeConfigHomeDir(), ".version-cleanup");
+  const markerPath = join167(getClaudeConfigHomeDir(), ".version-cleanup");
   try {
     const stat51 = await fs19.stat(markerPath);
     if (Date.now() - stat51.mtimeMs < ONE_DAY_MS) {
@@ -703407,7 +704539,7 @@ var init_useApiKeyVerification = __esm(() => {
 });
 
 // src/utils/terminalPanel.ts
-import { spawn as spawn15, spawnSync as spawnSync9 } from "child_process";
+import { spawn as spawn16, spawnSync as spawnSync10 } from "child_process";
 function getTerminalPanelSocket() {
   const sessionId = getSessionId();
   return `claude-panel-${sessionId.slice(0, 8)}`;
@@ -703428,7 +704560,7 @@ class TerminalPanel {
   checkTmux() {
     if (this.hasTmux !== undefined)
       return this.hasTmux;
-    const result = spawnSync9("tmux", ["-V"], { encoding: "utf-8" });
+    const result = spawnSync10("tmux", ["-V"], { encoding: "utf-8" });
     this.hasTmux = result.status === 0;
     if (!this.hasTmux) {
       logForDebugging("Terminal panel: tmux not found, falling back to non-persistent shell");
@@ -703436,14 +704568,14 @@ class TerminalPanel {
     return this.hasTmux;
   }
   hasSession() {
-    const result = spawnSync9("tmux", ["-L", getTerminalPanelSocket(), "has-session", "-t", TMUX_SESSION], { encoding: "utf-8" });
+    const result = spawnSync10("tmux", ["-L", getTerminalPanelSocket(), "has-session", "-t", TMUX_SESSION], { encoding: "utf-8" });
     return result.status === 0;
   }
   createSession() {
     const shell = process.env.SHELL || "/bin/bash";
     const cwd2 = pwd();
     const socket = getTerminalPanelSocket();
-    const result = spawnSync9("tmux", [
+    const result = spawnSync10("tmux", [
       "-L",
       socket,
       "new-session",
@@ -703459,7 +704591,7 @@ class TerminalPanel {
       logForDebugging(`Terminal panel: failed to create tmux session: ${result.stderr}`);
       return false;
     }
-    spawnSync9("tmux", [
+    spawnSync10("tmux", [
       "-L",
       socket,
       "bind-key",
@@ -703490,7 +704622,7 @@ class TerminalPanel {
     if (!this.cleanupRegistered) {
       this.cleanupRegistered = true;
       registerCleanup(async () => {
-        spawn15("tmux", ["-L", socket, "kill-server"], {
+        spawn16("tmux", ["-L", socket, "kill-server"], {
           detached: true,
           stdio: "ignore"
         }).on("error", () => {}).unref();
@@ -703499,7 +704631,7 @@ class TerminalPanel {
     return true;
   }
   attachSession() {
-    spawnSync9("tmux", ["-L", getTerminalPanelSocket(), "attach-session", "-t", TMUX_SESSION], { stdio: "inherit" });
+    spawnSync10("tmux", ["-L", getTerminalPanelSocket(), "attach-session", "-t", TMUX_SESSION], { stdio: "inherit" });
   }
   showShell() {
     const inkInstance = instances_default.get(process.stdout);
@@ -703526,7 +704658,7 @@ class TerminalPanel {
   runShellDirect() {
     const shell = process.env.SHELL || "/bin/bash";
     const cwd2 = pwd();
-    spawnSync9(shell, ["-i", "-l"], {
+    spawnSync10(shell, ["-i", "-l"], {
       stdio: "inherit",
       cwd: cwd2,
       env: process.env
@@ -703873,12 +705005,12 @@ function CancelRequestHandler(props) {
   });
   const killAllAgentsAndNotify = import_react268.useCallback(() => {
     const tasks2 = store.getState().tasks;
-    const running = Object.entries(tasks2).filter(([, t4]) => t4.type === "local_agent" && t4.status === "running");
-    if (running.length === 0)
+    const running2 = Object.entries(tasks2).filter(([, t4]) => t4.type === "local_agent" && t4.status === "running");
+    if (running2.length === 0)
       return false;
     killAllRunningAgentTasks(tasks2, setAppState);
     const descriptions = [];
-    for (const [taskId, task] of running) {
+    for (const [taskId, task] of running2) {
       markAgentsNotified(taskId, setAppState);
       descriptions.push(task.description);
       emitTaskTerminatedSdk(taskId, "stopped", {
@@ -706915,7 +708047,7 @@ __export(exports_asciicast, {
   _resetRecordingStateForTesting: () => _resetRecordingStateForTesting
 });
 import { appendFile as appendFile8, rename as rename10 } from "fs/promises";
-import { basename as basename63, dirname as dirname71, join as join166 } from "path";
+import { basename as basename63, dirname as dirname71, join as join170 } from "path";
 function getRecordFilePath() {
   if (recordingState.filePath !== null) {
     return recordingState.filePath;
@@ -706926,10 +708058,10 @@ function getRecordFilePath() {
   if (!isEnvTruthy(process.env.CLAUDE_CODE_TERMINAL_RECORDING)) {
     return null;
   }
-  const projectsDir = join166(getClaudeConfigHomeDir(), "projects");
-  const projectDir = join166(projectsDir, sanitizePath2(getOriginalCwd()));
+  const projectsDir = join170(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join170(projectsDir, sanitizePath2(getOriginalCwd()));
   recordingState.timestamp = Date.now();
-  recordingState.filePath = join166(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  recordingState.filePath = join170(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
   return recordingState.filePath;
 }
 function _resetRecordingStateForTesting() {
@@ -706938,13 +708070,13 @@ function _resetRecordingStateForTesting() {
 }
 function getSessionRecordingPaths() {
   const sessionId = getSessionId();
-  const projectsDir = join166(getClaudeConfigHomeDir(), "projects");
-  const projectDir = join166(projectsDir, sanitizePath2(getOriginalCwd()));
+  const projectsDir = join170(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join170(projectsDir, sanitizePath2(getOriginalCwd()));
   try {
     const entries = getFsImplementation().readdirSync(projectDir);
     const names = typeof entries[0] === "string" ? entries : entries.map((e4) => e4.name);
     const files3 = names.filter((f4) => f4.startsWith(sessionId) && f4.endsWith(".cast")).sort();
-    return files3.map((f4) => join166(projectDir, f4));
+    return files3.map((f4) => join170(projectDir, f4));
   } catch {
     return [];
   }
@@ -706954,9 +708086,9 @@ async function renameRecordingForSession() {
   if (!oldPath || recordingState.timestamp === 0) {
     return;
   }
-  const projectsDir = join166(getClaudeConfigHomeDir(), "projects");
-  const projectDir = join166(projectsDir, sanitizePath2(getOriginalCwd()));
-  const newPath = join166(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  const projectsDir = join170(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join170(projectsDir, sanitizePath2(getOriginalCwd()));
+  const newPath = join170(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
   if (oldPath === newPath) {
     return;
   }
@@ -708537,7 +709669,7 @@ var init_Feedback = __esm(() => {
 });
 
 // src/components/FeedbackSurvey/submitTranscriptShare.ts
-import { readFile as readFile64, stat as stat51 } from "fs/promises";
+import { readFile as readFile65, stat as stat51 } from "fs/promises";
 async function submitTranscriptShare(messages, trigger, appearanceId) {
   try {
     logForDebugging("Collecting transcript for sharing", { level: "info" });
@@ -708549,7 +709681,7 @@ async function submitTranscriptShare(messages, trigger, appearanceId) {
       const transcriptPath = getTranscriptPath();
       const { size } = await stat51(transcriptPath);
       if (size <= MAX_TRANSCRIPT_READ_BYTES) {
-        rawTranscriptJsonl = await readFile64(transcriptPath, "utf-8");
+        rawTranscriptJsonl = await readFile65(transcriptPath, "utf-8");
       } else {
         logForDebugging(`Skipping raw transcript read: file too large (${size} bytes)`, { level: "warn" });
       }
@@ -708630,7 +709762,7 @@ function useSurveyState({
     setState("submitted");
     setTimeout(setState, hideThanksAfterMs, "closed");
   }, [hideThanksAfterMs]);
-  const open15 = import_react288.useCallback(() => {
+  const open16 = import_react288.useCallback(() => {
     if (state4 !== "closed") {
       return;
     }
@@ -708681,7 +709813,7 @@ function useSurveyState({
   return {
     state: state4,
     lastResponse,
-    open: open15,
+    open: open16,
     handleSelect,
     handleTranscriptSelect
   };
@@ -708817,7 +709949,7 @@ function useFeedbackSurvey(messages, isLoading, submitCount, surveyType = "sessi
   const {
     state: state4,
     lastResponse,
-    open: open15,
+    open: open16,
     handleSelect,
     handleTranscriptSelect
   } = useSurveyState({
@@ -708898,9 +710030,9 @@ function useFeedbackSurvey(messages, isLoading, submitCount, surveyType = "sessi
   }, [state4, isLoading, hasActivePrompt, isModelAllowed2, feedbackSurvey.timeLastShown, feedbackSurvey.submitCountAtLastAppearance, submitCount, config7.minTimeBetweenFeedbackMs, config7.minTimeBetweenGlobalFeedbackMs, config7.minUserTurnsBetweenFeedback, config7.minTimeBeforeFeedbackMs, config7.minUserTurnsBeforeFeedback, config7.probability, settingsRate]);
   import_react289.useEffect(() => {
     if (shouldOpen) {
-      open15();
+      open16();
     }
-  }, [shouldOpen, open15]);
+  }, [shouldOpen, open16]);
   return {
     state: state4,
     lastResponse,
@@ -709044,7 +710176,7 @@ function useMemorySurvey(messages, isLoading, hasActivePrompt = false, {
   const {
     state: state4,
     lastResponse,
-    open: open15,
+    open: open16,
     handleSelect,
     handleTranscriptSelect
   } = useSurveyState({
@@ -709097,9 +710229,9 @@ function useMemorySurvey(messages, isLoading, hasActivePrompt = false, {
       return;
     }
     if (Math.random() < SURVEY_PROBABILITY) {
-      open15();
+      open16();
     }
-  }, [enabled2, state4, isLoading, hasActivePrompt, lastAssistant, messages, open15]);
+  }, [enabled2, state4, isLoading, hasActivePrompt, lastAssistant, messages, open16]);
   return {
     state: state4,
     lastResponse,
@@ -709181,7 +710313,7 @@ function usePostCompactSurvey(messages, isLoading, t0, t1) {
   const {
     state: state4,
     lastResponse,
-    open: open15,
+    open: open16,
     handleSelect
   } = useSurveyState(t5);
   let t6;
@@ -709213,7 +710345,7 @@ function usePostCompactSurvey(messages, isLoading, t0, t1) {
   const currentCompactBoundaries = t8;
   let t10;
   let t9;
-  if ($4[9] !== currentCompactBoundaries || $4[10] !== enabled2 || $4[11] !== gateEnabled || $4[12] !== hasActivePrompt || $4[13] !== isLoading || $4[14] !== messages || $4[15] !== open15 || $4[16] !== state4) {
+  if ($4[9] !== currentCompactBoundaries || $4[10] !== enabled2 || $4[11] !== gateEnabled || $4[12] !== hasActivePrompt || $4[13] !== isLoading || $4[14] !== messages || $4[15] !== open16 || $4[16] !== state4) {
     t9 = () => {
       if (!enabled2) {
         return;
@@ -709237,7 +710369,7 @@ function usePostCompactSurvey(messages, isLoading, t0, t1) {
         if (hasMessageAfterBoundary(messages, pendingCompactBoundaryUuid.current)) {
           pendingCompactBoundaryUuid.current = null;
           if (Math.random() < SURVEY_PROBABILITY2) {
-            open15();
+            open16();
           }
           return;
         }
@@ -709248,14 +710380,14 @@ function usePostCompactSurvey(messages, isLoading, t0, t1) {
         pendingCompactBoundaryUuid.current = newBoundaries[newBoundaries.length - 1];
       }
     };
-    t10 = [enabled2, currentCompactBoundaries, state4, isLoading, hasActivePrompt, gateEnabled, messages, open15];
+    t10 = [enabled2, currentCompactBoundaries, state4, isLoading, hasActivePrompt, gateEnabled, messages, open16];
     $4[9] = currentCompactBoundaries;
     $4[10] = enabled2;
     $4[11] = gateEnabled;
     $4[12] = hasActivePrompt;
     $4[13] = isLoading;
     $4[14] = messages;
-    $4[15] = open15;
+    $4[15] = open16;
     $4[16] = state4;
     $4[17] = t10;
     $4[18] = t9;
@@ -709917,7 +711049,7 @@ var init_useChromeExtensionNotification = __esm(() => {
 });
 
 // src/utils/plugins/officialMarketplaceStartupCheck.ts
-import { join as join167 } from "path";
+import { join as join171 } from "path";
 function isOfficialMarketplaceAutoInstallDisabled() {
   return isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_OFFICIAL_MARKETPLACE_AUTOINSTALL);
 }
@@ -710000,7 +711132,7 @@ async function checkAndInstallOfficialMarketplace() {
       return { installed: false, skipped: true, reason: "policy_blocked" };
     }
     const cacheDir = getMarketplacesCacheDir();
-    const installLocation = join167(cacheDir, OFFICIAL_MARKETPLACE_NAME);
+    const installLocation = join171(cacheDir, OFFICIAL_MARKETPLACE_NAME);
     const gcsSha = await fetchOfficialMarketplaceFromGcs(installLocation, cacheDir);
     if (gcsSha !== null) {
       const known = await loadKnownMarketplacesConfig();
@@ -713030,7 +714162,7 @@ var init_usePluginRecommendationBase = __esm(() => {
 });
 
 // src/hooks/useLspPluginRecommendation.tsx
-import { extname as extname18, join as join168 } from "path";
+import { extname as extname18, join as join172 } from "path";
 function useLspPluginRecommendation() {
   const $4 = import_compiler_runtime335.c(12);
   const trackedFiles = useAppState(_temp291);
@@ -713115,7 +714247,7 @@ function useLspPluginRecommendation() {
           case "yes": {
             installPluginAndNotify(pluginId, pluginName, "lsp-plugin", addNotification, async (pluginData) => {
               logForDebugging(`[useLspPluginRecommendation] Installing plugin: ${pluginId}`);
-              const localSourcePath = typeof pluginData.entry.source === "string" ? join168(pluginData.marketplaceInstallLocation, pluginData.entry.source) : undefined;
+              const localSourcePath = typeof pluginData.entry.source === "string" ? join172(pluginData.marketplaceInstallLocation, pluginData.entry.source) : undefined;
               await cacheAndRegisterPlugin(pluginId, pluginData.entry, "user", undefined, localSourcePath);
               const settings = getSettingsForSource("userSettings");
               updateSettingsForSource("userSettings", {
@@ -715267,7 +716399,7 @@ var init_DevBar = __esm(() => {
 function AlternateScreen(t0) {
   const $4 = import_compiler_runtime346.c(7);
   const {
-    children: children2,
+    children: children3,
     mouseTracking: t1
   } = t0;
   const mouseTracking = t1 === undefined ? true : t1;
@@ -715301,15 +716433,15 @@ function AlternateScreen(t0) {
   import_react311.useInsertionEffect(t22, t32);
   const t4 = size?.rows ?? 24;
   let t5;
-  if ($4[4] !== children2 || $4[5] !== t4) {
+  if ($4[4] !== children3 || $4[5] !== t4) {
     t5 = /* @__PURE__ */ jsx_dev_runtime456.jsxDEV(Box_default, {
       flexDirection: "column",
       height: t4,
       width: "100%",
       flexShrink: 0,
-      children: children2
+      children: children3
     }, undefined, false, undefined, this);
-    $4[4] = children2;
+    $4[4] = children3;
     $4[5] = t4;
     $4[6] = t5;
   } else {
@@ -715962,20 +717094,20 @@ var init_ScrollKeybindingHandler = __esm(() => {
 // src/components/FleetView/rowHelpers.ts
 function buildFleetRows(tasks2, now2 = Date.now(), foldWindowMs = 60000) {
   const all4 = Object.values(tasks2);
-  const running = [];
+  const running2 = [];
   const done = [];
   for (const t4 of all4) {
     if (isBackgroundTask(t4)) {
-      running.push(t4);
+      running2.push(t4);
       continue;
     }
     if (isTerminalTaskStatus(t4.status) && t4.endTime && now2 - t4.endTime <= foldWindowMs) {
       done.push(t4);
     }
   }
-  running.sort((a5, b5) => a5.startTime - b5.startTime);
+  running2.sort((a5, b5) => a5.startTime - b5.startTime);
   done.sort((a5, b5) => (b5.endTime ?? 0) - (a5.endTime ?? 0));
-  return { running, done };
+  return { running: running2, done };
 }
 function jobLabel(task) {
   switch (task.type) {
@@ -716080,11 +717212,11 @@ function fleetVerticalBudget(terminalRows) {
   const half = Math.floor(terminalRows / 2);
   return Math.max(4, Math.min(12, half));
 }
-function fleetTitle(running, done) {
-  if (running > 0 && done > 0)
-    return `Agents \xB7 ${running} live \xB7 ${done} done`;
-  if (running > 0)
-    return `Agents \xB7 ${running} live`;
+function fleetTitle(running2, done) {
+  if (running2 > 0 && done > 0)
+    return `Agents \xB7 ${running2} live \xB7 ${done} done`;
+  if (running2 > 0)
+    return `Agents \xB7 ${running2} live`;
   if (done > 0)
     return `Agents \xB7 ${done} done`;
   return "Agents";
@@ -716396,17 +717528,17 @@ var init_SessionPreview2 = __esm(() => {
 // src/components/FleetView/FleetView.tsx
 function FleetView(props) {
   const { rows, focused, selectedIndex, showPreview, now: now2, terminalRows } = props;
-  const { running, done } = rows;
+  const { running: running2, done } = rows;
   const budget = fleetVerticalBudget(terminalRows);
-  if (running.length === 0 && done.length === 0) {
+  if (running2.length === 0 && done.length === 0) {
     return /* @__PURE__ */ jsx_dev_runtime458.jsxDEV(FleetEmptyState, {
       focused
     }, undefined, false, undefined, this);
   }
-  const title = fleetTitle(running.length, done.length);
+  const title = fleetTitle(running2.length, done.length);
   const maxRows = Math.max(1, budget - 2);
-  const visibleRunning = running.slice(0, maxRows);
-  const hidden2 = running.length - visibleRunning.length;
+  const visibleRunning = running2.slice(0, maxRows);
+  const hidden2 = running2.length - visibleRunning.length;
   return /* @__PURE__ */ jsx_dev_runtime458.jsxDEV(ThemedBox_default, {
     flexDirection: "column",
     paddingLeft: 1,
@@ -716457,8 +717589,8 @@ function FleetView(props) {
           ]
         }, undefined, true, undefined, this)
       }, undefined, false, undefined, this),
-      showPreview && focused && running[selectedIndex] && /* @__PURE__ */ jsx_dev_runtime458.jsxDEV(SessionPreview2, {
-        task: running[selectedIndex],
+      showPreview && focused && running2[selectedIndex] && /* @__PURE__ */ jsx_dev_runtime458.jsxDEV(SessionPreview2, {
+        task: running2[selectedIndex],
         now: now2
       }, undefined, false, undefined, this)
     ]
@@ -717123,15 +718255,15 @@ var init_cronJitterConfig = __esm(() => {
 });
 
 // src/utils/cronTasksLock.ts
-import { mkdir as mkdir57, readFile as readFile65, unlink as unlink27, writeFile as writeFile60 } from "fs/promises";
-import { dirname as dirname73, join as join169 } from "path";
+import { mkdir as mkdir57, readFile as readFile66, unlink as unlink28, writeFile as writeFile61 } from "fs/promises";
+import { dirname as dirname73, join as join173 } from "path";
 function getLockPath2(dir) {
-  return join169(dir ?? getProjectRoot(), LOCK_FILE_REL);
+  return join173(dir ?? getProjectRoot(), LOCK_FILE_REL);
 }
 async function readLock2(dir) {
   let raw;
   try {
-    raw = await readFile65(getLockPath2(dir), "utf8");
+    raw = await readFile66(getLockPath2(dir), "utf8");
   } catch {
     return;
   }
@@ -717142,7 +718274,7 @@ async function tryCreateExclusive2(lock2, dir) {
   const path32 = getLockPath2(dir);
   const body = jsonStringify(lock2);
   try {
-    await writeFile60(path32, body, { flag: "wx" });
+    await writeFile61(path32, body, { flag: "wx" });
     return true;
   } catch (e4) {
     const code = getErrnoCode(e4);
@@ -717151,7 +718283,7 @@ async function tryCreateExclusive2(lock2, dir) {
     if (code === "ENOENT") {
       await mkdir57(dirname73(path32), { recursive: true });
       try {
-        await writeFile60(path32, body, { flag: "wx" });
+        await writeFile61(path32, body, { flag: "wx" });
         return true;
       } catch (retryErr) {
         if (getErrnoCode(retryErr) === "EEXIST")
@@ -717185,7 +718317,7 @@ async function tryAcquireSchedulerLock(opts) {
   const existing = await readLock2(dir);
   if (existing?.sessionId === sessionId) {
     if (existing.pid !== process.pid) {
-      await writeFile60(getLockPath2(dir), jsonStringify(lock2));
+      await writeFile61(getLockPath2(dir), jsonStringify(lock2));
       registerLockCleanup2(opts);
     }
     return true;
@@ -717200,7 +718332,7 @@ async function tryAcquireSchedulerLock(opts) {
   if (existing) {
     logForDebugging(`[ScheduledTasks] recovering stale scheduler lock from PID ${existing.pid}`);
   }
-  await unlink27(getLockPath2(dir)).catch(() => {});
+  await unlink28(getLockPath2(dir)).catch(() => {});
   if (await tryCreateExclusive2(lock2, dir)) {
     lastBlockedBy = undefined;
     registerLockCleanup2(opts);
@@ -717218,7 +718350,7 @@ async function releaseSchedulerLock(opts) {
   if (!existing || existing.sessionId !== sessionId)
     return;
   try {
-    await unlink27(getLockPath2(dir));
+    await unlink28(getLockPath2(dir));
     logForDebugging("[ScheduledTasks] released scheduler lock");
   } catch {}
 }
@@ -717232,7 +718364,7 @@ var init_cronTasksLock = __esm(() => {
   init_genericProcessUtils();
   init_json();
   init_slowOperations();
-  LOCK_FILE_REL = join169(".claude", "scheduled_tasks.lock");
+  LOCK_FILE_REL = join173(".claude", "scheduled_tasks.lock");
   schedulerLockSchema = lazySchema(() => exports_external.object({
     sessionId: exports_external.string(),
     pid: exports_external.number(),
@@ -717610,10 +718742,10 @@ var exports_REPL = {};
 __export(exports_REPL, {
   REPL: () => REPL
 });
-import { spawnSync as spawnSync10 } from "child_process";
-import { dirname as dirname74, join as join170 } from "path";
+import { spawnSync as spawnSync11 } from "child_process";
+import { dirname as dirname74, join as join174 } from "path";
 import { tmpdir as tmpdir16 } from "os";
-import { writeFile as writeFile61 } from "fs/promises";
+import { writeFile as writeFile62 } from "fs/promises";
 import { randomUUID as randomUUID62 } from "crypto";
 function TranscriptModeFooter(t0) {
   const $4 = import_compiler_runtime347.c(9);
@@ -719872,7 +721004,7 @@ Error: sandbox required but unavailable: ${reason}
   const handleExit = import_react316.useCallback(async () => {
     setIsExiting(true);
     if (feature("BG_SESSIONS") && isBgSession()) {
-      spawnSync10("tmux", ["detach-client"], {
+      spawnSync11("tmux", ["detach-client"], {
         stdio: "ignore"
       });
       setIsExiting(false);
@@ -720369,8 +721501,8 @@ Note: ctrl + z now suspends Claude Code, ctrl + _ undoes input.
           const w3 = Math.max(80, (process.stdout.columns ?? 80) - 6);
           const raw = await renderMessagesToPlainText(deferredMessages, tools, w3);
           const text2 = raw.replace(/[ \t]+$/gm, "");
-          const path32 = join170(tmpdir16(), `cc-transcript-${Date.now()}.txt`);
-          await writeFile61(path32, text2);
+          const path32 = join174(tmpdir16(), `cc-transcript-${Date.now()}.txt`);
+          await writeFile62(path32, text2);
           const opened = openFileInExternalEditor(path32);
           setStatus(opened ? `opening ${path32}` : `wrote ${path32} \xB7 no $VISUAL/$EDITOR set`);
         } catch (e4) {
@@ -723503,7 +724635,7 @@ var init_WelcomeV2 = __esm(() => {
 function OrderedListItem(t0) {
   const $4 = import_compiler_runtime354.c(7);
   const {
-    children: children2
+    children: children3
   } = t0;
   const {
     marker
@@ -723520,12 +724652,12 @@ function OrderedListItem(t0) {
     t1 = $4[1];
   }
   let t22;
-  if ($4[2] !== children2) {
+  if ($4[2] !== children3) {
     t22 = /* @__PURE__ */ jsx_dev_runtime469.jsxDEV(ThemedBox_default, {
       flexDirection: "column",
-      children: children2
+      children: children3
     }, undefined, false, undefined, this);
-    $4[2] = children2;
+    $4[2] = children3;
     $4[3] = t22;
   } else {
     t22 = $4[3];
@@ -723562,13 +724694,13 @@ var init_OrderedListItem = __esm(() => {
 function OrderedListComponent(t0) {
   const $4 = import_compiler_runtime355.c(9);
   const {
-    children: children2
+    children: children3
   } = t0;
   const {
     marker: parentMarker
   } = import_react320.useContext(OrderedListContext);
   let numberOfItems = 0;
-  for (const child of import_react320.default.Children.toArray(children2)) {
+  for (const child of import_react320.default.Children.toArray(children3)) {
     if (!import_react320.isValidElement(child) || child.type !== OrderedListItem) {
       continue;
     }
@@ -723576,7 +724708,7 @@ function OrderedListComponent(t0) {
   }
   const maxMarkerWidth = String(numberOfItems).length;
   let t1;
-  if ($4[0] !== children2 || $4[1] !== maxMarkerWidth || $4[2] !== parentMarker) {
+  if ($4[0] !== children3 || $4[1] !== maxMarkerWidth || $4[2] !== parentMarker) {
     let t23;
     if ($4[4] !== maxMarkerWidth || $4[5] !== parentMarker) {
       t23 = (child_0, index2) => {
@@ -723603,8 +724735,8 @@ function OrderedListComponent(t0) {
     } else {
       t23 = $4[6];
     }
-    t1 = import_react320.default.Children.map(children2, t23);
-    $4[0] = children2;
+    t1 = import_react320.default.Children.map(children3, t23);
+    $4[0] = children3;
     $4[1] = maxMarkerWidth;
     $4[2] = parentMarker;
     $4[3] = t1;
@@ -723906,7 +725038,7 @@ function SkippableStep(t0) {
   const {
     skip,
     onSkip,
-    children: children2
+    children: children3
   } = t0;
   let t1;
   let t22;
@@ -723929,7 +725061,7 @@ function SkippableStep(t0) {
   if (skip) {
     return null;
   }
-  return children2;
+  return children3;
 }
 var import_compiler_runtime356, import_react321, jsx_dev_runtime471;
 var init_Onboarding = __esm(() => {
@@ -724093,7 +725225,7 @@ var exports_TrustDialog = {};
 __export(exports_TrustDialog, {
   TrustDialog: () => TrustDialog
 });
-import { homedir as homedir44 } from "os";
+import { homedir as homedir45 } from "os";
 function TrustDialog(t0) {
   const $4 = import_compiler_runtime357.c(33);
   const {
@@ -724204,7 +725336,7 @@ function TrustDialog(t0) {
   let t13;
   if ($4[13] !== hasAnyBashExecution) {
     t12 = () => {
-      const isHomeDir = homedir44() === getCwd();
+      const isHomeDir = homedir45() === getCwd();
       logEvent("tengu_trust_dialog_shown", {
         isHomeDir,
         hasMcpServers,
@@ -724233,7 +725365,7 @@ function TrustDialog(t0) {
         gracefulShutdownSync(1);
         return;
       }
-      const isHomeDir_0 = homedir44() === getCwd();
+      const isHomeDir_0 = homedir45() === getCwd();
       logEvent("tengu_trust_dialog_accept", {
         isHomeDir: isHomeDir_0,
         hasMcpServers,
@@ -724877,7 +726009,7 @@ var init_ClaudeInChromeOnboarding = __esm(() => {
 });
 
 // src/interactiveHelpers.tsx
-import { appendFileSync as appendFileSync4 } from "fs";
+import { appendFileSync as appendFileSync5 } from "fs";
 function completeOnboarding() {
   saveGlobalConfig((current) => ({
     ...current,
@@ -725105,7 +726237,7 @@ function getRenderContext(exitOnCtrlC) {
             cpu: process.cpuUsage()
           }) + `
 `;
-          appendFileSync4(frameTimingLogPath, line);
+          appendFileSync5(frameTimingLogPath, line);
         }
         if (isSynchronizedOutputSupported()) {
           return;
@@ -726963,7 +728095,7 @@ var init_claudeInChrome = __esm(() => {
 });
 
 // src/skills/bundled/debug.ts
-import { open as open15, stat as stat52 } from "fs/promises";
+import { open as open16, stat as stat52 } from "fs/promises";
 function registerDebugSkill() {
   registerBundledSkill({
     name: "debug",
@@ -726980,7 +728112,7 @@ function registerDebugSkill() {
         const stats = await stat52(debugLogPath);
         const readSize = Math.min(stats.size, TAIL_READ_BYTES);
         const startOffset = stats.size - readSize;
-        const fd2 = await open15(debugLogPath, "r");
+        const fd2 = await open16(debugLogPath, "r");
         try {
           const { buffer, bytesRead } = await fd2.read({
             buffer: Buffer.alloc(readSize),
@@ -729662,8 +730794,8 @@ var init_bundled2 = __esm(() => {
 
 // src/utils/deepLink/banner.ts
 import { stat as stat53 } from "fs/promises";
-import { homedir as homedir45 } from "os";
-import { join as join171, sep as sep43 } from "path";
+import { homedir as homedir46 } from "os";
+import { join as join175, sep as sep43 } from "path";
 function buildDeepLinkBanner(info) {
   const lines2 = [
     `This session was opened by an external deep link in ${tildify(info.cwd)}`
@@ -729685,8 +730817,8 @@ async function readLastFetchTime(cwd2) {
     return;
   const commonDir = await getCommonDir(gitDir);
   const [local, common4] = await Promise.all([
-    mtimeOrUndefined(join171(gitDir, "FETCH_HEAD")),
-    commonDir ? mtimeOrUndefined(join171(commonDir, "FETCH_HEAD")) : Promise.resolve(undefined)
+    mtimeOrUndefined(join175(gitDir, "FETCH_HEAD")),
+    commonDir ? mtimeOrUndefined(join175(commonDir, "FETCH_HEAD")) : Promise.resolve(undefined)
   ]);
   if (local && common4)
     return local > common4 ? local : common4;
@@ -729701,7 +730833,7 @@ async function mtimeOrUndefined(p4) {
   }
 }
 function tildify(p4) {
-  const home = homedir45();
+  const home = homedir46();
   if (p4 === home)
     return "~";
   if (p4.startsWith(home + sep43))
@@ -730065,9 +731197,9 @@ function levenshtein2(a5, b5) {
   }
   return prev[n6];
 }
-function getSubcommandNames(program2) {
+function getSubcommandNames(program3) {
   const names = [];
-  for (const cmd of program2.commands) {
+  for (const cmd of program3.commands) {
     const name3 = cmd.name();
     if (name3)
       names.push(name3);
@@ -730076,12 +731208,12 @@ function getSubcommandNames(program2) {
   }
   return names;
 }
-function findClosestSubcommand(word, program2) {
+function findClosestSubcommand(word, program3) {
   if (!word)
     return;
   let best;
   let bestDist = Infinity;
-  for (const name3 of getSubcommandNames(program2)) {
+  for (const name3 of getSubcommandNames(program3)) {
     if (name3 === word)
       continue;
     const dist = levenshtein2(word, name3);
@@ -730535,7 +731667,7 @@ var parseConnectUrl = () => ({ serverUrl: "", authToken: "" });
 var init_parseConnectUrl = () => {};
 
 // src/utils/deepLink/terminalLauncher.ts
-import { spawn as spawn16 } from "child_process";
+import { spawn as spawn17 } from "child_process";
 import { basename as basename64 } from "path";
 async function detectMacosTerminal() {
   const stored = getGlobalConfig().deepLinkTerminal;
@@ -730792,7 +731924,7 @@ async function launchWindowsTerminal(terminal, claudePath, claudeArgs, cwd2) {
 }
 function spawnDetached(command10, args, opts = {}) {
   return new Promise((resolve53) => {
-    const child = spawn16(command10, args, {
+    const child = spawn17(command10, args, {
       detached: true,
       stdio: "ignore",
       cwd: opts.cwd,
@@ -730875,7 +732007,7 @@ __export(exports_protocolHandler, {
   handleUrlSchemeLaunch: () => handleUrlSchemeLaunch,
   handleDeepLinkUri: () => handleDeepLinkUri
 });
-import { homedir as homedir46 } from "os";
+import { homedir as homedir47 } from "os";
 async function handleDeepLinkUri(uri3) {
   logForDebugging(`Handling deep link URI: ${uri3}`);
   let action2;
@@ -730929,7 +732061,7 @@ async function resolveCwd(action2) {
     }
     logForDebugging(`No local clone found for repo ${action2.repo}, falling back to home`);
   }
-  return { cwd: homedir46() };
+  return { cwd: homedir47() };
 }
 var init_protocolHandler = __esm(() => {
   init_debug();
@@ -730946,12 +732078,12 @@ var exports_setup = {};
 __export(exports_setup, {
   setupComputerUseMCP: () => setupComputerUseMCP
 });
-import { join as join172 } from "path";
+import { join as join176 } from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 function setupComputerUseMCP() {
   const allowedTools = buildComputerUseTools(CLI_CU_CAPABILITIES, getChicagoCoordinateMode()).map((t4) => buildMcpToolName(COMPUTER_USE_MCP_SERVER_NAME, t4.name));
   const args = isInBundledMode() ? ["--computer-use-mcp"] : [
-    join172(fileURLToPath9(import.meta.url), "..", "cli.js"),
+    join176(fileURLToPath9(import.meta.url), "..", "cli.js"),
     "--computer-use-mcp"
   ];
   return {
@@ -730974,7 +732106,7 @@ var init_setup3 = __esm(() => {
 });
 
 // src/services/SessionMemory/sessionMemory.ts
-import { writeFile as writeFile62 } from "fs/promises";
+import { writeFile as writeFile63 } from "fs/promises";
 function isSessionMemoryGateEnabled() {
   return getFeatureValue_CACHED_MAY_BE_STALE("tengu_session_memory", false);
 }
@@ -731028,13 +732160,13 @@ async function setupSessionMemoryFile(toolUseContext) {
   await fs21.mkdir(sessionMemoryDir, { mode: 448 });
   const memoryPath = getSessionMemoryPath();
   try {
-    await writeFile62(memoryPath, "", {
+    await writeFile63(memoryPath, "", {
       encoding: "utf-8",
       mode: 384,
       flag: "wx"
     });
     const template = await loadSessionMemoryTemplate();
-    await writeFile62(memoryPath, template, {
+    await writeFile63(memoryPath, template, {
       encoding: "utf-8",
       mode: 384
     });
@@ -731172,8 +732304,8 @@ var init_sessionMemory = __esm(() => {
 
 // src/utils/iTermBackup.ts
 import { copyFile as copyFile12, stat as stat54 } from "fs/promises";
-import { homedir as homedir47 } from "os";
-import { join as join173 } from "path";
+import { homedir as homedir48 } from "os";
+import { join as join177 } from "path";
 function markITerm2SetupComplete() {
   saveGlobalConfig((current) => ({
     ...current,
@@ -731188,7 +732320,7 @@ function getIterm2RecoveryInfo() {
   };
 }
 function getITerm2PlistPath() {
-  return join173(homedir47(), "Library", "Preferences", "com.googlecode.iterm2.plist");
+  return join177(homedir48(), "Library", "Preferences", "com.googlecode.iterm2.plist");
 }
 async function checkAndRestoreITerm2Backup() {
   const { inProgress, backupPath } = getIterm2RecoveryInfo();
@@ -732715,7 +733847,7 @@ var init_QueryEngine = __esm(() => {
 var FILE_COUNT_LIMIT = 1e4, OUTPUTS_SUBDIR = ".claude-code/outputs", DEFAULT_UPLOAD_CONCURRENCY = 5;
 
 // src/utils/filePersistence/filePersistence.ts
-import { join as join174, relative as relative37 } from "path";
+import { join as join178, relative as relative37 } from "path";
 async function runFilePersistence(turnStartTime, signal) {
   const environmentKind = getEnvironmentKind();
   if (environmentKind !== "byoc") {
@@ -732734,7 +733866,7 @@ async function runFilePersistence(turnStartTime, signal) {
     oauthToken: sessionAccessToken,
     sessionId
   };
-  const outputsDir = join174(getCwd(), sessionId, OUTPUTS_SUBDIR);
+  const outputsDir = join178(getCwd(), sessionId, OUTPUTS_SUBDIR);
   if (signal?.aborted) {
     logDebug("Persistence aborted before processing");
     return null;
@@ -732942,11 +734074,11 @@ var init_sessionUrl = __esm(() => {
 });
 
 // src/utils/plugins/zipCacheAdapters.ts
-import { readFile as readFile66 } from "fs/promises";
-import { join as join175 } from "path";
+import { readFile as readFile67 } from "fs/promises";
+import { join as join179 } from "path";
 async function readZipCacheKnownMarketplaces() {
   try {
-    const content = await readFile66(getZipCacheKnownMarketplacesPath(), "utf-8");
+    const content = await readFile67(getZipCacheKnownMarketplacesPath(), "utf-8");
     const parsed = KnownMarketplacesFileSchema().safeParse(jsonParse(content));
     if (!parsed.success) {
       logForDebugging(`Invalid known_marketplaces.json in zip cache: ${parsed.error.message}`, { level: "error" });
@@ -732968,18 +734100,18 @@ async function saveMarketplaceJsonToZipCache(marketplaceName, installLocation) {
   const content = await readMarketplaceJsonContent(installLocation);
   if (content !== null) {
     const relPath = getMarketplaceJsonRelativePath(marketplaceName);
-    await atomicWriteToZipCache(join175(zipCachePath, relPath), content);
+    await atomicWriteToZipCache(join179(zipCachePath, relPath), content);
   }
 }
 async function readMarketplaceJsonContent(dir) {
   const candidates = [
-    join175(dir, ".claude-plugin", "marketplace.json"),
-    join175(dir, "marketplace.json"),
+    join179(dir, ".claude-plugin", "marketplace.json"),
+    join179(dir, "marketplace.json"),
     dir
   ];
   for (const candidate of candidates) {
     try {
-      return await readFile66(candidate, "utf-8");
+      return await readFile67(candidate, "utf-8");
     } catch {}
   }
   return null;
@@ -733109,7 +734241,7 @@ __export(exports_print, {
   createCanUseToolWithPermissionPrompt: () => createCanUseToolWithPermissionPrompt,
   canBatchWith: () => canBatchWith
 });
-import { readFile as readFile67, stat as stat55 } from "fs/promises";
+import { readFile as readFile68, stat as stat55 } from "fs/promises";
 import { dirname as dirname76 } from "path";
 import { cwd as cwd2 } from "process";
 import { randomUUID as randomUUID65 } from "crypto";
@@ -733435,7 +734567,7 @@ Error: sandbox required but unavailable: ${sandboxUnavailableReason}
   gracefulShutdownSync(lastMessage?.type === "result" && lastMessage?.is_error ? 1 : 0);
 }
 function runHeadlessStreaming(structuredIO, mcpClients, commands7, tools, initialMessages, canUseTool, sdkMcpConfigs, getAppState, setAppState, agents2, options, turnInterruptionState) {
-  let running = false;
+  let running2 = false;
   let runPhase;
   let inputClosed = false;
   let shutdownPromptInjected = false;
@@ -733457,7 +734589,7 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands7, tools, initia
         bg[t4.type] = (bg[t4.type] ?? 0) + 1;
     }
     logForDiagnosticsNoPII("info", "run_state_at_shutdown", {
-      run_active: running,
+      run_active: running2,
       run_phase: runPhase,
       worker_status: getSessionState(),
       internal_events_pending: structuredIO.internalEventsPending,
@@ -733816,7 +734948,7 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands7, tools, initia
       installPluginsAndApplyMcpInBackground();
     }
   }
-  const idleTimeout = createIdleTimeoutManager(() => !running);
+  const idleTimeout = createIdleTimeoutManager(() => !running2);
   let currentCommands = commands7;
   let currentAgents = agents2;
   async function refreshPluginState() {
@@ -733873,10 +735005,10 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands7, tools, initia
     }
   });
   const run = async () => {
-    if (running) {
+    if (running2) {
       return;
     }
-    running = true;
+    running2 = true;
     runPhase = undefined;
     notifySessionStateChanged("running");
     idleTimeout.stop();
@@ -734228,7 +735360,7 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands7, tools, initia
           output.enqueue(event);
         }
       }
-      running = false;
+      running2 = false;
       idleTimeout.start();
     }
     if ((feature("PROACTIVE") || feature("KAIROS")) && proactiveModule9?.isProactiveActive() && !proactiveModule9.isProactivePaused()) {
@@ -734373,7 +735505,7 @@ ${m5.text}
         });
         run();
       },
-      isLoading: () => running || inputClosed,
+      isLoading: () => running2 || inputClosed,
       getJitterConfig: cronJitterConfigModule?.getCronJitterConfig,
       isKilled: () => !cronGate?.isKairosCronEnabled()
     });
@@ -734552,7 +735684,7 @@ ${m5.text}
             const normalizedPath = expandPath(message.request.path);
             const diskMtime = Math.floor((await stat55(normalizedPath)).mtimeMs);
             if (diskMtime <= message.request.mtime) {
-              const raw = await readFile67(normalizedPath, "utf-8");
+              const raw = await readFile68(normalizedPath, "utf-8");
               const content = (raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw).replaceAll(`\r
 `, `
 `);
@@ -735238,7 +736370,7 @@ ${m5.text}
     }
     inputClosed = true;
     cronScheduler?.stop();
-    if (!running) {
+    if (!running2) {
       if (suggestionState.inflightPromise) {
         await Promise.race([suggestionState.inflightPromise, sleep3(5000)]);
       }
@@ -737250,16 +738382,16 @@ __export(exports_claudeDesktop, {
   readClaudeDesktopMcpServers: () => readClaudeDesktopMcpServers,
   getClaudeDesktopConfigPath: () => getClaudeDesktopConfigPath
 });
-import { readdir as readdir37, readFile as readFile68, stat as stat56 } from "fs/promises";
-import { homedir as homedir48 } from "os";
-import { join as join176 } from "path";
+import { readdir as readdir37, readFile as readFile69, stat as stat56 } from "fs/promises";
+import { homedir as homedir49 } from "os";
+import { join as join180 } from "path";
 async function getClaudeDesktopConfigPath() {
   const platform7 = getPlatform();
   if (!SUPPORTED_PLATFORMS.includes(platform7)) {
     throw new Error(`Unsupported platform: ${platform7} - Claude Desktop integration only works on macOS and WSL.`);
   }
   if (platform7 === "macos") {
-    return join176(homedir48(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return join180(homedir49(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   const windowsHome = process.env.USERPROFILE ? process.env.USERPROFILE.replace(/\\/g, "/") : null;
   if (windowsHome) {
@@ -737278,7 +738410,7 @@ async function getClaudeDesktopConfigPath() {
         if (user.name === "Public" || user.name === "Default" || user.name === "Default User" || user.name === "All Users") {
           continue;
         }
-        const potentialConfigPath = join176(usersDir, user.name, "AppData", "Roaming", "Claude", "claude_desktop_config.json");
+        const potentialConfigPath = join180(usersDir, user.name, "AppData", "Roaming", "Claude", "claude_desktop_config.json");
         try {
           await stat56(potentialConfigPath);
           return potentialConfigPath;
@@ -737298,7 +738430,7 @@ async function readClaudeDesktopMcpServers() {
     const configPath = await getClaudeDesktopConfigPath();
     let configContent;
     try {
-      configContent = await readFile68(configPath, { encoding: "utf8" });
+      configContent = await readFile69(configPath, { encoding: "utf8" });
     } catch (e4) {
       const code = getErrnoCode(e4);
       if (code === "ENOENT") {
@@ -738246,13 +739378,13 @@ var exports_install = {};
 __export(exports_install, {
   install: () => install
 });
-import { homedir as homedir49 } from "os";
-import { join as join177 } from "path";
+import { homedir as homedir50 } from "os";
+import { join as join181 } from "path";
 function getInstallationPath2() {
   const isWindows3 = env4.platform === "win32";
-  const homeDir = homedir49();
+  const homeDir = homedir50();
   if (isWindows3) {
-    const windowsPath = join177(homeDir, ".local", "bin", "claude.exe");
+    const windowsPath = join181(homeDir, ".local", "bin", "claude.exe");
     return windowsPath.replace(/\//g, "\\");
   }
   return "~/.local/bin/claude";
@@ -738564,7 +739696,7 @@ function Install({
   }, undefined, true, undefined, this);
 }
 var import_compiler_runtime368, import_react332, jsx_dev_runtime486, install;
-var init_install = __esm(() => {
+var init_install2 = __esm(() => {
   init_analytics();
   init_StatusIcon();
   init_ink2();
@@ -738698,7 +739830,7 @@ async function installHandler(target, options) {
   await setup2(cwd4(), "default", false, false, undefined, false);
   const {
     install: install2
-  } = await Promise.resolve().then(() => (init_install(), exports_install));
+  } = await Promise.resolve().then(() => (init_install2(), exports_install));
   await new Promise((resolve53) => {
     const args = [];
     if (target)
@@ -738837,7 +739969,7 @@ var exports_projectPurge = {};
 __export(exports_projectPurge, {
   purgeProjectHandler: () => purgeProjectHandler
 });
-import { join as join178 } from "path";
+import { join as join182 } from "path";
 function resolveAbsolutePath(input) {
   if (!input) {
     return getCwd();
@@ -738856,7 +739988,7 @@ async function discoverAllProjectPaths() {
   try {
     const entries = await fs21.readdir(projectsDir);
     for (const entry of entries) {
-      paths2.add(join178(projectsDir, entry.name));
+      paths2.add(join182(projectsDir, entry.name));
     }
   } catch {}
   return [...paths2];
@@ -738866,7 +739998,7 @@ async function collectItemsForProject(projectPath) {
   const warnings = [];
   const fs21 = getFsImplementation();
   const projectsDir = getProjectsDir2();
-  const transcriptDir = join178(projectsDir, sanitizePath2(projectPath));
+  const transcriptDir = join182(projectsDir, sanitizePath2(projectPath));
   try {
     const stat58 = await fs21.stat(transcriptDir);
     if (stat58.isDirectory()) {
@@ -739532,7 +740664,7 @@ __export(exports_main4, {
   startDeferredPrefetches: () => startDeferredPrefetches,
   main: () => main
 });
-import { readFileSync as readFileSync26 } from "fs";
+import { readFileSync as readFileSync28 } from "fs";
 import { resolve as resolve53 } from "path";
 function logManagedSettings() {
   try {
@@ -739609,26 +740741,54 @@ async function logStartupTelemetry() {
   });
 }
 function runMigrations() {
+  process.stderr.write(`[DIAG5] runMigrations entry
+`);
   if (getGlobalConfig().migrationVersion !== CURRENT_MIGRATION_VERSION) {
+    process.stderr.write(`[DIAG5] before migrateAutoUpdates
+`);
     migrateAutoUpdatesToSettings();
+    process.stderr.write(`[DIAG5] before migrateBypass
+`);
     migrateBypassPermissionsAcceptedToSettings();
+    process.stderr.write(`[DIAG5] before migrateEnableAllMcp
+`);
     migrateEnableAllProjectMcpServersToSettings();
+    process.stderr.write(`[DIAG5] before resetPro
+`);
     resetProToOpusDefault();
+    process.stderr.write(`[DIAG5] before migrateSonnet1m
+`);
     migrateSonnet1mToSonnet45();
+    process.stderr.write(`[DIAG5] before migrateLegacyOpus
+`);
     migrateLegacyOpusToCurrent();
+    process.stderr.write(`[DIAG5] before migrateSonnet45
+`);
     migrateSonnet45ToSonnet46();
+    process.stderr.write(`[DIAG5] before migrateOpus1m
+`);
     migrateOpusToOpus1m();
+    process.stderr.write(`[DIAG5] before migrateReplBridge
+`);
     migrateReplBridgeEnabledToRemoteControlAtStartup();
     if (feature("TRANSCRIPT_CLASSIFIER")) {
       resetAutoModeOptInForDefaultOffer();
     }
     if (false) {}
+    process.stderr.write(`[DIAG5] before saveGlobalConfig
+`);
     saveGlobalConfig((prev) => prev.migrationVersion === CURRENT_MIGRATION_VERSION ? prev : {
       ...prev,
       migrationVersion: CURRENT_MIGRATION_VERSION
     });
+    process.stderr.write(`[DIAG5] after saveGlobalConfig
+`);
   }
+  process.stderr.write(`[DIAG5] before migrateChangelog
+`);
   migrateChangelogFromConfig().catch(() => {});
+  process.stderr.write(`[DIAG5] runMigrations exit
+`);
 }
 function prefetchSystemContextIfSafe() {
   const isNonInteractiveSession = getIsNonInteractiveSession();
@@ -739690,7 +740850,7 @@ function loadSettingsFromFlag(settingsFile) {
         resolvedPath: resolvedSettingsPath
       } = safeResolvePath(getFsImplementation(), settingsFile);
       try {
-        readFileSync26(resolvedSettingsPath, "utf8");
+        readFileSync28(resolvedSettingsPath, "utf8");
       } catch (e4) {
         if (isENOENT(e4)) {
           process.stderr.write(source_default.red(`Error: Settings file not found: ${resolvedSettingsPath}
@@ -739912,6 +741072,13 @@ async function main() {
   const hasInitOnlyFlag = cliArgs.includes("--init-only");
   const hasSdkUrl = cliArgs.some((arg) => arg.startsWith("--sdk-url"));
   const isNonInteractive = hasPrintFlag || hasInitOnlyFlag || hasSdkUrl || !process.stdout.isTTY;
+  const daemonWorkerIdx = cliArgs.indexOf("--daemon-worker");
+  if (daemonWorkerIdx >= 0) {
+    const workerKind = cliArgs[daemonWorkerIdx + 1] ?? "default";
+    const { runDaemonWorker: runDaemonWorker2 } = await Promise.resolve().then(() => (init_workerRegistry(), exports_workerRegistry));
+    await runDaemonWorker2(workerKind);
+    return program;
+  }
   if (isNonInteractive) {
     stopCapturingEarlyInput();
   }
@@ -739988,9 +741155,9 @@ async function run() {
       compareOptions: (a5, b5) => getOptionSortKey(a5).localeCompare(getOptionSortKey(b5))
     });
   }
-  const program2 = new Command().configureHelp(createSortedHelpConfig()).enablePositionalOptions();
+  const program3 = new Command().configureHelp(createSortedHelpConfig()).enablePositionalOptions();
   profileCheckpoint("run_commander_initialized");
-  program2.hook("preAction", async (thisCommand) => {
+  program3.hook("preAction", async (thisCommand) => {
     profileCheckpoint("preAction_start");
     await Promise.all([ensureMdmSettingsLoaded(), ensureKeychainPrefetchCompleted()]);
     profileCheckpoint("preAction_after_mdm");
@@ -740005,11 +741172,17 @@ async function run() {
     initSinks2();
     profileCheckpoint("preAction_after_sinks");
     const pluginDir = thisCommand.getOptionValue("pluginDir");
+    process.stderr.write(`[DIAG4] before pluginDir check
+`);
     if (Array.isArray(pluginDir) && pluginDir.length > 0 && pluginDir.every((p4) => typeof p4 === "string")) {
       setInlinePlugins(pluginDir);
       clearPluginCache("preAction: --plugin-dir inline plugins");
     }
+    process.stderr.write(`[DIAG4] before runMigrations
+`);
     runMigrations();
+    process.stderr.write(`[DIAG4] after runMigrations
+`);
     profileCheckpoint("preAction_after_migrations");
     if (getSettingsForSource("policySettings")?.forceRemoteSettingsRefresh) {
       const result = await forceRefreshRemoteManagedSettingsOrFailClosed();
@@ -740028,7 +741201,7 @@ async function run() {
     }
     profileCheckpoint("preAction_after_settings_sync");
   });
-  program2.name("claude").description(`Claude Code - starts an interactive session by default, use -p/--print for non-interactive output`).argument("[prompt]", "Your prompt", String).helpOption("-h, --help", "Display help for command").option("-d, --debug [filter]", 'Enable debug mode with optional category filtering (e.g., "api,hooks" or "!1p,!file")', (_value) => {
+  program3.name("claude").description(`Claude Code - starts an interactive session by default, use -p/--print for non-interactive output`).argument("[prompt]", "Your prompt", String).helpOption("-h, --help", "Display help for command").option("-d, --debug [filter]", 'Enable debug mode with optional category filtering (e.g., "api,hooks" or "!1p,!file")', (_value) => {
     return true;
   }).addOption(new Option("--debug-to-stderr", "Enable debug mode (to stderr)").argParser(Boolean).hideHelp()).option("--debug-file <path>", "Write debug logs to a specific file path (implicitly enables debug mode)", () => true).option("--verbose", "Override verbose mode setting from config", () => true).option("-p, --print", "Print response and exit (useful for pipes). Note: The workspace trust dialog is skipped when Claude is run with the -p mode. Only use this flag in directories you trust.", () => true).option("--bare", "Minimal mode: skip hooks, LSP, plugin sync, attribution, auto-memory, background prefetches, keychain reads, and CLAUDE.md auto-discovery. Sets CLAUDE_CODE_SIMPLE=1. Anthropic auth is strictly ANTHROPIC_API_KEY or apiKeyHelper via --settings (OAuth and keychain are never read). 3P providers (Bedrock/Vertex/Foundry) use their own credentials. Skills still resolve via /skill-name. Explicitly provide context via: --system-prompt[-file], --append-system-prompt[-file], --add-dir (CLAUDE.md dirs), --mcp-config, --settings, --agents, --plugin-dir.", () => true).addOption(new Option("--init", "Run Setup hooks with init trigger, then continue").hideHelp()).addOption(new Option("--init-only", "Run Setup and SessionStart:startup hooks, then exit").hideHelp()).addOption(new Option("--maintenance", "Run Setup hooks with maintenance trigger, then continue").hideHelp()).addOption(new Option("--output-format <format>", 'Output format (only works with --print): "text" (default), "json" (single result), or "stream-json" (realtime streaming)').choices(["text", "json", "stream-json"])).addOption(new Option("--json-schema <schema>", 'JSON Schema for structured output validation. Example: {"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}').argParser(String)).option("--include-hook-events", "Include all hook lifecycle events in the output stream (only works with --output-format=stream-json)", () => true).option("--include-partial-messages", "Include partial message chunks as they arrive (only works with --print and --output-format=stream-json)", () => true).addOption(new Option("--input-format <format>", 'Input format (only works with --print): "text" (default), or "stream-json" (realtime streaming input)').choices(["text", "stream-json"])).option("--mcp-debug", "[DEPRECATED. Use --debug instead] Enable MCP debug mode (shows MCP server errors)", () => true).option("--dangerously-skip-permissions", "Bypass all permission checks. Recommended only for sandboxes with no internet access.", () => true).option("--allow-dangerously-skip-permissions", "Enable bypassing all permission checks as an option, without it being enabled by default. Recommended only for sandboxes with no internet access.", () => true).addOption(new Option("--thinking <mode>", "Thinking mode: enabled (equivalent to adaptive), disabled").choices(["enabled", "adaptive", "disabled"]).hideHelp()).addOption(new Option("--max-thinking-tokens <tokens>", "[DEPRECATED. Use --thinking instead for newer models] Maximum number of thinking tokens (only works with --print)").argParser(Number).hideHelp()).addOption(new Option("--max-turns <turns>", "Maximum number of agentic turns in non-interactive mode. This will early exit the conversation after the specified number of turns. (only works with --print)").argParser(Number).hideHelp()).addOption(new Option("--max-budget-usd <amount>", "Maximum dollar amount to spend on API calls (only works with --print)").argParser((value) => {
     const amount = Number(value);
@@ -740068,12 +741241,12 @@ async function run() {
       });
     }
     if (prompt && typeof prompt === "string" && !/\s/.test(prompt) && prompt.length > 0) {
-      const subcommandSuggestion = findClosestSubcommand(prompt, program2);
+      const subcommandSuggestion = findClosestSubcommand(prompt, program3);
       if (subcommandSuggestion) {
         process.stderr.write(`Unknown command: ${prompt}. Did you mean '${subcommandSuggestion}'?
 `);
         await gracefulShutdown(1);
-        return program2;
+        return program3;
       }
     }
     let kairosEnabled = false;
@@ -740266,7 +741439,7 @@ ${getTmuxInstallInstructions2()}
       }
       try {
         const filePath = resolve53(options.systemPromptFile);
-        systemPrompt = readFileSync26(filePath, "utf8");
+        systemPrompt = readFileSync28(filePath, "utf8");
       } catch (error52) {
         const code = getErrnoCode(error52);
         if (code === "ENOENT") {
@@ -740288,7 +741461,7 @@ ${getTmuxInstallInstructions2()}
       }
       try {
         const filePath = resolve53(options.appendSystemPromptFile);
-        appendSystemPrompt = readFileSync26(filePath, "utf8");
+        appendSystemPrompt = readFileSync28(filePath, "utf8");
       } catch (error52) {
         const code = getErrnoCode(error52);
         if (code === "ENOENT") {
@@ -742062,59 +743235,60 @@ Usage: claude --remote "your task description"`, () => gracefulShutdown(1));
       }, renderAndRun);
     }
   }).version(`${MACRO.VERSION} (Claude Code)`, "-v, --version", "Output the version number");
-  program2.option("-w, --worktree [name]", "Create a new git worktree for this session (optionally specify a name)");
-  program2.option("--tmux", "Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.");
+  program3.option("-w, --worktree [name]", "Create a new git worktree for this session (optionally specify a name)");
+  program3.option("--tmux", "Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.");
   if (canUserConfigureAdvisor()) {
-    program2.addOption(new Option("--advisor <model>", "Enable the server-side advisor tool with the specified model (alias or full ID).").hideHelp());
+    program3.addOption(new Option("--advisor <model>", "Enable the server-side advisor tool with the specified model (alias or full ID).").hideHelp());
   }
   if (false) {}
   if (feature("TRANSCRIPT_CLASSIFIER")) {
-    program2.addOption(new Option("--enable-auto-mode", "Opt in to auto mode").hideHelp());
+    program3.addOption(new Option("--enable-auto-mode", "Opt in to auto mode").hideHelp());
   }
   if (feature("PROACTIVE") || feature("KAIROS")) {
-    program2.addOption(new Option("--proactive", "Start in proactive autonomous mode"));
+    program3.addOption(new Option("--proactive", "Start in proactive autonomous mode"));
   }
   if (feature("UDS_INBOX")) {
-    program2.addOption(new Option("--messaging-socket-path <path>", "Unix domain socket path for the UDS messaging server (defaults to a tmp path)"));
+    program3.addOption(new Option("--messaging-socket-path <path>", "Unix domain socket path for the UDS messaging server (defaults to a tmp path)"));
   }
   if (feature("KAIROS") || feature("KAIROS_BRIEF")) {
-    program2.addOption(new Option("--brief", "Enable SendUserMessage tool for agent-to-user communication"));
+    program3.addOption(new Option("--brief", "Enable SendUserMessage tool for agent-to-user communication"));
   }
   if (feature("KAIROS")) {
-    program2.addOption(new Option("--assistant", "Force assistant mode (Agent SDK daemon use)").hideHelp());
+    program3.addOption(new Option("--assistant", "Force assistant mode (Agent SDK daemon use)").hideHelp());
   }
   if (feature("KAIROS") || feature("KAIROS_CHANNELS")) {
-    program2.addOption(new Option("--channels <servers...>", "MCP servers whose channel notifications (inbound push) should register this session. Space-separated server names.").hideHelp());
-    program2.addOption(new Option("--dangerously-load-development-channels <servers...>", "Load channel servers not on the approved allowlist. For local channel development only. Shows a confirmation dialog at startup.").hideHelp());
-  }
-  program2.addOption(new Option("--agent-id <id>", "Teammate agent ID").hideHelp());
-  program2.addOption(new Option("--agent-name <name>", "Teammate display name").hideHelp());
-  program2.addOption(new Option("--team-name <name>", "Team name for swarm coordination").hideHelp());
-  program2.addOption(new Option("--agent-color <color>", "Teammate UI color").hideHelp());
-  program2.addOption(new Option("--plan-mode-required", "Require plan mode before implementation").hideHelp());
-  program2.addOption(new Option("--parent-session-id <id>", "Parent session ID for analytics correlation").hideHelp());
-  program2.addOption(new Option("--teammate-mode <mode>", 'How to spawn teammates: "tmux", "in-process", or "auto"').choices(["auto", "tmux", "in-process"]).hideHelp());
-  program2.addOption(new Option("--agent-type <type>", "Custom agent type for this teammate").hideHelp());
-  program2.addOption(new Option("--sdk-url <url>", "Use remote WebSocket endpoint for SDK I/O streaming (only with -p and stream-json format)").hideHelp());
-  program2.addOption(new Option("--teleport [session]", "Resume a teleport session, optionally specify session ID").hideHelp());
-  program2.addOption(new Option("--remote [description]", "Create a remote session with the given description").hideHelp());
+    program3.addOption(new Option("--channels <servers...>", "MCP servers whose channel notifications (inbound push) should register this session. Space-separated server names.").hideHelp());
+    program3.addOption(new Option("--dangerously-load-development-channels <servers...>", "Load channel servers not on the approved allowlist. For local channel development only. Shows a confirmation dialog at startup.").hideHelp());
+  }
+  program3.addOption(new Option("--agent-id <id>", "Teammate agent ID").hideHelp());
+  program3.addOption(new Option("--agent-name <name>", "Teammate display name").hideHelp());
+  program3.addOption(new Option("--team-name <name>", "Team name for swarm coordination").hideHelp());
+  program3.addOption(new Option("--agent-color <color>", "Teammate UI color").hideHelp());
+  program3.addOption(new Option("--plan-mode-required", "Require plan mode before implementation").hideHelp());
+  program3.addOption(new Option("--parent-session-id <id>", "Parent session ID for analytics correlation").hideHelp());
+  program3.addOption(new Option("--teammate-mode <mode>", 'How to spawn teammates: "tmux", "in-process", or "auto"').choices(["auto", "tmux", "in-process"]).hideHelp());
+  program3.addOption(new Option("--agent-type <type>", "Custom agent type for this teammate").hideHelp());
+  program3.addOption(new Option("--sdk-url <url>", "Use remote WebSocket endpoint for SDK I/O streaming (only with -p and stream-json format)").hideHelp());
+  program3.addOption(new Option("--daemon-worker <kind>", "Run as a B daemon worker of the given kind (internal)").hideHelp());
+  program3.addOption(new Option("--teleport [session]", "Resume a teleport session, optionally specify session ID").hideHelp());
+  program3.addOption(new Option("--remote [description]", "Create a remote session with the given description").hideHelp());
   if (feature("BRIDGE_MODE")) {
-    program2.addOption(new Option("--remote-control [name]", "Start an interactive session with Remote Control enabled (optionally named)").argParser((value) => value || true).hideHelp());
-    program2.addOption(new Option("--rc [name]", "Alias for --remote-control").argParser((value) => value || true).hideHelp());
+    program3.addOption(new Option("--remote-control [name]", "Start an interactive session with Remote Control enabled (optionally named)").argParser((value) => value || true).hideHelp());
+    program3.addOption(new Option("--rc [name]", "Alias for --remote-control").argParser((value) => value || true).hideHelp());
   }
   if (feature("HARD_FAIL")) {
-    program2.addOption(new Option("--hard-fail", "Crash on logError calls instead of silently logging").hideHelp());
+    program3.addOption(new Option("--hard-fail", "Crash on logError calls instead of silently logging").hideHelp());
   }
   profileCheckpoint("run_main_options_built");
   const isPrintMode = process.argv.includes("-p") || process.argv.includes("--print");
   const isCcUrl = process.argv.some((a5) => a5.startsWith("cc://") || a5.startsWith("cc+unix://"));
   if (isPrintMode && !isCcUrl) {
     profileCheckpoint("run_before_parse");
-    await program2.parseAsync(process.argv);
+    await program3.parseAsync(process.argv);
     profileCheckpoint("run_after_parse");
-    return program2;
+    return program3;
   }
-  const mcp2 = program2.command("mcp").description("Configure and manage MCP servers").configureHelp(createSortedHelpConfig()).enablePositionalOptions();
+  const mcp2 = program3.command("mcp").description("Configure and manage MCP servers").configureHelp(createSortedHelpConfig()).enablePositionalOptions();
   mcp2.command("serve").description(`Start the Claude Code MCP server`).option("-d, --debug", "Enable debug mode", () => true).option("--verbose", "Override verbose mode setting from config", () => true).action(async ({
     debug: debug5,
     verbose
@@ -742168,7 +743342,7 @@ Usage: claude --remote "your task description"`, () => gracefulShutdown(1));
     await mcpResetChoicesHandler2();
   });
   if (feature("DIRECT_CONNECT")) {
-    program2.command("server").description("Start a Claude Code session server").option("--port <number>", "HTTP port", "0").option("--host <string>", "Bind address", "0.0.0.0").option("--auth-token <token>", "Bearer token for auth").option("--unix <path>", "Listen on a unix domain socket").option("--workspace <dir>", "Default working directory for sessions that do not specify cwd").option("--idle-timeout <ms>", "Idle timeout for detached sessions in ms (0 = never expire)", "600000").option("--max-sessions <n>", "Maximum concurrent sessions (0 = unlimited)", "32").action(async (opts) => {
+    program3.command("server").description("Start a Claude Code session server").option("--port <number>", "HTTP port", "0").option("--host <string>", "Bind address", "0.0.0.0").option("--auth-token <token>", "Bearer token for auth").option("--unix <path>", "Listen on a unix domain socket").option("--workspace <dir>", "Default working directory for sessions that do not specify cwd").option("--idle-timeout <ms>", "Idle timeout for detached sessions in ms (0 = never expire)", "600000").option("--max-sessions <n>", "Maximum concurrent sessions (0 = unlimited)", "32").action(async (opts) => {
       const {
         randomBytes: randomBytes20
       } = await import("crypto");
@@ -742239,7 +743413,7 @@ Usage: claude --remote "your task description"`, () => gracefulShutdown(1));
     });
   }
   if (feature("SSH_REMOTE")) {
-    program2.command("ssh <host> [dir]").description("Run Claude Code on a remote host over SSH. Deploys the binary and " + "tunnels API auth back through your local machine \u2014 no remote setup needed.").option("--permission-mode <mode>", "Permission mode for the remote session").option("--dangerously-skip-permissions", "Skip all permission prompts on the remote (dangerous)").option("--local", "e2e test mode \u2014 spawn the child CLI locally (skip ssh/deploy). " + "Exercises the auth proxy and unix-socket plumbing without a remote host.").action(async () => {
+    program3.command("ssh <host> [dir]").description("Run Claude Code on a remote host over SSH. Deploys the binary and " + "tunnels API auth back through your local machine \u2014 no remote setup needed.").option("--permission-mode <mode>", "Permission mode for the remote session").option("--dangerously-skip-permissions", "Skip all permission prompts on the remote (dangerous)").option("--local", "e2e test mode \u2014 spawn the child CLI locally (skip ssh/deploy). " + "Exercises the auth proxy and unix-socket plumbing without a remote host.").action(async () => {
       process.stderr.write(`Usage: claude ssh <user@host | ssh-config-alias> [dir]
 
 Runs Claude Code on a remote Linux host. You don't need to install
@@ -742249,7 +743423,7 @@ Runs Claude Code on a remote Linux host. You don't need to install
     });
   }
   if (feature("DIRECT_CONNECT")) {
-    program2.command("open <cc-url>").description("Connect to a Claude Code server (internal \u2014 use cc:// URLs)").option("-p, --print [prompt]", "Print mode (headless)").option("--output-format <format>", "Output format: text, json, stream-json", "text").action(async (ccUrl, opts, _command) => {
+    program3.command("open <cc-url>").description("Connect to a Claude Code server (internal \u2014 use cc:// URLs)").option("-p, --print [prompt]", "Print mode (headless)").option("--output-format <format>", "Output format: text, json, stream-json", "text").action(async (ccUrl, opts, _command) => {
       const {
         parseConnectUrl: parseConnectUrl2
       } = await Promise.resolve().then(() => (init_parseConnectUrl(), exports_parseConnectUrl));
@@ -742283,7 +743457,7 @@ Runs Claude Code on a remote Linux host. You don't need to install
       await runConnectHeadless2(connectConfig, prompt, opts.outputFormat, interactive);
     });
   }
-  const auth6 = program2.command("auth").description("Manage authentication").configureHelp(createSortedHelpConfig());
+  const auth6 = program3.command("auth").description("Manage authentication").configureHelp(createSortedHelpConfig());
   auth6.command("login").description("Sign in to your Anthropic account").option("--email <email>", "Pre-populate email address on the login page").option("--sso", "Force SSO login flow").option("--console", "Use Anthropic Console (API usage billing) instead of Claude subscription").option("--claudeai", "Use Claude subscription (default)").action(async ({
     email: email3,
     sso,
@@ -742312,8 +743486,76 @@ Runs Claude Code on a remote Linux host. You don't need to install
     } = await Promise.resolve().then(() => (init_auth10(), exports_auth2));
     await authLogout2();
   });
+  const daemonCmd = program3.command("daemon").description("Manage the background-agent daemon (supervisor + workers)").configureHelp(createSortedHelpConfig());
+  daemonCmd.command("start", { isDefault: true }).description("Start the supervisor (default)").allowUnknownOption().action(async () => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("start", []);
+  });
+  daemonCmd.command("stop").description("Stop the supervisor").option("--any, -a", "Displace any holder (force)").allowUnknownOption().action(async (opts) => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    const any3 = !!(opts.any || opts.a);
+    await daemonSubcommand2("stop", any3 ? ["--any"] : []);
+  });
+  daemonCmd.command("restart").description("Restart the supervisor").action(async () => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("restart", []);
+  });
+  daemonCmd.command("status").description("Show supervisor + worker status").action(async () => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("status", []);
+  });
+  daemonCmd.command("logs").description("Tail the daemon log").action(async () => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("logs", []);
+  });
+  daemonCmd.command("install").description("Install a persistent service (launchd/systemd)").action(async () => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("install", []);
+  });
+  daemonCmd.command("uninstall").description("Remove the persistent service").action(async () => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("uninstall", []);
+  });
+  const daemonScheduled = daemonCmd.command("scheduled").description("Manage scheduled daemon tasks").configureHelp(createSortedHelpConfig());
+  daemonScheduled.command("add <task-id>").description("Add a scheduled task").option("--schedule <cron>", "Cron schedule (default: 0 * * * *)").option("--prompt <text>", "Prompt to dispatch when the task fires").action(async (taskId, opts) => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    const args = ["add", taskId];
+    if (opts.schedule)
+      args.push("--schedule", opts.schedule);
+    if (opts.prompt)
+      args.push("--prompt", opts.prompt);
+    await daemonSubcommand2("scheduled", args);
+  });
+  daemonScheduled.command("remove <task-id>").alias("rm").description("Remove a scheduled task").action(async (taskId) => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("scheduled", ["remove", taskId]);
+  });
+  daemonScheduled.command("list").description("List scheduled tasks").action(async () => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("scheduled", ["list"]);
+  });
+  daemonCmd.command("remote-control").description("Configure the remote-control daemon worker").action(async () => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("remote-control", []);
+  });
+  daemonCmd.command("hub").description("Interactive daemon hub (TTY)").action(async () => {
+    const { daemonSubcommand: daemonSubcommand2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await daemonSubcommand2("hub", []);
+  });
+  program3.command("stop <id>").description("Stop a background session").action(async (id) => {
+    const { stopHandler: stopHandler2 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await stopHandler2(id);
+  });
+  program3.command("attach <id>").description("Open/join the background session").action(async (id) => {
+    const { attachHandler: attachHandler3 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await attachHandler3(id);
+  });
+  program3.command("logs <id>").description("Print the background session log").action(async (id) => {
+    const { logsHandler: logsHandler3 } = await Promise.resolve().then(() => (init_daemon(), exports_daemon));
+    await logsHandler3(id);
+  });
   const coworkOption = () => new Option("--cowork", "Use cowork_plugins directory").hideHelp();
-  const pluginCmd = program2.command("plugin").alias("plugins").description("Manage Claude Code plugins").configureHelp(createSortedHelpConfig());
+  const pluginCmd = program3.command("plugin").alias("plugins").description("Manage Claude Code plugins").configureHelp(createSortedHelpConfig());
   pluginCmd.command("validate <path>").description("Validate a plugin or marketplace manifest").addOption(coworkOption()).action(async (manifestPath, options) => {
     const {
       pluginValidateHandler: pluginValidateHandler2
@@ -742381,7 +743623,7 @@ Runs Claude Code on a remote Linux host. You don't need to install
     } = await Promise.resolve().then(() => (init_plugins(), exports_plugins));
     await pluginUpdateHandler2(plugin2, options);
   });
-  program2.command("setup-token").description("Set up a long-lived authentication token (requires Claude subscription)").action(async () => {
+  program3.command("setup-token").description("Set up a long-lived authentication token (requires Claude subscription)").action(async () => {
     const [{
       setupTokenHandler: setupTokenHandler2
     }, {
@@ -742390,14 +743632,14 @@ Runs Claude Code on a remote Linux host. You don't need to install
     const root3 = await createRoot3(getBaseRenderOptions(false));
     await setupTokenHandler2(root3);
   });
-  program2.command("agents").description("List configured agents").option("--setting-sources <sources>", "Comma-separated list of setting sources to load (user, project, local).").action(async () => {
+  program3.command("agents").description("List configured agents").option("--setting-sources <sources>", "Comma-separated list of setting sources to load (user, project, local).").action(async () => {
     const {
       agentsHandler: agentsHandler2
     } = await Promise.resolve().then(() => (init_agents2(), exports_agents2));
     await agentsHandler2();
     process.exit(0);
   });
-  const projectCmd = program2.command("project").description("Manage Claude Code project state").configureHelp(createSortedHelpConfig());
+  const projectCmd = program3.command("project").description("Manage Claude Code project state").configureHelp(createSortedHelpConfig());
   projectCmd.command("purge [path]").description("Delete all Claude Code state for a project (transcripts, tasks, file history, config entry)").option("--dry-run", "List what would be deleted without deleting").option("--all", "Purge state for every project (mutually exclusive with [path])").option("-i, --interactive", "Interactively select a project to purge").action(async (path32, options) => {
     const {
       purgeProjectHandler: purgeProjectHandler2
@@ -742405,7 +743647,7 @@ Runs Claude Code on a remote Linux host. You don't need to install
     await purgeProjectHandler2(path32, options);
     process.exit(0);
   });
-  program2.command("ultrareview [target]").description("Run a cloud-hosted multi-agent code review of the current branch (or a PR number / base branch) and print the findings").option("--json", "Print the raw bugs.json payload instead of formatted findings").option("--timeout <minutes>", "Maximum minutes to wait for the review to finish (default: 30)").action(async (target, options) => {
+  program3.command("ultrareview [target]").description("Run a cloud-hosted multi-agent code review of the current branch (or a PR number / base branch) and print the findings").option("--json", "Print the raw bugs.json payload instead of formatted findings").option("--timeout <minutes>", "Maximum minutes to wait for the review to finish (default: 30)").action(async (target, options) => {
     const {
       ultrareviewHandler: ultrareviewHandler2
     } = await Promise.resolve().then(() => (init_ultrareview(), exports_ultrareview));
@@ -742414,7 +743656,7 @@ Runs Claude Code on a remote Linux host. You don't need to install
   });
   if (feature("TRANSCRIPT_CLASSIFIER")) {
     if (getAutoModeEnabledStateIfCached() !== "disabled") {
-      const autoModeCmd = program2.command("auto-mode").description("Inspect auto mode classifier configuration");
+      const autoModeCmd = program3.command("auto-mode").description("Inspect auto mode classifier configuration");
       autoModeCmd.command("defaults").description("Print the default auto mode environment, allow, and deny rules as JSON").action(async () => {
         const {
           autoModeDefaultsHandler: autoModeDefaultsHandler2
@@ -742439,7 +743681,7 @@ Runs Claude Code on a remote Linux host. You don't need to install
     }
   }
   if (feature("BRIDGE_MODE")) {
-    program2.command("remote-control", {
+    program3.command("remote-control", {
       hidden: true
     }).alias("rc").description("Connect your local environment for remote-control sessions via claude.ai/code").action(async () => {
       const {
@@ -742449,7 +743691,7 @@ Runs Claude Code on a remote Linux host. You don't need to install
     });
   }
   if (feature("KAIROS")) {
-    program2.command("assistant [sessionId]").description("Attach the REPL as a client to a running bridge session. Discovers sessions via API if no sessionId given.").action(() => {
+    program3.command("assistant [sessionId]").description("Attach the REPL as a client to a running bridge session. Discovers sessions via API if no sessionId given.").action(() => {
       process.stderr.write(`Usage: claude assistant [sessionId]
 
 Attach the REPL as a viewer client to a running bridge session.
@@ -742458,7 +743700,7 @@ Omit sessionId to discover and pick from available sessions.
       process.exit(1);
     });
   }
-  program2.command("doctor").description("Check the health of your Claude Code auto-updater. Note: The workspace trust dialog is skipped and stdio servers from .mcp.json are spawned for health checks. Only use this command in directories you trust.").action(async () => {
+  program3.command("doctor").description("Check the health of your Claude Code auto-updater. Note: The workspace trust dialog is skipped and stdio servers from .mcp.json are spawned for health checks. Only use this command in directories you trust.").action(async () => {
     const [{
       doctorHandler: doctorHandler2
     }, {
@@ -742467,7 +743709,7 @@ Omit sessionId to discover and pick from available sessions.
     const root3 = await createRoot3(getBaseRenderOptions(false));
     await doctorHandler2(root3);
   });
-  program2.command("update").alias("upgrade").description("Check for updates and install if available").action(async () => {
+  program3.command("update").alias("upgrade").description("Check for updates and install if available").action(async () => {
     const {
       update: update2
     } = await Promise.resolve().then(() => (init_update(), exports_update));
@@ -742475,7 +743717,7 @@ Omit sessionId to discover and pick from available sessions.
   });
   if (false) {}
   if (false) {}
-  program2.command("install [target]").description("Install Claude Code native build. Use [target] to specify version (stable, latest, or specific version)").option("--force", "Force installation even if already installed").action(async (target, options) => {
+  program3.command("install [target]").description("Install Claude Code native build. Use [target] to specify version (stable, latest, or specific version)").option("--force", "Force installation even if already installed").action(async (target, options) => {
     const {
       installHandler: installHandler2
     } = await Promise.resolve().then(() => (init_util6(), exports_util2));
@@ -742483,11 +743725,11 @@ Omit sessionId to discover and pick from available sessions.
   });
   if (false) {}
   profileCheckpoint("run_before_parse");
-  await program2.parseAsync(process.argv);
+  await program3.parseAsync(process.argv);
   profileCheckpoint("run_after_parse");
   profileCheckpoint("main_after_run");
   profileReport();
-  return program2;
+  return program3;
 }
 async function logTenguInit({
   hasInitialPrompt,