@linzumi/cli 0.0.84-beta → 0.0.86-beta

package/dist/index.js

@@ -39,6 +39,70 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/onboardingPlaceResponsiveness.ts
+import { Worker } from "node:worker_threads";
+function isPlaceResponsive(path2, deps = {}) {
+  const timeoutMs = deps.timeoutMs ?? defaultPlaceProbeTimeoutMs;
+  if (deps.probe !== void 0) {
+    return deps.probe(path2, timeoutMs);
+  }
+  return statProbe(path2, timeoutMs);
+}
+function statProbe(path2, timeoutMs) {
+  const sharedBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
+  const status = new Int32Array(sharedBuffer);
+  Atomics.store(status, 0, probeStatusPending);
+  let worker;
+  try {
+    worker = new Worker(probeWorkerSource, {
+      eval: true,
+      workerData: { sharedBuffer, path: path2 }
+    });
+  } catch {
+    return true;
+  }
+  worker.unref();
+  worker.on("error", () => {
+    if (Atomics.load(status, 0) === probeStatusPending) {
+      Atomics.store(status, 0, probeStatusUnresponsive);
+      Atomics.notify(status, 0);
+    }
+  });
+  Atomics.wait(status, 0, probeStatusPending, timeoutMs);
+  const result = Atomics.load(status, 0);
+  void worker.terminate().catch(() => {
+  });
+  return result === probeStatusResponsive;
+}
+var defaultPlaceProbeTimeoutMs, probeStatusPending, probeStatusResponsive, probeStatusUnresponsive, probeWorkerSource;
+var init_onboardingPlaceResponsiveness = __esm({
+  "src/onboardingPlaceResponsiveness.ts"() {
+    "use strict";
+    defaultPlaceProbeTimeoutMs = 1e3;
+    probeStatusPending = 0;
+    probeStatusResponsive = 1;
+    probeStatusUnresponsive = 2;
+    probeWorkerSource = `
+const { workerData, parentPort } = require('node:worker_threads');
+const { statSync } = require('node:fs');
+const status = new Int32Array(workerData.sharedBuffer);
+let result = ${probeStatusUnresponsive};
+try {
+  statSync(workerData.path);
+  result = ${probeStatusResponsive};
+} catch {
+  // A path that throws quickly (ENOENT/EACCES/ENOTDIR) is still a *responsive*
+  // volume - discovery's own existence checks will handle it. Only a wedged
+  // syscall (which never returns here) counts as unresponsive.
+  result = ${probeStatusResponsive};
+}
+Atomics.store(status, 0, result);
+Atomics.notify(status, 0);
+if (parentPort) parentPort.postMessage(result);
+`;
+  }
+});
+
 // src/onboardingProjectDiscovery.ts
 var onboardingProjectDiscovery_exports = {};
 __export(onboardingProjectDiscovery_exports, {
@@ -50,10 +114,12 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 function discoverCurrentGitProject(args) {
   const startedAtMs = args.nowMs ?? Date.now();
+  const responsiveness = args.placeResponsiveness;
   const candidates = /* @__PURE__ */ new Map();
   const searchStats = [];
+  const cwdResponsive = isPlaceResponsive(args.cwd, responsiveness);
   const gitStartedAtMs = Date.now();
-  const topLevel = gitOutput(args.cwd, ["rev-parse", "--show-toplevel"]);
+  const topLevel = cwdResponsive ? gitOutput(args.cwd, ["rev-parse", "--show-toplevel"]) : void 0;
   const gitDurationMs = Date.now() - gitStartedAtMs;
   if (topLevel !== void 0) {
     mergeCandidate(
@@ -65,12 +131,28 @@ function discoverCurrentGitProject(args) {
     place: args.cwd,
     source: "git",
     duration_ms: gitDurationMs,
-    result_count: topLevel === void 0 ? 0 : 1
+    result_count: topLevel === void 0 ? 0 : 1,
+    skipped_unresponsive: cwdResponsive ? void 0 : true
   });
   const sourceRoots = args.sourceRoots ?? defaultLocalProjectSourceRoots(args.cwd);
   let placesSearched = 1;
   for (const sourceRoot of sourceRoots) {
     const sourceRootStartedAtMs = Date.now();
+    const rootResponsive = isPlaceResponsive(sourceRoot, responsiveness);
+    if (!rootResponsive) {
+      searchStats.push({
+        place: sourceRoot,
+        source: "git",
+        duration_ms: Date.now() - sourceRootStartedAtMs,
+        result_count: 0,
+        skipped_unresponsive: true
+      });
+      placesSearched += 1;
+      continue;
+    }
+    if (!isDirectory(sourceRoot)) {
+      continue;
+    }
     const foundInRoot = discoverGitWorktreesInSourceRoot(sourceRoot);
     for (const worktreePath of foundInRoot) {
       mergeCandidate(
@@ -218,7 +300,7 @@ function defaultLocalProjectSourceRoots(cwd) {
     ...ancestorSourceRoots(cwd),
     ...homeSourceRoots(),
     ...externalVolumeSourceRoots()
-  ]).filter(isDirectory);
+  ]);
 }
 function ancestorSourceRoots(cwd) {
   const sourceRootNames = /* @__PURE__ */ new Set([
@@ -331,6 +413,7 @@ var worktreePathSampleLimit, gitSpawnTimeoutMs;
 var init_onboardingProjectDiscovery = __esm({
   "src/onboardingProjectDiscovery.ts"() {
     "use strict";
+    init_onboardingPlaceResponsiveness();
     worktreePathSampleLimit = 25;
     gitSpawnTimeoutMs = 4e3;
   }
@@ -6977,6 +7060,7 @@ function startPortForwardWatcher(options) {
   const scanProcessCwds = options.scanProcessCwds ?? readProcessCwdRows;
   const nowMs = options.nowMs ?? Date.now;
   const commanderBoundPids = validPidSet(options.commanderBoundPids ?? []);
+  const commanderBoundPorts = validPortSet(options.commanderBoundPorts ?? []);
   const candidateStabilityByPort = /* @__PURE__ */ new Map();
   const emittedByPort = /* @__PURE__ */ new Map();
   const missingByPort = /* @__PURE__ */ new Map();
@@ -6990,12 +7074,15 @@ function startPortForwardWatcher(options) {
       const descendants = descendantPidSet(scanProcesses(), rootPid);
       const sockets = scanListenSockets();
       const observedPids = /* @__PURE__ */ new Set([...descendants, ...commanderBoundPids]);
-      const candidatePids = sockets.filter((socket) => observedPids.has(socket.pid)).map((socket) => socket.pid);
+      const candidatePids = sockets.filter(
+        (socket) => observedPids.has(socket.pid) || commanderBoundPorts.has(socket.port)
+      ).map((socket) => socket.pid);
       const candidates = detectedForwardCandidates(
         sockets,
         observedPids,
         scanProcessCwds(candidatePids),
-        commanderBoundPids
+        commanderBoundPids,
+        commanderBoundPorts
       );
       const scanTimeMs = nowMs();
       const stable = stableForwardCandidates(
@@ -7113,10 +7200,12 @@ function descendantPidSet(rows, rootPid) {
   }
   return descendants;
 }
-function detectedForwardCandidates(sockets, descendantPids, processCwds = /* @__PURE__ */ new Map(), commanderBoundPids = /* @__PURE__ */ new Set()) {
-  return sockets.filter((socket) => descendantPids.has(socket.pid)).filter((socket) => socket.port > 0 && socket.port < 65536).sort((left, right) => left.port - right.port).map((socket) => {
+function detectedForwardCandidates(sockets, descendantPids, processCwds = /* @__PURE__ */ new Map(), commanderBoundPids = /* @__PURE__ */ new Set(), commanderBoundPorts = /* @__PURE__ */ new Set()) {
+  return sockets.filter(
+    (socket) => descendantPids.has(socket.pid) || commanderBoundPorts.has(socket.port)
+  ).filter((socket) => socket.port > 0 && socket.port < 65536).sort((left, right) => left.port - right.port).map((socket) => {
     const cwd = processCwds.get(socket.pid);
-    const portKind = commanderBoundPids.size === 0 ? void 0 : commanderBoundPids.has(socket.pid) ? "commander_bound" : "descendant";
+    const portKind = commanderBoundPids.size === 0 && commanderBoundPorts.size === 0 ? void 0 : commanderBoundPids.has(socket.pid) || commanderBoundPorts.has(socket.port) ? "commander_bound" : "descendant";
     return {
       port: socket.port,
       pid: socket.pid,
@@ -7129,6 +7218,11 @@ function detectedForwardCandidates(sockets, descendantPids, processCwds = /* @__
 function validPidSet(pids) {
   return new Set(pids.filter((pid) => Number.isInteger(pid) && pid > 0));
 }
+function validPortSet(ports) {
+  return new Set(
+    ports.filter((port) => Number.isInteger(port) && port > 0 && port < 65536)
+  );
+}
 function normalizedPortKind(portKind) {
   return portKind ?? "descendant";
 }
@@ -9822,7 +9916,11 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
       seq: event.seq,
       actor_slug: event.actorSlug ?? null,
       actor_user_id: event.actorUserId ?? null,
-      reason: "different_thread"
+      reason: "different_thread",
+      thread_id: event.threadId ?? null,
+      bound_thread_id: state.kandanThreadId ?? null,
+      codex_thread_id: state.codexThreadId ?? null,
+      body_preview: runnerConsoleBodyPreview(event.body)
     });
     return;
   }
@@ -11960,14 +12058,336 @@ var init_claudeCodePlanMirror = __esm({
   }
 });
 
+// src/runnerLogger.ts
+import { appendFileSync, openSync as openSync2 } from "node:fs";
+import { createWriteStream } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname3, join as join6 } from "node:path";
+import { mkdirSync as mkdirSync2 } from "node:fs";
+function createRunnerLogger(logFile, consoleReporter) {
+  mkdirSync2(dirname3(logFile), { recursive: true });
+  const fd = openSync2(logFile, "a");
+  const stream = createWriteStream("", { fd, flags: "a", autoClose: true });
+  const logger = ((event, payload) => {
+    const redacted = redactForCliLog(payload);
+    stream.write(
+      `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), event, ...redacted })}
+`,
+      "utf8"
+    );
+    consoleReporter?.(event, runnerConsolePayload(redacted, payload));
+  });
+  Object.defineProperty(logger, "close", {
+    value: () => closeStream(stream)
+  });
+  return logger;
+}
+function writeCliAuditEvent(event, payload, options = {}) {
+  const logFile = options.logFile ?? defaultCliAuditLogFile();
+  try {
+    mkdirSync2(dirname3(logFile), { recursive: true });
+    appendFileSync(
+      logFile,
+      `${JSON.stringify({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        event,
+        ...options.sessionId === void 0 ? {} : { sessionId: options.sessionId },
+        ...redactForCliLog(payload)
+      })}
+`,
+      "utf8"
+    );
+  } catch (_error) {
+    return;
+  }
+}
+function defaultCliAuditLogFile() {
+  const override = process.env.LINZUMI_CLI_AUDIT_LOG?.trim();
+  return override === void 0 || override === "" ? join6(homedir5(), ".linzumi", "logs", "command-events.jsonl") : override;
+}
+function defaultRunnerLogFile() {
+  return join6(homedir5(), ".linzumi", "logs", "linzumi-runner.log");
+}
+function redactForCliLog(value) {
+  return redactObject(value);
+}
+function redactValue(value, key) {
+  if (sensitiveKey(key)) {
+    return sensitiveMarker;
+  }
+  if (typeof value === "string") {
+    return redactString(value);
+  }
+  if (Array.isArray(value)) {
+    return key === "args" ? redactArgs(value) : value.map((item) => redactValue(item, void 0));
+  }
+  if (value !== null && typeof value === "object") {
+    return redactObject(value);
+  }
+  return value;
+}
+function redactObject(value) {
+  const headerName = typeof value.name === "string" ? value.name.toLowerCase() : void 0;
+  const shouldRedactHeaderValue = headerName === "authorization" || headerName === "cookie" || headerName === "set-cookie";
+  return Object.fromEntries(
+    Object.entries(value).filter(([key]) => key !== "runner_console").map(([key, entry]) => [
+      key,
+      shouldRedactHeaderValue && key === "value" ? sensitiveMarker : redactValue(entry, key)
+    ])
+  );
+}
+function runnerConsolePayload(redacted, original) {
+  const consoleFields = objectValue3(original.runner_console);
+  return consoleFields === void 0 ? redacted : { ...redacted, ...redactForCliLog(consoleFields) };
+}
+function objectValue3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function redactArgs(args) {
+  let redactNext = false;
+  return args.map((arg) => {
+    if (typeof arg !== "string") {
+      redactNext = false;
+      return redactValue(arg, void 0);
+    }
+    if (redactNext) {
+      redactNext = false;
+      return sensitiveMarker;
+    }
+    const [flag, value] = splitArgAssignment(arg);
+    if (sensitiveArgFlags.has(flag)) {
+      if (value === void 0) {
+        redactNext = true;
+        return arg;
+      }
+      return `${flag}=${sensitiveMarker}`;
+    }
+    return redactString(arg);
+  });
+}
+function splitArgAssignment(value) {
+  const index = value.indexOf("=");
+  return index === -1 ? [value, void 0] : [value.slice(0, index), value.slice(index + 1)];
+}
+function sensitiveKey(key) {
+  if (key === void 0) {
+    return false;
+  }
+  return /^(authorization|cookie|set-cookie|password)$/i.test(key) || /(^|[_-])(access[_-]?token|api[_-]?key|auth[_-]?token|oauth[_-]?code|refresh[_-]?token|secret|token)$/i.test(
+    key
+  );
+}
+function redactString(value) {
+  const withRedactedQuery = redactUrlQuery(value);
+  return withRedactedQuery.replace(
+    /\beyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g,
+    sensitiveMarker
+  );
+}
+function redactUrlQuery(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch (_error) {
+    return redactRelativeUrlQuery(value);
+  }
+  for (const name of [...parsed.searchParams.keys()]) {
+    if (sensitiveQueryParams.has(name.toLowerCase())) {
+      parsed.searchParams.set(name, sensitiveMarker);
+    }
+  }
+  return parsed.toString();
+}
+function redactRelativeUrlQuery(value) {
+  const queryStart = value.indexOf("?");
+  const hashStart = value.indexOf("#");
+  if (queryStart === -1 || hashStart !== -1 && hashStart < queryStart) {
+    return value;
+  }
+  const path2 = value.slice(0, queryStart);
+  const query = hashStart === -1 ? value.slice(queryStart + 1) : value.slice(queryStart + 1, hashStart);
+  const hash = hashStart === -1 ? "" : value.slice(hashStart);
+  const searchParams = new URLSearchParams(query);
+  let redacted = false;
+  for (const name of [...searchParams.keys()]) {
+    if (sensitiveQueryParams.has(name.toLowerCase())) {
+      searchParams.set(name, sensitiveMarker);
+      redacted = true;
+    }
+  }
+  switch (redacted) {
+    case true:
+      return `${path2}?${searchParams.toString()}${hash}`;
+    case false:
+      return value;
+  }
+}
+function closeStream(stream) {
+  if (stream.closed || stream.destroyed) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve12, reject) => {
+    stream.once("error", reject);
+    stream.end(resolve12);
+  });
+}
+var sensitiveMarker, sensitiveQueryParams, sensitiveArgFlags;
+var init_runnerLogger = __esm({
+  "src/runnerLogger.ts"() {
+    "use strict";
+    sensitiveMarker = "<SENSITIVE_DATA>";
+    sensitiveQueryParams = /* @__PURE__ */ new Set([
+      "access_token",
+      "authorization",
+      "code",
+      "cookie",
+      "kandan_preview_ticket",
+      "refresh_token",
+      "token"
+    ]);
+    sensitiveArgFlags = /* @__PURE__ */ new Set([
+      "--access-token",
+      "--api-key",
+      "--authorization",
+      "--cookie",
+      "--oauth-code",
+      "--password",
+      "--refresh-token",
+      "--secret",
+      "--token"
+    ]);
+  }
+});
+
+// src/engineChildReaper.ts
+function registerEngineChild(registration, _killProcess = process.kill) {
+  reaperState.children.add(registration);
+  ensureExitHandlersInstalled();
+  return {
+    unregister: () => {
+      reaperState.children.delete(registration);
+    }
+  };
+}
+function reapAllEngineChildren(killProcess = process.kill, reason = "exit") {
+  const children = [...reaperState.children];
+  reaperState.children.clear();
+  for (const child of children) {
+    reapEngineChild(child, killProcess, reason);
+  }
+}
+function reapEngineChild(child, killProcess, reason) {
+  try {
+    child.stop();
+  } catch (error) {
+    auditReapFailure(child, reason, "stop", error);
+  }
+  if (child.pid === void 0) {
+    return;
+  }
+  if (child.ownProcessGroup) {
+    try {
+      killProcess(-child.pid, reapSignal);
+      return;
+    } catch (error) {
+      if (processSignalErrorCode(error) === "ESRCH") {
+        return;
+      }
+      auditReapFailure(child, reason, "group_kill", error);
+    }
+  }
+  try {
+    killProcess(child.pid, reapSignal);
+  } catch (error) {
+    if (processSignalErrorCode(error) === "ESRCH") {
+      return;
+    }
+    auditReapFailure(child, reason, "pid_kill", error);
+  }
+}
+function ensureExitHandlersInstalled() {
+  if (reaperState.handlersInstalled) {
+    return;
+  }
+  reaperState.handlersInstalled = true;
+  const onExit2 = () => {
+    reapAllEngineChildren(process.kill, "process_exit");
+  };
+  process.on("exit", onExit2);
+  const ownsUncaught = process.listenerCount("uncaughtException") === 0;
+  const ownsRejection = process.listenerCount("unhandledRejection") === 0;
+  const onUncaughtException = (error) => {
+    reapAllEngineChildren(process.kill, "uncaught_exception");
+    process.stderr.write(
+      `linzumi runner uncaughtException: ${error instanceof Error ? error.stack ?? error.message : String(error)}
+`
+    );
+    process.exit(1);
+  };
+  const onUnhandledRejection = (reason) => {
+    reapAllEngineChildren(process.kill, "unhandled_rejection");
+    process.stderr.write(
+      `linzumi runner unhandledRejection: ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}
+`
+    );
+    process.exit(1);
+  };
+  if (ownsUncaught) {
+    process.on("uncaughtException", onUncaughtException);
+  }
+  if (ownsRejection) {
+    process.on("unhandledRejection", onUnhandledRejection);
+  }
+  reaperState.removeHandlers = () => {
+    process.off("exit", onExit2);
+    if (ownsUncaught) {
+      process.off("uncaughtException", onUncaughtException);
+    }
+    if (ownsRejection) {
+      process.off("unhandledRejection", onUnhandledRejection);
+    }
+  };
+}
+function auditReapFailure(child, reason, stage, error) {
+  writeCliAuditEvent("process.reap_failed", {
+    purpose: child.kind,
+    pid: child.pid ?? null,
+    ownProcessGroup: child.ownProcessGroup,
+    reason,
+    stage,
+    code: processSignalErrorCode(error) ?? null,
+    message: error instanceof Error ? error.message : String(error)
+  });
+}
+function processSignalErrorCode(error) {
+  if (error !== null && typeof error === "object" && "code" in error) {
+    const code = error.code;
+    return typeof code === "string" ? code : void 0;
+  }
+  return void 0;
+}
+var reaperState, reapSignal;
+var init_engineChildReaper = __esm({
+  "src/engineChildReaper.ts"() {
+    "use strict";
+    init_runnerLogger();
+    reaperState = {
+      children: /* @__PURE__ */ new Set(),
+      handlersInstalled: false,
+      removeHandlers: void 0
+    };
+    reapSignal = "SIGKILL";
+  }
+});
+
 // src/claudeCodeLiveBashOutput.ts
 import {
-  mkdirSync as mkdirSync2,
+  mkdirSync as mkdirSync3,
   rmSync,
   writeFileSync,
   promises as fsPromises
 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function shellSingleQuoted(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
@@ -12092,12 +12512,12 @@ function createClaudeCodeLiveBashCapture(host) {
     isClaudeLiveBashWrappedCommand(command)) {
       return void 0;
     }
-    const file = join6(
+    const file = join7(
       host.captureDir,
       `${toolUseId.replaceAll(/[^\w-]/g, "_")}.out`
     );
     try {
-      mkdirSync2(host.captureDir, { recursive: true });
+      mkdirSync3(host.captureDir, { recursive: true });
       writeFileSync(file, "");
     } catch (error) {
       host.log?.("claude_live_bash.capture_file_failed", {
@@ -12179,8 +12599,8 @@ var init_claudeCodeLiveBashOutput = __esm({
 
 // src/claudeCodeSession.ts
 import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join7 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { join as join8 } from "node:path";
 function claudeCodeSettingSources() {
   return ["user", "project", "local"];
 }
@@ -12324,7 +12744,7 @@ function claudeCodeRateLimitSummaryText(rateLimit, nowMs) {
 async function probeClaudeCodeAvailability(args) {
   if (!hasClaudeCodeAuthHint(process.env, {
     cwd: args.cwd,
-    homeDir: homedir5(),
+    homeDir: homedir6(),
     platform: process.platform,
     fileExists: existsSync4,
     readTextFile: readTextFileIfPresent
@@ -12357,7 +12777,7 @@ async function probeClaudeCodeAvailability(args) {
   }
 }
 function hasClaudeCodeAuthHint(env, deps) {
-  const configDir = env.CLAUDE_CONFIG_DIR ?? join7(deps.homeDir, ".claude");
+  const configDir = env.CLAUDE_CONFIG_DIR ?? join8(deps.homeDir, ".claude");
   return hasAnthropicCredentialEnv(env) || hasClaudeCloudProviderEnv(env) || hasClaudeCodeFileCredential(configDir, deps) || hasClaudeCodeApiKeyHelper(configDir, deps) || hasMacClaudeCodeKeychainAnchor(deps);
 }
 function claudeCodePolicyDeferHooks() {
@@ -12392,14 +12812,14 @@ function hasClaudeCloudProviderEnv(env) {
   return trueishEnv(env.CLAUDE_CODE_USE_BEDROCK) || trueishEnv(env.CLAUDE_CODE_USE_VERTEX) || trueishEnv(env.CLAUDE_CODE_USE_FOUNDRY) || trueishEnv(env.CLAUDE_CODE_USE_ANTHROPIC_AWS) || trueishEnv(env.CLAUDE_CODE_USE_MANTLE);
 }
 function hasClaudeCodeFileCredential(configDir, deps) {
-  return deps.fileExists(join7(configDir, ".credentials.json")) || deps.fileExists(join7(configDir, ".claude.json")) || deps.fileExists(join7(deps.homeDir, ".claude.json"));
+  return deps.fileExists(join8(configDir, ".credentials.json")) || deps.fileExists(join8(configDir, ".claude.json")) || deps.fileExists(join8(deps.homeDir, ".claude.json"));
 }
 function hasClaudeCodeApiKeyHelper(configDir, deps) {
   return [
-    join7(configDir, "settings.json"),
-    join7(configDir, "settings.local.json"),
-    join7(deps.cwd, ".claude", "settings.json"),
-    join7(deps.cwd, ".claude", "settings.local.json")
+    join8(configDir, "settings.json"),
+    join8(configDir, "settings.local.json"),
+    join8(deps.cwd, ".claude", "settings.json"),
+    join8(deps.cwd, ".claude", "settings.local.json")
   ].some((path2) => settingsFileHasApiKeyHelper(path2, deps));
 }
 function settingsFileHasApiKeyHelper(path2, deps) {
@@ -12419,9 +12839,9 @@ function hasMacClaudeCodeKeychainAnchor(deps) {
     return false;
   }
   return [
-    join7(deps.homeDir, "Library", "Application Support", "claude-cli-nodejs"),
-    join7(deps.homeDir, "Library", "Application Support", "Claude"),
-    join7(deps.homeDir, "Library", "Preferences", "claude-cli-nodejs")
+    join8(deps.homeDir, "Library", "Application Support", "claude-cli-nodejs"),
+    join8(deps.homeDir, "Library", "Application Support", "Claude"),
+    join8(deps.homeDir, "Library", "Preferences", "claude-cli-nodejs")
   ].some((path2) => deps.fileExists(path2));
 }
 function readTextFileIfPresent(path2) {
@@ -12440,87 +12860,83 @@ async function startClaudeCodeSession(options) {
     assistantTextByKey: /* @__PURE__ */ new Map(),
     usage: void 0,
     startedSessionIds: /* @__PURE__ */ new Set(),
-    completedTurnCount: 0
+    completedTurnCount: 0,
+    lastCompletedTurnBody: void 0
   };
   const streamUsageTracker = createClaudeCodeStreamUsageTracker();
-  for await (const message of runner(options)) {
-    state.sessionId = state.sessionId ?? extractClaudeSessionId(message);
-    const sessionId = extractClaudeSessionId(message) ?? state.sessionId;
-    if (sessionId !== void 0 && !state.startedSessionIds.has(sessionId)) {
-      state.startedSessionIds.add(sessionId);
-      await options.onTranscriptEvent?.({ type: "session_started", sessionId });
-    }
-    for (const event of transcriptEventsForClaudeMessage(
-      message,
-      sessionId,
-      streamUsageTracker
-    )) {
-      if (event.type === "assistant_message") {
-        recordClaudeAssistantAggregate(state, event);
-      }
-      if (event.type === "usage") {
-        state.usage = event.usage;
-      }
-      await options.onTranscriptEvent?.(event);
-    }
-    const resultOutcome = extractClaudeResultOutcome(message);
-    switch (resultOutcome.type) {
-      case "success": {
-        if (resultOutcome.text !== void 0) {
-          state.resultText = resultOutcome.text;
-        }
-        state.usage = extractClaudeUsage(message) ?? state.usage;
-        state.completedTurnCount += 1;
-        const queuedTurnCountBeforeTranscript = options.streamingInput === void 0 ? void 0 : options.streamingInput.queuedTurnCount();
-        if (options.streamingInput !== void 0) {
-          await emitClaudeCodeTurnCompleted(options, state);
-        }
-        if (options.streamingInput !== void 0 && queuedTurnCountBeforeTranscript !== void 0 && state.completedTurnCount >= Math.max(
-          queuedTurnCountBeforeTranscript,
-          options.streamingInput.queuedTurnCount()
-        )) {
-          options.streamingInput.close();
-          return completeClaudeCodeSession(options, state);
-        }
-        if (options.streamingInput !== void 0) {
-          await options.onTurnCompleted?.();
-          resetClaudeAssistantAggregate(state);
-          state.resultText = void 0;
+  try {
+    for await (const message of runner(options)) {
+      state.sessionId = state.sessionId ?? extractClaudeSessionId(message);
+      const sessionId = extractClaudeSessionId(message) ?? state.sessionId;
+      if (sessionId !== void 0 && !state.startedSessionIds.has(sessionId)) {
+        state.startedSessionIds.add(sessionId);
+        await options.onTranscriptEvent?.({
+          type: "session_started",
+          sessionId
+        });
+      }
+      for (const event of transcriptEventsForClaudeMessage(
+        message,
+        sessionId,
+        streamUsageTracker
+      )) {
+        if (event.type === "assistant_message") {
+          recordClaudeAssistantAggregate(state, event);
         }
-        break;
+        if (event.type === "usage") {
+          state.usage = event.usage;
+        }
+        await options.onTranscriptEvent?.(event);
       }
-      case "interrupted": {
-        state.completedTurnCount += 1;
-        if (state.sessionId !== void 0) {
-          await options.onTranscriptEvent?.({
-            type: "turn_interrupted",
-            sessionId: state.sessionId
-          });
+      const resultOutcome = extractClaudeResultOutcome(message);
+      switch (resultOutcome.type) {
+        case "success": {
+          if (resultOutcome.text !== void 0) {
+            state.resultText = resultOutcome.text;
+          }
+          state.usage = extractClaudeUsage(message) ?? state.usage;
+          state.completedTurnCount += 1;
+          if (options.streamingInput !== void 0) {
+            await emitClaudeCodeTurnCompleted(options, state);
+            state.lastCompletedTurnBody = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state)) ?? "";
+            await options.onTurnCompleted?.();
+            resetClaudeAssistantAggregate(state);
+            state.resultText = void 0;
+          }
+          break;
         }
-        if (options.streamingInput !== void 0) {
-          await options.onTurnCompleted?.();
-          resetClaudeAssistantAggregate(state);
-          state.resultText = void 0;
+        case "interrupted": {
+          state.completedTurnCount += 1;
+          if (state.sessionId !== void 0) {
+            await options.onTranscriptEvent?.({
+              type: "turn_interrupted",
+              sessionId: state.sessionId
+            });
+          }
+          if (options.streamingInput !== void 0) {
+            await options.onTurnCompleted?.();
+            resetClaudeAssistantAggregate(state);
+            state.resultText = void 0;
+          }
+          break;
         }
-        break;
+        case "error":
+          return await failClaudeCodeSession(
+            options,
+            state.sessionId,
+            `Claude Code failed: ${resultOutcome.reason}`
+          );
+        case "none":
+          break;
       }
-      case "error":
-        return await failClaudeCodeSession(
-          options,
-          state.sessionId,
-          `Claude Code failed: ${resultOutcome.reason}`
-        );
-      case "none":
-        break;
     }
+  } finally {
+    options.streamingInput?.close();
   }
   return completeClaudeCodeSession(options, state);
 }
 async function emitClaudeCodeTurnCompleted(options, state) {
-  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state));
-  if (body === void 0) {
-    return;
-  }
+  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state)) ?? "";
   if (state.sessionId === void 0) {
     return;
   }
@@ -12532,7 +12948,7 @@ async function emitClaudeCodeTurnCompleted(options, state) {
   });
 }
 async function completeClaudeCodeSession(options, state) {
-  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state));
+  const body = state.resultText ?? nonEmptyText(claudeAssistantAggregateText(state)) ?? state.lastCompletedTurnBody;
   if (body === void 0) {
     return await failClaudeCodeSession(
       options,
@@ -13076,207 +13492,6 @@ var init_claudeCodeSession = __esm({
   }
 });
 
-// src/runnerLogger.ts
-import { appendFileSync, openSync as openSync2 } from "node:fs";
-import { createWriteStream } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { dirname as dirname3, join as join8 } from "node:path";
-import { mkdirSync as mkdirSync3 } from "node:fs";
-function createRunnerLogger(logFile, consoleReporter) {
-  mkdirSync3(dirname3(logFile), { recursive: true });
-  const fd = openSync2(logFile, "a");
-  const stream = createWriteStream("", { fd, flags: "a", autoClose: true });
-  const logger = ((event, payload) => {
-    const redacted = redactForCliLog(payload);
-    stream.write(
-      `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), event, ...redacted })}
-`,
-      "utf8"
-    );
-    consoleReporter?.(event, runnerConsolePayload(redacted, payload));
-  });
-  Object.defineProperty(logger, "close", {
-    value: () => closeStream(stream)
-  });
-  return logger;
-}
-function writeCliAuditEvent(event, payload, options = {}) {
-  const logFile = options.logFile ?? defaultCliAuditLogFile();
-  try {
-    mkdirSync3(dirname3(logFile), { recursive: true });
-    appendFileSync(
-      logFile,
-      `${JSON.stringify({
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        event,
-        ...options.sessionId === void 0 ? {} : { sessionId: options.sessionId },
-        ...redactForCliLog(payload)
-      })}
-`,
-      "utf8"
-    );
-  } catch (_error) {
-    return;
-  }
-}
-function defaultCliAuditLogFile() {
-  const override = process.env.LINZUMI_CLI_AUDIT_LOG?.trim();
-  return override === void 0 || override === "" ? join8(homedir6(), ".linzumi", "logs", "command-events.jsonl") : override;
-}
-function defaultRunnerLogFile() {
-  return join8(homedir6(), ".linzumi", "logs", "linzumi-runner.log");
-}
-function redactForCliLog(value) {
-  return redactObject(value);
-}
-function redactValue(value, key) {
-  if (sensitiveKey(key)) {
-    return sensitiveMarker;
-  }
-  if (typeof value === "string") {
-    return redactString(value);
-  }
-  if (Array.isArray(value)) {
-    return key === "args" ? redactArgs(value) : value.map((item) => redactValue(item, void 0));
-  }
-  if (value !== null && typeof value === "object") {
-    return redactObject(value);
-  }
-  return value;
-}
-function redactObject(value) {
-  const headerName = typeof value.name === "string" ? value.name.toLowerCase() : void 0;
-  const shouldRedactHeaderValue = headerName === "authorization" || headerName === "cookie" || headerName === "set-cookie";
-  return Object.fromEntries(
-    Object.entries(value).filter(([key]) => key !== "runner_console").map(([key, entry]) => [
-      key,
-      shouldRedactHeaderValue && key === "value" ? sensitiveMarker : redactValue(entry, key)
-    ])
-  );
-}
-function runnerConsolePayload(redacted, original) {
-  const consoleFields = objectValue3(original.runner_console);
-  return consoleFields === void 0 ? redacted : { ...redacted, ...redactForCliLog(consoleFields) };
-}
-function objectValue3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function redactArgs(args) {
-  let redactNext = false;
-  return args.map((arg) => {
-    if (typeof arg !== "string") {
-      redactNext = false;
-      return redactValue(arg, void 0);
-    }
-    if (redactNext) {
-      redactNext = false;
-      return sensitiveMarker;
-    }
-    const [flag, value] = splitArgAssignment(arg);
-    if (sensitiveArgFlags.has(flag)) {
-      if (value === void 0) {
-        redactNext = true;
-        return arg;
-      }
-      return `${flag}=${sensitiveMarker}`;
-    }
-    return redactString(arg);
-  });
-}
-function splitArgAssignment(value) {
-  const index = value.indexOf("=");
-  return index === -1 ? [value, void 0] : [value.slice(0, index), value.slice(index + 1)];
-}
-function sensitiveKey(key) {
-  if (key === void 0) {
-    return false;
-  }
-  return /^(authorization|cookie|set-cookie|password)$/i.test(key) || /(^|[_-])(access[_-]?token|api[_-]?key|auth[_-]?token|oauth[_-]?code|refresh[_-]?token|secret|token)$/i.test(
-    key
-  );
-}
-function redactString(value) {
-  const withRedactedQuery = redactUrlQuery(value);
-  return withRedactedQuery.replace(
-    /\beyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g,
-    sensitiveMarker
-  );
-}
-function redactUrlQuery(value) {
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch (_error) {
-    return redactRelativeUrlQuery(value);
-  }
-  for (const name of [...parsed.searchParams.keys()]) {
-    if (sensitiveQueryParams.has(name.toLowerCase())) {
-      parsed.searchParams.set(name, sensitiveMarker);
-    }
-  }
-  return parsed.toString();
-}
-function redactRelativeUrlQuery(value) {
-  const queryStart = value.indexOf("?");
-  const hashStart = value.indexOf("#");
-  if (queryStart === -1 || hashStart !== -1 && hashStart < queryStart) {
-    return value;
-  }
-  const path2 = value.slice(0, queryStart);
-  const query = hashStart === -1 ? value.slice(queryStart + 1) : value.slice(queryStart + 1, hashStart);
-  const hash = hashStart === -1 ? "" : value.slice(hashStart);
-  const searchParams = new URLSearchParams(query);
-  let redacted = false;
-  for (const name of [...searchParams.keys()]) {
-    if (sensitiveQueryParams.has(name.toLowerCase())) {
-      searchParams.set(name, sensitiveMarker);
-      redacted = true;
-    }
-  }
-  switch (redacted) {
-    case true:
-      return `${path2}?${searchParams.toString()}${hash}`;
-    case false:
-      return value;
-  }
-}
-function closeStream(stream) {
-  if (stream.closed || stream.destroyed) {
-    return Promise.resolve();
-  }
-  return new Promise((resolve12, reject) => {
-    stream.once("error", reject);
-    stream.end(resolve12);
-  });
-}
-var sensitiveMarker, sensitiveQueryParams, sensitiveArgFlags;
-var init_runnerLogger = __esm({
-  "src/runnerLogger.ts"() {
-    "use strict";
-    sensitiveMarker = "<SENSITIVE_DATA>";
-    sensitiveQueryParams = /* @__PURE__ */ new Set([
-      "access_token",
-      "authorization",
-      "code",
-      "cookie",
-      "kandan_preview_ticket",
-      "refresh_token",
-      "token"
-    ]);
-    sensitiveArgFlags = /* @__PURE__ */ new Set([
-      "--access-token",
-      "--api-key",
-      "--authorization",
-      "--cookie",
-      "--oauth-code",
-      "--password",
-      "--refresh-token",
-      "--secret",
-      "--token"
-    ]);
-  }
-});
-
 // src/mcpConfig.ts
 function linzumiMcpServerConfig(options) {
   return {
@@ -13403,6 +13618,76 @@ var init_mcpConfig = __esm({
   }
 });
 
+// src/engineParentDeathWatchdog.ts
+function encodeParentDeathWatchdogConfig(config) {
+  return JSON.stringify(config);
+}
+function parentDeathWatchdogProgram() {
+  return `
+const { spawn } = require('node:child_process');
+const config = JSON.parse(process.argv[process.argv.length - 1]);
+const originalParentPid = process.ppid;
+const child = spawn(config.command, config.args, { stdio: 'inherit' });
+let done = false;
+function shutdown(signal) {
+  if (done) return;
+  done = true;
+  try { process.kill(-process.pid, signal); }
+  catch (_e) { try { child.kill(signal); } catch (_e2) {} }
+}
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGHUP', () => shutdown('SIGTERM'));
+child.on('exit', (code, signal) => {
+  clearInterval(watchdog);
+  // The child is gone; the wrapper must follow it down rather than linger as an
+  // orphan. On the forwarded-signal path (shutdown() above caught SIGINT/SIGTERM
+  // /SIGHUP and propagated it to the child), the wrapper still has its own
+  // handler installed for that signal, so a bare process.kill(self, signal)
+  // would just re-enter shutdown() - a no-op once done is set - and the wrapper
+  // would never exit. Remove the handlers first so the signal's DEFAULT
+  // disposition (terminate) applies, re-raise to mirror the child's death
+  // signal, then exit() as a belt-and-suspenders fallback in case re-raising
+  // does not terminate (e.g. a signal with no default-terminate disposition).
+  process.removeAllListeners('SIGINT');
+  process.removeAllListeners('SIGTERM');
+  process.removeAllListeners('SIGHUP');
+  if (signal) { try { process.kill(process.pid, signal); } catch (_e) {} }
+  process.exit(signal ? 1 : code == null ? 0 : code);
+});
+child.on('error', (err) => {
+  process.stderr.write('engine watchdog spawn failed: ' + (err && err.message) + '\\n');
+  process.exit(1);
+});
+const watchdog = setInterval(() => {
+  // Inlined parentDeathWatchdogShouldReap (keep in sync): reap PURELY on a ppid
+  // change from boot - covers reparent-to-subreaper AND reparent-to-init. NO
+  // \`=== 1\` arm: a runner that is PID 1 captures originalParentPid === 1, so
+  // such an arm would false-fire on the first poll and kill a healthy codex.
+  if (process.ppid !== originalParentPid) {
+    try { child.kill('SIGKILL'); } catch (_e) {}
+    try { process.kill(-process.pid, 'SIGKILL'); } catch (_e) {}
+    process.exit(0);
+  }
+}, config.pollIntervalMs);
+`.trim();
+}
+function parentDeathWatchdogSpawn(nodeExecPath, config) {
+  return {
+    command: nodeExecPath,
+    args: [
+      "-e",
+      parentDeathWatchdogProgram(),
+      encodeParentDeathWatchdogConfig(config)
+    ]
+  };
+}
+var init_engineParentDeathWatchdog = __esm({
+  "src/engineParentDeathWatchdog.ts"() {
+    "use strict";
+  }
+});
+
 // src/codexAppServer.ts
 import {
   spawn as spawn2
@@ -13444,13 +13729,18 @@ async function startCodexAppServerAttempt(codexBin, cwd, options, attempt) {
   let stderrText = "";
   const configuredStdio = codexAppServerStdio(process.stdout.isTTY === true);
   const stdio = [configuredStdio[0], configuredStdio[1], "pipe"];
+  const watchdogSpawn = parentDeathWatchdogSpawn(process.execPath, {
+    command: codexBin,
+    args,
+    pollIntervalMs: codexAppServerWatchdogPollMs
+  });
   writeCliAuditEvent("process.spawn", {
     command: codexBin,
     args,
     cwd,
     purpose: "codex.app_server"
   });
-  const child = spawn2(codexBin, args, {
+  const child = spawn2(watchdogSpawn.command, [...watchdogSpawn.args], {
     cwd,
     env: codexAppServerEnv(options.env, options.inheritEnv ?? true),
     stdio,
@@ -13467,7 +13757,17 @@ async function startCodexAppServerAttempt(codexBin, cwd, options, attempt) {
       }
     });
   }
-  const stop = () => stopCodexAppServerProcess(child);
+  const registered = registerEngineChild({
+    stop: () => stopCodexAppServerProcess(child),
+    pid: child.pid,
+    ownProcessGroup: true,
+    kind: "codex.app_server"
+  });
+  child.once("exit", () => registered.unregister());
+  const stop = () => {
+    registered.unregister();
+    stopCodexAppServerProcess(child);
+  };
   writeCliAuditEvent("process.spawned", {
     command: codexBin,
     args,
@@ -13571,7 +13871,7 @@ function stopCodexAppServerProcess(child, killProcess = process.kill) {
   child.kill("SIGINT");
 }
 function logProcessGroupSignalFailure(pid, error) {
-  const code = processSignalErrorCode(error);
+  const code = processSignalErrorCode2(error);
   const message = error instanceof Error ? error.message : String(error);
   const event = code === "EPERM" ? "process.group_signal_denied" : code === "ESRCH" ? "process.group_signal_missing" : "process.group_signal_failed";
   writeCliAuditEvent(event, {
@@ -13589,7 +13889,7 @@ function logProcessGroupSignalFailure(pid, error) {
     );
   }
 }
-function processSignalErrorCode(error) {
+function processSignalErrorCode2(error) {
   if (error !== null && typeof error === "object" && "code" in error) {
     const code = error.code;
     return typeof code === "string" ? code : void 0;
@@ -13973,13 +14273,16 @@ function readyzUrlForWebsocket(websocketUrl) {
   parsed.hash = "";
   return parsed.toString();
 }
-var blockedCodexAppServerEnvKeys;
+var codexAppServerWatchdogPollMs, blockedCodexAppServerEnvKeys;
 var init_codexAppServer = __esm({
   "src/codexAppServer.ts"() {
     "use strict";
     init_protocol();
     init_runnerLogger();
     init_mcpConfig();
+    init_engineChildReaper();
+    init_engineParentDeathWatchdog();
+    codexAppServerWatchdogPollMs = 2e3;
     blockedCodexAppServerEnvKeys = [
       "LINZUMI_MCP_ACCESS_TOKEN",
       "LINZUMI_MCP_OWNER_USERNAME"
@@ -18127,7 +18430,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.84-beta";
+    linzumiCliVersion = "0.0.86-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -18406,6 +18709,9 @@ function releaseRunnerLock(path2, record) {
   }
 }
 function readRunnerLockForRelease(path2) {
+  return readRunnerLockOwner(path2);
+}
+function readRunnerLockOwner(path2) {
   try {
     return readRunnerLockIfPresent(path2);
   } catch (_error) {
@@ -18526,8 +18832,216 @@ var init_runnerLock = __esm({
   }
 });
 
-// src/runnerConsoleReporter.ts
+// src/runnerLockTakeover.ts
+function runnerLockTakeoverSleep(ms) {
+  return new Promise((resolve12) => {
+    setTimeout(resolve12, ms);
+  });
+}
+function runnerLockConflictReport(baseMessage) {
+  const bar = "=".repeat(64);
+  return [
+    "",
+    bar,
+    "ERROR: linzumi connect could not start - workspace already in use",
+    bar,
+    baseMessage,
+    bar,
+    ""
+  ].join("\n");
+}
+function isRunnerLockConflictReportedError(error) {
+  return error instanceof RunnerLockConflictReportedError || error instanceof Error && error.name === runnerLockConflictReportedErrorName;
+}
+function shouldResolveRunnerLockConflict(lockTakeover) {
+  return lockTakeover !== void 0;
+}
+async function resolveRunnerLockConflict(args) {
+  const report = runnerLockConflictReport(args.baseMessage);
+  if (args.takeOverWithoutPrompt) {
+    args.prompt.writeReport(report);
+    await stopHolderAndAwaitRelease(args.holder, args.lockPath, args.takeover);
+    return { outcome: "take_over" };
+  }
+  if (!args.prompt.isInteractive()) {
+    args.prompt.writeReport(report);
+    return { outcome: "declined", report };
+  }
+  args.prompt.writeReport(report);
+  const yes = await args.prompt.promptYesNo(
+    `Another runner (pid ${args.holder.pid}) is already connected to this workspace. Stop it and run here instead? [y/N] `
+  );
+  if (!yes) {
+    return { outcome: "declined", report };
+  }
+  await stopHolderAndAwaitRelease(args.holder, args.lockPath, args.takeover);
+  return { outcome: "take_over" };
+}
+async function stopHolderAndAwaitRelease(holder, lockPath, deps) {
+  deps.log("runner.lock_takeover_requested", {
+    holderPid: holder.pid,
+    holderRunnerId: holder.runnerId,
+    lockPath
+  });
+  if (!deps.isPidAlive(holder.pid)) {
+    deps.log("runner.lock_takeover_holder_already_gone", {
+      holderPid: holder.pid,
+      lockPath
+    });
+    return;
+  }
+  if (!stillHeldBy(deps, holder)) {
+    deps.log("runner.lock_takeover_owner_changed", {
+      holderPid: holder.pid,
+      lockPath
+    });
+    return;
+  }
+  sendSignalTolerant(deps, holder.pid, "SIGTERM");
+  if (await waitForHolderRelease(holder, deps, runnerLockTakeoverGracefulStopMs)) {
+    deps.log("runner.lock_takeover_graceful", {
+      holderPid: holder.pid,
+      lockPath
+    });
+    return;
+  }
+  if (!stillHeldBy(deps, holder)) {
+    deps.log("runner.lock_takeover_owner_changed", {
+      holderPid: holder.pid,
+      lockPath
+    });
+    return;
+  }
+  deps.log("runner.lock_takeover_escalating_sigkill", {
+    holderPid: holder.pid,
+    lockPath
+  });
+  sendSignalTolerant(deps, holder.pid, "SIGKILL");
+  if (await waitForHolderRelease(holder, deps, runnerLockTakeoverForcefulStopMs)) {
+    deps.log("runner.lock_takeover_forceful", {
+      holderPid: holder.pid,
+      lockPath
+    });
+    return;
+  }
+  throw new Error(
+    `Could not stop the runner holding this workspace (pid ${holder.pid}). It did not exit after SIGTERM and SIGKILL within the timeout. Stop it manually or remove the lock file (${lockPath}) and retry.`
+  );
+}
+async function waitForHolderRelease(holder, deps, timeoutMs) {
+  const deadline = deps.now() + timeoutMs;
+  while (deps.now() < deadline) {
+    if (!deps.isPidAlive(holder.pid) || deps.lockReleased()) {
+      return true;
+    }
+    await deps.sleep(runnerLockTakeoverPollMs);
+  }
+  return !deps.isPidAlive(holder.pid) || deps.lockReleased();
+}
+function stillHeldBy(deps, holder) {
+  const current = deps.currentLockOwner();
+  return current !== void 0 && current.machineId === holder.machineId && current.runnerId === holder.runnerId && current.pid === holder.pid && current.startedAt === holder.startedAt;
+}
+function sendSignalTolerant(deps, pid, signal) {
+  try {
+    deps.signalPid(pid, signal);
+  } catch (error) {
+    const code = error !== null && typeof error === "object" && "code" in error ? error.code : void 0;
+    if (code !== "ESRCH") {
+      deps.log("runner.lock_takeover_signal_failed", {
+        holderPid: pid,
+        signal,
+        code: typeof code === "string" ? code : null,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+var runnerLockTakeoverGracefulStopMs, runnerLockTakeoverForcefulStopMs, runnerLockTakeoverPollMs, runnerLockConflictReportedErrorName, RunnerLockConflictReportedError;
+var init_runnerLockTakeover = __esm({
+  "src/runnerLockTakeover.ts"() {
+    "use strict";
+    runnerLockTakeoverGracefulStopMs = 1e4;
+    runnerLockTakeoverForcefulStopMs = 5e3;
+    runnerLockTakeoverPollMs = 200;
+    runnerLockConflictReportedErrorName = "RunnerLockConflictReportedError";
+    RunnerLockConflictReportedError = class extends Error {
+      constructor() {
+        super("");
+        this.name = runnerLockConflictReportedErrorName;
+      }
+    };
+  }
+});
+
+// src/blessedTputSetulcShim.ts
 import blessed from "blessed";
+function balanceTerminfoConditionals(cap) {
+  if (cap.indexOf("%;") === -1) {
+    return cap;
+  }
+  let depth = 0;
+  let repaired = "";
+  let index = 0;
+  while (index < cap.length) {
+    const here = cap[index];
+    const next = cap[index + 1];
+    if (here === "%" && next === "%") {
+      repaired += "%%";
+      index += 2;
+      continue;
+    }
+    if (here === "%" && next === "?") {
+      depth += 1;
+      repaired += "%?";
+      index += 2;
+      continue;
+    }
+    if (here === "%" && next === ";") {
+      if (depth > 0) {
+        depth -= 1;
+        repaired += "%;";
+      }
+      index += 2;
+      continue;
+    }
+    repaired += here;
+    index += 1;
+  }
+  return repaired;
+}
+function installBlessedSetulcShim(blessedModule = blessed) {
+  const tput = blessedModule.Tput;
+  const proto = tput?.prototype;
+  const original = proto?._compile;
+  if (proto === void 0 || typeof original !== "function") {
+    return;
+  }
+  if (proto[SHIM_FLAG] === true) {
+    return;
+  }
+  const patched = function patchedCompile(info, key, str) {
+    const safeStr = typeof str === "string" ? balanceTerminfoConditionals(str) : str;
+    return original.call(this, info, key, safeStr);
+  };
+  proto._compile = patched;
+  Object.defineProperty(proto, SHIM_FLAG, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: true
+  });
+}
+var SHIM_FLAG;
+var init_blessedTputSetulcShim = __esm({
+  "src/blessedTputSetulcShim.ts"() {
+    "use strict";
+    SHIM_FLAG = "__linzumiSetulcShimInstalled";
+  }
+});
+
+// src/runnerConsoleReporter.ts
+import blessed2 from "blessed";
 function reportRunnerConsoleEvent(event, payload) {
   if (shouldRenderDashboard()) {
     const tui = initializeDashboardTui(dashboardState);
@@ -19250,7 +19764,9 @@ function ignoredMessage(payload) {
     `reason=${text(payload.reason)}`,
     optionalField("type", payload.type),
     optionalField("thread", payload.thread_id),
+    optionalField("bound_thread", payload.bound_thread_id),
     optionalField("body_chars", payload.body_length),
+    optionalField("body", payload.body_preview),
     optionalField("attachments", payload.attachment_count),
     optionalField("local_event", payload.local_runner_event_type)
   ].filter((part) => part !== void 0).join(" ");
@@ -19510,20 +20026,21 @@ function handleDashboardKey(state, key, exitProcess = () => process.kill(process
 function createRunnerConsoleDashboardTui(state, exitProcess = () => process.kill(process.pid, "SIGINT")) {
   let rendering = false;
   let rawScrollAnchor;
-  const screen = blessed.screen({
+  installBlessedSetulcShim();
+  const screen = blessed2.screen({
     title: "Linzumi Commander",
     smartCSR: true,
     fullUnicode: true,
     mouse: true
   });
-  const header = blessed.box({
+  const header = blessed2.box({
     top: 0,
     left: 0,
     width: "100%",
     height: 1,
     tags: false
   });
-  const tableElement = blessed.listtable({
+  const tableElement = blessed2.listtable({
     top: 1,
     left: 0,
     width: "100%",
@@ -19552,7 +20069,7 @@ function createRunnerConsoleDashboardTui(state, exitProcess = () => process.kill
       }
     }
   });
-  const rawTitle = blessed.box({
+  const rawTitle = blessed2.box({
     top: 0,
     left: 12,
     right: 0,
@@ -19560,7 +20077,7 @@ function createRunnerConsoleDashboardTui(state, exitProcess = () => process.kill
     tags: false,
     hidden: true
   });
-  const backButton = blessed.button({
+  const backButton = blessed2.button({
     top: 0,
     left: 0,
     width: 10,
@@ -19575,7 +20092,7 @@ function createRunnerConsoleDashboardTui(state, exitProcess = () => process.kill
       hover: { inverse: true }
     }
   });
-  const rawBox = blessed.box({
+  const rawBox = blessed2.box({
     top: 3,
     left: 0,
     width: "100%",
@@ -20054,6 +20571,7 @@ var dashboardState, maxRawLines, escapeKey, ctrlCKey, enterKey, upKey, downKey,
 var init_runnerConsoleReporter = __esm({
   "src/runnerConsoleReporter.ts"() {
     "use strict";
+    init_blessedTputSetulcShim();
     dashboardState = {
       jobs: /* @__PURE__ */ new Map(),
       discovery: /* @__PURE__ */ new Map(),
@@ -21379,6 +21897,7 @@ import { spawn as spawn9, spawnSync as spawnSync5 } from "node:child_process";
 import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
+  existsSync as existsSync13,
   lstatSync,
   mkdirSync as mkdirSync12,
   mkdtempSync as mkdtempSync4,
@@ -21393,6 +21912,7 @@ import {
 import { readFile as readFile2 } from "node:fs/promises";
 import { createServer as createServer3 } from "node:http";
 import { homedir as homedir13, hostname as hostname2, tmpdir as tmpdir3 } from "node:os";
+import { createInterface } from "node:readline";
 import {
   basename as basename8,
   dirname as dirname13,
@@ -21417,42 +21937,35 @@ async function runLocalCodexRunner(options) {
   });
   try {
     if (options.machineId !== void 0) {
-      let runnerLock;
-      try {
-        runnerLock = acquireRunnerLock({
-          machineId: options.machineId,
-          runnerId: options.runnerId,
-          cwd: options.cwd,
-          workspace: runnerWorkspaceSlug(options) ?? null,
-          linzumiUrl: options.kandanUrl,
-          launchSource: options.launchSource,
-          configPath: options.runnerLockConfigPath,
-          // Wedged-runner takeover: a lock holder whose pid is alive but
-          // whose lock heartbeat went stale (>3 min) gets SIGKILLed and its
-          // lock replaced, instead of blocking recovery until someone runs
-          // kill -9 by hand. Log it so the runner log explains where the old
-          // pid went.
-          onTakeover: (takeover) => {
-            log2("runner.lock_takeover", {
-              runnerId: options.runnerId,
-              holderRunnerId: takeover.holderRunnerId,
-              holderPid: takeover.holderPid,
-              reason: takeover.reason,
-              lockPath: takeover.lockPath
-            });
-          }
-        });
-      } catch (error) {
-        if (isRunnerLockHeldError(error)) {
-          log2("runner.lock_held_by_live_process", {
+      const machineId = options.machineId;
+      const acquire = () => acquireRunnerLock({
+        machineId,
+        runnerId: options.runnerId,
+        cwd: options.cwd,
+        workspace: runnerWorkspaceSlug(options) ?? null,
+        linzumiUrl: options.kandanUrl,
+        launchSource: options.launchSource,
+        configPath: options.runnerLockConfigPath,
+        // Wedged-runner takeover: a lock holder whose pid is alive but
+        // whose lock heartbeat went stale (>3 min) gets SIGKILLed and its
+        // lock replaced, instead of blocking recovery until someone runs
+        // kill -9 by hand. Log it so the runner log explains where the old
+        // pid went.
+        onTakeover: (takeover) => {
+          log2("runner.lock_takeover", {
             runnerId: options.runnerId,
-            heldByRunnerId: error.heldBy.runnerId,
-            heldByPid: error.heldBy.pid,
-            lockPath: error.lockPath
+            holderRunnerId: takeover.holderRunnerId,
+            holderPid: takeover.holderPid,
+            reason: takeover.reason,
+            lockPath: takeover.lockPath
           });
         }
-        throw error;
-      }
+      });
+      const runnerLock = await acquireRunnerLockWithConflictResolution(
+        acquire,
+        options,
+        log2
+      );
       cleanup.actions.push(() => runnerLock.release());
       log2("runner.lock_acquired", {
         path: runnerLock.path,
@@ -22472,6 +22985,11 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
   if (options.channelSession !== void 0 && codex === void 0) {
     throw new Error("channel session requires a Codex app-server connection");
   }
+  const ownsRespawnableAppServer = runnerOwnsRespawnableAppServer({
+    codexUrl: options.codexUrl,
+    threadProcessRole: options.threadProcess?.role,
+    ownsStartedAppServer: started !== void 0
+  });
   const seq = { value: 0 };
   const discoveredCodexThreads = { value: [] };
   const runtimeDefaults = runnerRuntimeDefaults(options);
@@ -22563,6 +23081,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
   const dynamicChannelSessions = /* @__PURE__ */ new Map();
   const dynamicChannelSessionCodexClients = /* @__PURE__ */ new Map();
   const codexTurnFailureGuards = /* @__PURE__ */ new Map();
+  const lossReportPushes = [];
   const codexTurnFailureGuardFor = (client) => {
     const existing = codexTurnFailureGuards.get(client);
     if (existing !== void 0) {
@@ -22575,7 +23094,36 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
           ([codexThreadId]) => dynamicChannelSessionCodexClients.get(codexThreadId) === client
         ).map(([, session]) => session)
       ],
-      log: log2
+      log: log2,
+      // Spec: plans/2026-06-13-orphaned-mid-turn-reconnect-recovery-spec.md
+      // The runner process and its channel survive an app-server death, so the
+      // server otherwise keeps these thread bindings "connected" and never
+      // offers reconnect. Report the loss per affected thread (best-effort)
+      // so the bindings flip to disconnected/reconnectable upstream.
+      //
+      // Only do this for a runner that owns a respawnable app-server. For an
+      // external/remote `codexUrl` backend (or a thread-process worker) this
+      // runner cannot relaunch the dead app-server, so a reconnect could never
+      // recover the thread - marking it reconnectable would be misleading. In
+      // that case we still fail the in-flight turns terminally, but leave the
+      // binding as-is rather than offering a reconnect that cannot succeed.
+      onActiveThreadsFailed: ownsRespawnableAppServer ? (threadIds) => {
+        for (const codexThreadId of threadIds) {
+          lossReportPushes.push(
+            kandan.push(topic, "session:app_server_lost", {
+              codex_thread_id: codexThreadId
+            }).then(
+              () => void 0,
+              (error) => {
+                log2("kandan.session_app_server_lost_push_failed", {
+                  codex_thread_id: codexThreadId,
+                  message: error instanceof Error ? error.message : String(error)
+                });
+              }
+            )
+          );
+        }
+      } : void 0
     });
     codexTurnFailureGuards.set(client, guard);
     return guard;
@@ -22592,7 +23140,29 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     );
     dynamicChannelSessions.clear();
     dynamicChannelSessionCodexClients.clear();
-    for (const session of activeClaudeCodeSessions.values()) {
+    const claudeSessions = [...activeClaudeCodeSessions.values()];
+    for (const session of claudeSessions) {
+      try {
+        session.closeInput();
+      } catch (error) {
+        log2("claude_code.session_input_close_failed", {
+          linzumi_thread_id: session.threadId,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    await Promise.race([
+      Promise.allSettled(
+        claudeSessions.flatMap((session) => {
+          const work = session.sessionWork();
+          return work === void 0 ? [] : [work];
+        })
+      ),
+      new Promise((resolve12) => {
+        setTimeout(resolve12, 1e4).unref?.();
+      })
+    ]);
+    for (const session of claudeSessions) {
       session.abortController.abort(new Error("local runner stopped"));
     }
     activeClaudeCodeSessions.clear();
@@ -22657,7 +23227,8 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
         portForwardWatcher: channelSessionPortForwardWatcherOptions({
           rootPid: portForwardWatcherRootPid,
           start: options.portForwardWatcher,
-          commanderBoundPids: args.commanderBoundPids
+          commanderBoundPids: args.commanderBoundPids,
+          commanderBoundPorts: args.commanderBoundPorts
         }),
         suppressedForwardPorts,
         onForwardPortApproved: (port, attribution) => {
@@ -22852,6 +23423,12 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
         portForwardWatcherRootPid: handle.processPid,
         commanderBoundPids: (handle.commanderManagedPorts ?? []).flatMap(
           (port) => port.pid === void 0 ? [] : [port.pid]
+        ),
+        // The exact codex app-server ports are commander-managed even though
+        // their listening pid is the wrapped grandchild, not the recorded
+        // wrapper pid (Codex P1).
+        commanderBoundPorts: (handle.commanderManagedPorts ?? []).map(
+          (port) => port.port
         )
       });
       switch (control.type) {
@@ -23001,6 +23578,7 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
     }
   });
   if (sharedCodexTurnFailureGuard !== void 0) {
+    const appServerLost = { handled: false };
     const failCodexSessionTurns = (cause) => {
       if (cleanup.closePromise !== void 0) {
         return;
@@ -23008,6 +23586,27 @@ async function openLocalCodexRunner(options, log2, cleanup, close) {
       log2("codex.app_server_connection_lost", { cause });
       sharedCodexTurnFailureGuard.failActiveTurns(cause);
       started?.stop();
+      if (ownsRespawnableAppServer && !appServerLost.handled) {
+        appServerLost.handled = true;
+        console.error(
+          `Codex app-server connection was lost (${cause}); exiting so a fresh runner can relaunch it. Run \`linzumi connect\` to reconnect.`
+        );
+        const sessionDrains = [
+          ...channelSession !== void 0 ? [channelSession] : [],
+          ...dynamicChannelSessions.values()
+        ].map(
+          (session) => session.close().catch((error) => {
+            log2("codex.app_server_lost_session_drain_failed", {
+              message: error instanceof Error ? error.message : String(error)
+            });
+          })
+        );
+        void awaitLossReportsThenExit({
+          pushes: [...lossReportPushes, ...sessionDrains],
+          exit: () => process.exit(75),
+          safetyCapMs: 5e3
+        });
+      }
     };
     codex?.onClose?.((error) => failCodexSessionTurns(error.message));
     started?.process.once(
@@ -23763,6 +24362,19 @@ async function resolveSessionControl(channelSession, dynamicChannelSessions, con
   }
   return void 0;
 }
+function runnerOwnsRespawnableAppServer(args) {
+  return args.codexUrl === void 0 && args.threadProcessRole !== "thread" && args.ownsStartedAppServer;
+}
+async function awaitLossReportsThenExit(args) {
+  const setTimeoutImpl = args.setTimeoutFn ?? setTimeout;
+  const drained = Promise.allSettled(args.pushes).then(() => void 0);
+  const safetyCap = new Promise((resolve12) => {
+    const handle = setTimeoutImpl(() => resolve12(), args.safetyCapMs);
+    handle?.unref?.();
+  });
+  await Promise.race([drained, safetyCap]);
+  args.exit();
+}
 function createCodexTurnFailureGuard(args) {
   const activeTurnsByThread = /* @__PURE__ */ new Map();
   const state = { failed: false };
@@ -23798,6 +24410,7 @@ function createCodexTurnFailureGuard(args) {
       if (activeTurns.length === 0) {
         return;
       }
+      args.onActiveThreadsFailed?.(activeTurns.map(([threadId]) => threadId));
       const sessions = Array.from(args.sessions());
       for (const [threadId, turnId] of activeTurns) {
         args.log("codex.active_turn_failed_on_connection_loss", {
@@ -23955,6 +24568,101 @@ function installCleanupHandlers(close) {
     process.off("exit", closeOnExit);
   };
 }
+async function acquireRunnerLockWithConflictResolution(acquire, options, log2) {
+  try {
+    return acquire();
+  } catch (error) {
+    if (!isRunnerLockHeldError(error)) {
+      throw error;
+    }
+    log2("runner.lock_held_by_live_process", {
+      runnerId: options.runnerId,
+      heldByRunnerId: error.heldBy.runnerId,
+      heldByPid: error.heldBy.pid,
+      lockPath: error.lockPath
+    });
+    const lockTakeover = options.lockTakeover;
+    if (!shouldResolveRunnerLockConflict(lockTakeover)) {
+      throw error;
+    }
+    const promptDeps = lockTakeover.prompt ?? defaultRunnerLockTakeoverPromptDeps(lockTakeover);
+    const takeoverDeps = resolveRunnerLockTakeoverDeps(
+      error.lockPath,
+      lockTakeover.takeover,
+      log2
+    );
+    const resolution = await resolveRunnerLockConflict({
+      holder: error.heldBy,
+      lockPath: error.lockPath,
+      baseMessage: error.message,
+      takeOverWithoutPrompt: lockTakeover.takeOverWithoutPrompt === true,
+      prompt: promptDeps,
+      takeover: takeoverDeps
+    });
+    if (resolution.outcome === "declined") {
+      throw new RunnerLockConflictReportedError();
+    }
+    log2("runner.lock_takeover_interactive", {
+      runnerId: options.runnerId,
+      heldByRunnerId: error.heldBy.runnerId,
+      heldByPid: error.heldBy.pid,
+      lockPath: error.lockPath
+    });
+    return acquire();
+  }
+}
+function defaultRunnerLockTakeoverPromptDeps(takeover) {
+  return {
+    isInteractive: () => takeover?.forceNonInteractive !== true && process.stdin.isTTY === true && process.stderr.isTTY === true,
+    writeReport: (text2) => {
+      process.stderr.write(`${text2}
+`);
+    },
+    promptYesNo: (question) => promptYesNoOnStdin(question)
+  };
+}
+function promptYesNoOnStdin(question) {
+  return new Promise((resolve12) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stderr
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve12(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+function resolveRunnerLockTakeoverDeps(lockPath, overrides, log2) {
+  return {
+    isPidAlive: overrides?.isPidAlive ?? runnerLockTakeoverPidIsAlive,
+    signalPid: overrides?.signalPid ?? ((pid, signal) => {
+      process.kill(pid, signal);
+    }),
+    lockReleased: overrides?.lockReleased ?? (() => !existsSync13(lockPath)),
+    // Re-reads the on-disk owner so the takeover flow can revalidate identity
+    // before signaling (never throws on a torn/partial lock file).
+    currentLockOwner: overrides?.currentLockOwner ?? (() => readRunnerLockOwner(lockPath)),
+    // runnerLockTakeoverSleep is deliberately NOT unref'ed - see its definition;
+    // an unref'ed timer here would let `linzumi connect` exit before retrying
+    // the lock acquisition during a takeover.
+    sleep: overrides?.sleep ?? runnerLockTakeoverSleep,
+    now: overrides?.now ?? (() => Date.now()),
+    log: overrides?.log ?? ((event, payload) => {
+      log2(event, payload);
+      writeCliAuditEvent(event, payload);
+    })
+  };
+}
+function runnerLockTakeoverPidIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error !== null && typeof error === "object" && "code" in error ? error.code : void 0;
+    return code !== "ESRCH";
+  }
+}
 function launchCodexTui(codexBin, codexUrl, cwd, codexThreadId, session, fast) {
   const args = codexTuiArgs(codexUrl, codexThreadId, session, fast);
   writeCliAuditEvent("process.spawn", {
@@ -24449,10 +25157,28 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
             };
           }
           try {
-            activeSession.enqueueInput({
+            const enqueueResult = activeSession.enqueueInput({
               content: contentResult.content,
               sourceSeq
             });
+            if (enqueueResult === "duplicate") {
+              log2("claude_code.message_duplicate_ignored", {
+                linzumi_thread_id: optionalThreadControlField(control, "threadId") ?? null,
+                claude_session_id: codexThreadId,
+                body_preview: claudeConsoleBodyPreview(workDescription),
+                source_seq: sourceSeq ?? null
+              });
+              return {
+                instanceId,
+                controlType: control.type,
+                agentProvider: "claude-code",
+                cwd: cwd.cwd,
+                matchedRoot: cwd.matchedRoot,
+                codexThreadId,
+                queuedInput: true,
+                duplicate: true
+              };
+            }
             log2("claude_code.message_queued", {
               linzumi_thread_id: optionalThreadControlField(control, "threadId") ?? null,
               claude_session_id: codexThreadId,
@@ -24956,7 +25682,24 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       };
     }
     case "stop_instance":
-    case "kill_instance":
+    case "kill_instance": {
+      const controlThreadId2 = "threadId" in control && typeof control.threadId === "string" ? control.threadId : void 0;
+      const activeSession = controlThreadId2 === void 0 ? void 0 : activeClaudeCodeSessions.get(controlThreadId2);
+      if (activeSession !== void 0) {
+        await activeSession.interruptTurn("Claude Code stopped by Linzumi");
+        activeSession.abortController.abort(
+          new Error("Claude Code stopped by Linzumi")
+        );
+        return {
+          instanceId,
+          controlType: control.type,
+          agentProvider: "claude-code",
+          threadId: controlThreadId2,
+          stopped: true
+        };
+      }
+      return { instanceId, controlType: control.type, skipped: true };
+    }
     case "resolve_port_forward_request":
     case "update_thread_interaction_access":
     case "set_port_forward_enabled":
@@ -25456,10 +26199,10 @@ function createClaudeCodeInputQueue(input) {
     claudeCodeUserInputMessage(input.content)
   ];
   const pendingSourceSeqs = [input.sourceSeq];
+  const deferredFollowUps = [];
   const waiters = [];
   const state = {
-    closed: false,
-    queuedTurnCount: 1
+    closed: false
   };
   const drainClosedWaiters = () => {
     while (state.closed) {
@@ -25470,19 +26213,25 @@ function createClaudeCodeInputQueue(input) {
       waiter({ done: true, value: void 0 });
     }
   };
+  const deliverNow = (message, sourceSeq) => {
+    pendingSourceSeqs.push(sourceSeq);
+    const waiter = waiters.shift();
+    if (waiter === void 0) {
+      pendingMessages.push(message);
+      return;
+    }
+    waiter({ done: false, value: message });
+  };
   const enqueue = (next) => {
     if (state.closed) {
       throw new Error("Claude Code streaming input is closed");
     }
     const message = claudeCodeUserInputMessage(next.content);
-    pendingSourceSeqs.push(next.sourceSeq);
-    state.queuedTurnCount += 1;
-    const waiter = waiters.shift();
-    if (waiter === void 0) {
-      pendingMessages.push(message);
+    if (pendingSourceSeqs.length > 0) {
+      deferredFollowUps.push({ message, sourceSeq: next.sourceSeq });
       return;
     }
-    waiter({ done: false, value: message });
+    deliverNow(message, next.sourceSeq);
   };
   const enqueueSteer = (content) => {
     if (state.closed) {
@@ -25520,14 +26269,30 @@ function createClaudeCodeInputQueue(input) {
         };
       }
     },
-    queuedTurnCount: () => state.queuedTurnCount,
     close: () => {
+      if (pendingSourceSeqs.length === 0) {
+        while (deferredFollowUps.length > 0) {
+          const followUp = deferredFollowUps.shift();
+          if (followUp !== void 0) {
+            deliverNow(followUp.message, followUp.sourceSeq);
+          }
+        }
+      }
       state.closed = true;
       drainClosedWaiters();
     },
     enqueue,
     enqueueSteer,
-    completeTurn: () => pendingSourceSeqs.shift(),
+    completeTurn: () => {
+      const completed = pendingSourceSeqs.shift();
+      if (!state.closed && pendingSourceSeqs.length === 0) {
+        const nextFollowUp = deferredFollowUps.shift();
+        if (nextFollowUp !== void 0) {
+          deliverNow(nextFollowUp.message, nextFollowUp.sourceSeq);
+        }
+      }
+      return completed;
+    },
     currentSourceSeq: () => pendingSourceSeqs[0]
   };
 }
@@ -25775,6 +26540,21 @@ async function startClaudeCodeProviderInstance(args) {
     codexVersion: void 0
   };
   const abortController = new AbortController();
+  const reaperRegistration = registerEngineChild({
+    stop: () => {
+      if (!abortController.signal.aborted) {
+        abortController.abort(new Error("engine child reaper teardown"));
+      }
+    },
+    pid: void 0,
+    ownProcessGroup: false,
+    kind: "claude_code"
+  });
+  const acceptedSourceSeqs = new Set(
+    sourceSeq === void 0 ? [] : [sourceSeq]
+  );
+  const sessionWorkHandle = { value: void 0 };
+  let startControlResponded = false;
   let activeSessionId;
   let sessionControls;
   const planMirrorClient = createLinzumiMcpApiClient({
@@ -25909,7 +26689,7 @@ async function startClaudeCodeProviderInstance(args) {
     rootSeq,
     log: args.log
   };
-  let lastRateLimitSignature;
+  const lastRateLimitSignatureByWindow = /* @__PURE__ */ new Map();
   const reportClaudeCodeRateLimit = async (event) => {
     const nowMs = Date.now();
     const summary = claudeCodeRateLimitSummaryText(event.rateLimit, nowMs);
@@ -25925,13 +26705,13 @@ async function startClaudeCodeProviderInstance(args) {
       utilization_percent: event.rateLimit.utilizationPercent ?? null,
       resets_at_ms: event.rateLimit.resetsAtMs ?? null
     });
+    const windowKey = event.rateLimit.rateLimitType ?? "account";
     const signature = claudeRateLimitSignature(event.rateLimit);
-    if (signature === lastRateLimitSignature) {
+    if (signature === lastRateLimitSignatureByWindow.get(windowKey)) {
       return;
     }
-    lastRateLimitSignature = signature;
     try {
-      await postClaudeCodeRateLimitMessage({
+      await publishClaudeCodeRateLimitState({
         kandan: args.kandan,
         topic: args.topic,
         workspace,
@@ -25940,6 +26720,7 @@ async function startClaudeCodeProviderInstance(args) {
         claudeSessionId: event.sessionId ?? activeSessionId,
         rateLimit: event.rateLimit
       });
+      lastRateLimitSignatureByWindow.set(windowKey, signature);
     } catch (error) {
       args.log("claude_code.rate_limit_post_failed", {
         thread_id: threadId,
@@ -25947,6 +26728,10 @@ async function startClaudeCodeProviderInstance(args) {
       });
     }
   };
+  let settleFirstTurn = () => void 0;
+  const firstTurnSettled = new Promise((resolve12) => {
+    settleFirstTurn = resolve12;
+  });
   const onTranscriptEvent = async (event) => {
     try {
       await mirrorClaudeSessionStoreAppend(mirrorArgs, event);
@@ -25969,7 +26754,19 @@ async function startClaudeCodeProviderInstance(args) {
         channel,
         threadId,
         currentSourceSeq: inputQueue.currentSourceSeq,
-        enqueueInput: inputQueue.enqueue,
+        enqueueInput: (input) => {
+          if (input.sourceSeq !== void 0 && acceptedSourceSeqs.has(input.sourceSeq)) {
+            return "duplicate";
+          }
+          inputQueue.enqueue(input);
+          if (input.sourceSeq !== void 0) {
+            acceptedSourceSeqs.add(input.sourceSeq);
+          }
+          return "queued";
+        },
+        closeInput: inputQueue.close,
+        hasActiveTurn: () => adapter.activeTurnId() !== void 0,
+        sessionWork: () => sessionWorkHandle.value,
         steerTurn: inputQueue.enqueueSteer,
         interruptTurn: async (reason) => {
           const aborted = adapter.interruptActiveTurn(reason);
@@ -26025,6 +26822,10 @@ async function startClaudeCodeProviderInstance(args) {
         claude_session_id: event.sessionId,
         body_preview: claudeConsoleBodyPreview(event.body)
       });
+      settleFirstTurn();
+    }
+    if (event.type === "turn_interrupted") {
+      settleFirstTurn();
     }
     if (event.type === "rate_limit") {
       await reportClaudeCodeRateLimit(event);
@@ -26071,80 +26872,98 @@ async function startClaudeCodeProviderInstance(args) {
     request,
     signal
   });
-  let result;
-  try {
+  const runSession = async () => {
+    let result2;
     try {
-      result = await startClaudeCodeSession({
-        cwd: args.cwd,
-        prompt: workDescription,
-        developerInstructions: commanderDeveloperInstructions({
+      try {
+        result2 = await startClaudeCodeSession({
           cwd: args.cwd,
-          agentLabel: "Claude Code",
-          planTool: "todo-write",
-          developerPrompt,
-          linzumiContext
-        }),
-        model: claudeCodeModelForRuntimeModel(runtimeSettings.model),
-        resumeSessionId: args.resumeSessionId,
-        abortController,
-        streamingInput: inputQueue,
-        runner: args.options.claudeCodeRunner,
-        canUseTool,
-        ...mcpServers === void 0 ? {} : { mcpServers },
-        ...liveBashCapture === void 0 ? {} : {
-          preToolUseHookMatchers: liveBashCapture.hookMatchers,
-          wrapApprovedToolInput: (toolUseId, toolName2, input) => toolName2 === "Bash" ? liveBashCapture.wrapApprovedTool(toolUseId, input) : void 0
-        },
-        env: sessionEnv,
-        // The built-in Linzumi MCP is trusted like the codex side: its tools
-        // run without an approval round-trip. SDK allowedTools matches MCP
-        // tools as mcp__<server>__<tool>; the __* suffix covers the server.
-        allowedTools: ["mcp__linzumi__*"],
-        onSessionControls: (controls) => {
-          sessionControls = controls;
-        },
-        onTurnCompleted: () => {
-          inputQueue.completeTurn();
-        },
-        onTranscriptEvent
-      });
-    } finally {
-      inputQueue.close();
-      mcpAuthCleanup?.();
-      liveBashCapture?.close();
-      if (activeSessionId !== void 0) {
-        args.activeClaudeCodeSessions.delete(activeSessionId);
-        await args.disposeClaudeCodeForwardPortSession?.(activeSessionId);
+          prompt: workDescription,
+          developerInstructions: commanderDeveloperInstructions({
+            cwd: args.cwd,
+            agentLabel: "Claude Code",
+            planTool: "todo-write",
+            developerPrompt,
+            linzumiContext
+          }),
+          model: claudeCodeModelForRuntimeModel(runtimeSettings.model),
+          resumeSessionId: args.resumeSessionId,
+          abortController,
+          streamingInput: inputQueue,
+          runner: args.options.claudeCodeRunner,
+          canUseTool,
+          ...mcpServers === void 0 ? {} : { mcpServers },
+          ...liveBashCapture === void 0 ? {} : {
+            preToolUseHookMatchers: liveBashCapture.hookMatchers,
+            wrapApprovedToolInput: (toolUseId, toolName2, input) => toolName2 === "Bash" ? liveBashCapture.wrapApprovedTool(toolUseId, input) : void 0
+          },
+          env: sessionEnv,
+          // The built-in Linzumi MCP is trusted like the codex side: its tools
+          // run without an approval round-trip. SDK allowedTools matches MCP
+          // tools as mcp__<server>__<tool>; the __* suffix covers the server.
+          allowedTools: ["mcp__linzumi__*"],
+          onSessionControls: (controls) => {
+            sessionControls = controls;
+          },
+          onTurnCompleted: () => {
+            inputQueue.completeTurn();
+            settleFirstTurn();
+          },
+          onTranscriptEvent
+        });
+      } finally {
+        inputQueue.close();
+        mcpAuthCleanup?.();
+        liveBashCapture?.close();
+        if (activeSessionId !== void 0) {
+          args.activeClaudeCodeSessions.delete(activeSessionId);
+          await args.disposeClaudeCodeForwardPortSession?.(activeSessionId);
+        }
+      }
+    } catch (error) {
+      adapter.submitLifecycle(
+        "codexDied",
+        error instanceof Error ? error.message : String(error)
+      );
+      await adapter.close(5e3).catch(() => void 0);
+      await Promise.race([
+        planMirror.settle().catch(() => void 0),
+        new Promise((resolve12) => {
+          setTimeout(resolve12, 5e3).unref?.();
+        })
+      ]);
+      logStartFailureTerminal(
+        error instanceof Error ? error.message : String(error)
+      );
+      if (!startControlResponded) {
+        args.setStartupStage("claude_code_session_failed");
       }
+      throw error;
     }
-  } catch (error) {
-    adapter.submitLifecycle(
-      "codexDied",
-      error instanceof Error ? error.message : String(error)
-    );
-    await adapter.close(5e3).catch(() => void 0);
+    if (!startControlResponded) {
+      args.setStartupStage("posting_claude_code_output");
+    }
+    await adapter.awaitTurnsSettled(3e4);
+    await adapter.close(3e4);
     await Promise.race([
-      planMirror.settle().catch(() => void 0),
+      planMirror.settle(),
       new Promise((resolve12) => {
-        setTimeout(resolve12, 5e3).unref?.();
+        setTimeout(resolve12, 1e4).unref?.();
       })
     ]);
-    logStartFailureTerminal(
-      error instanceof Error ? error.message : String(error)
-    );
-    args.setStartupStage("claude_code_session_failed");
-    throw error;
-  }
-  args.setStartupStage("posting_claude_code_output");
-  await adapter.awaitTurnsSettled(3e4);
-  await adapter.close(3e4);
-  await Promise.race([
-    planMirror.settle(),
-    new Promise((resolve12) => {
-      setTimeout(resolve12, 1e4).unref?.();
-    })
+    return result2;
+  };
+  const sessionWork = runSession();
+  void sessionWork.finally(() => reaperRegistration.unregister()).catch(() => void 0);
+  sessionWorkHandle.value = sessionWork;
+  const settled = await Promise.race([
+    sessionWork.then((result2) => ({
+      type: "session_ended",
+      result: result2
+    })),
+    firstTurnSettled.then(() => ({ type: "first_turn_settled" }))
   ]);
-  return {
+  const respondWithSessionId = (sessionId) => ({
     controlResponse: {
       instanceId: args.instanceId,
       controlType: args.control.type,
@@ -26152,16 +26971,52 @@ async function startClaudeCodeProviderInstance(args) {
       cwd: args.cwd,
       matchedRoot: args.matchedRoot,
       response: {
-        session: { id: result.sessionId }
+        session: { id: sessionId }
       }
     },
     providerSession: {
       provider: "claude-code",
       cwd: args.cwd,
       matchedRoot: args.matchedRoot,
-      sessionId: result.sessionId
+      sessionId
     }
-  };
+  });
+  if (settled.type === "session_ended") {
+    return respondWithSessionId(settled.result.sessionId);
+  }
+  args.setStartupStage("posting_claude_code_output");
+  startControlResponded = true;
+  await adapter.awaitTurnsSettled(3e4);
+  try {
+    await adapter.flush(3e4);
+  } catch (error) {
+    args.log("claude_code.first_turn_flush_timeout", {
+      linzumi_thread_id: threadId,
+      claude_session_id: activeSessionId ?? null,
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+  void sessionWork.then(
+    () => {
+      args.log("claude_code.session_loop_ended", {
+        linzumi_thread_id: threadId,
+        claude_session_id: activeSessionId ?? null
+      });
+    },
+    (error) => {
+      args.log("claude_code.session_loop_failed", {
+        linzumi_thread_id: threadId,
+        claude_session_id: activeSessionId ?? null,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  );
+  const liveSessionId = activeSessionId ?? args.resumeSessionId;
+  if (liveSessionId !== void 0) {
+    return respondWithSessionId(liveSessionId);
+  }
+  const result = await sessionWork;
+  return respondWithSessionId(result.sessionId);
 }
 function claudePermissionModeForApprovalPolicy(approvalPolicy) {
   switch (approvalPolicy) {
@@ -26403,50 +27258,26 @@ function claudeRateLimitSignature(rateLimit) {
     rateLimit.resetsAtMs ?? "na"
   ].join(":");
 }
-async function postClaudeCodeRateLimitMessage(args) {
-  const nowMs = Date.now();
-  const summary = claudeCodeRateLimitSummaryText(args.rateLimit, nowMs);
-  const headline = `Claude Code rate limit: ${summary}`;
-  const resetLabel = claudeCodeRateLimitResetLabel(
-    args.rateLimit.resetsAtMs,
-    nowMs
-  );
-  const richUi = args.rateLimit.utilizationPercent === void 0 ? [{ primitive: "label", label: headline }] : [
-    {
-      primitive: "progress",
-      value: Math.min(
-        100,
-        Math.max(0, Math.round(args.rateLimit.utilizationPercent))
-      ),
-      max: 100,
-      label: `Claude Code rate limit${resetLabel === void 0 ? "" : ` - ${resetLabel}`}`
-    }
-  ];
-  await args.kandan.push(args.topic, "session:post_thread_message", {
+async function publishClaudeCodeRateLimitState(args) {
+  await args.kandan.push(args.topic, "claude_rate_limit_state", {
     workspace: args.workspace,
     channel: args.channel,
     thread_id: args.threadId,
-    body: headline,
-    payload: {
-      rich_ui: richUi,
-      metadata: {
-        local_codex_runner: {
-          event_type: "claude_code_rate_limit",
-          agent_provider: "claude-code",
-          ...args.claudeSessionId === void 0 ? {} : { claude_session_id: args.claudeSessionId }
-        }
-      }
+    agent_provider: "claude-code",
+    ...args.claudeSessionId === void 0 ? {} : { claude_session_id: args.claudeSessionId },
+    // "account" mirrors the server-side default for SDK frames that omit a
+    // window type; sending it explicitly keeps the wire contract obvious.
+    rate_limit_type: args.rateLimit.rateLimitType ?? "account",
+    status: args.rateLimit.status ?? "allowed",
+    ...args.rateLimit.utilizationPercent === void 0 ? {} : {
+      utilization_percent: Math.min(
+        100,
+        Math.max(0, Math.round(args.rateLimit.utilizationPercent))
+      )
     },
-    client_message_id: claudeRateLimitClientMessageId(
-      args.threadId,
-      args.rateLimit
-    )
+    ...args.rateLimit.resetsAtMs === void 0 ? {} : { resets_at_ms: args.rateLimit.resetsAtMs }
   });
 }
-function claudeRateLimitClientMessageId(threadId, rateLimit) {
-  const digest = createHash5("sha256").update(`${threadId}:${claudeRateLimitSignature(rateLimit)}`).digest("hex").slice(0, 32);
-  return `claude-rate-limit-${digest}`;
-}
 async function publishStartInstanceMessageState(kandan, topic, control, status, reason, diagnostics = {}) {
   const payload = startInstanceMessageStatePayload(
     control,
@@ -26562,9 +27393,11 @@ function channelSessionPortForwardWatcherOptions(args) {
     ...args.rootPid === void 0 ? [] : [args.rootPid],
     ...args.commanderBoundPids ?? []
   ];
+  const commanderBoundPorts = args.commanderBoundPorts ?? [];
   return {
     ...args.rootPid === void 0 ? {} : { rootPid: args.rootPid },
     ...commanderBoundPids.length === 0 ? {} : { commanderBoundPids },
+    ...commanderBoundPorts.length === 0 ? {} : { commanderBoundPorts },
     ...args.start === void 0 ? {} : { start: args.start }
   };
 }
@@ -28366,6 +29199,7 @@ var init_runner = __esm({
     init_commanderAttachments();
     init_claudeCodePipeline();
     init_claudeCodePlanMirror();
+    init_engineChildReaper();
     init_claudeCodeLiveBashOutput();
     init_claudeCodeSession();
     init_codexAppServer();
@@ -28388,6 +29222,7 @@ var init_runner = __esm({
     init_protocol();
     init_runnerLogger();
     init_runnerLock();
+    init_runnerLockTakeover();
     init_runnerConsoleReporter();
     init_version();
     init_telemetry();
@@ -28428,7 +29263,7 @@ var init_runner = __esm({
 });
 
 // src/kandanTls.ts
-import { existsSync as existsSync13, readFileSync as readFileSync17 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync17 } from "node:fs";
 import { Agent } from "undici";
 import WsWebSocket from "ws";
 function kandanTlsTrustFromEnv() {
@@ -28439,7 +29274,7 @@ function kandanTlsTrustFromCaFile(caFile) {
     return void 0;
   }
   const trimmed = caFile.trim();
-  if (!existsSync13(trimmed)) {
+  if (!existsSync14(trimmed)) {
     throw new Error(`KANDAN_TLS_CA_FILE does not exist: ${trimmed}`);
   }
   const ca = readFileSync17(trimmed, "utf8");
@@ -48717,7 +49552,7 @@ __export(signupFlow_exports, {
 });
 import { spawn as spawn12, spawnSync as spawnSync7 } from "node:child_process";
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   constants as fsConstants,
   mkdirSync as mkdirSync15,
   mkdtempSync as mkdtempSync5,
@@ -48845,7 +49680,7 @@ function defaultSignupDraftStore(serviceUrl) {
   const path2 = defaultSignupDraftPath(serviceUrl);
   return {
     read: () => {
-      if (!existsSync16(path2)) {
+      if (!existsSync17(path2)) {
         return void 0;
       }
       let parsed;
@@ -48924,7 +49759,7 @@ function defaultSignupTaskCachePath(serviceUrl) {
   );
 }
 function readSignupTaskCache(path2) {
-  if (!existsSync16(path2)) {
+  if (!existsSync17(path2)) {
     return { version: 1, entries: {} };
   }
   let parsed;
@@ -51752,7 +52587,7 @@ async function discoverCodeRoots(homeDir) {
   const candidates = ["src", "code", "projects"].map(
     (name) => join23(homeDir, name)
   );
-  return candidates.filter((path2) => existsSync16(path2)).flatMap((path2) => discoveredProjectNames(path2));
+  return candidates.filter((path2) => existsSync17(path2)).flatMap((path2) => discoveredProjectNames(path2));
 }
 function discoveredProjectNames(root) {
   try {
@@ -51856,25 +52691,25 @@ function looksLikeProject(path2) {
     "pnpm-lock.yaml",
     "yarn.lock",
     "package-lock.json"
-  ].some((name) => existsSync16(join23(path2, name)));
+  ].some((name) => existsSync17(join23(path2, name)));
 }
 function detectProjectLanguage(path2) {
-  if (existsSync16(join23(path2, "pyproject.toml")) || existsSync16(join23(path2, "requirements.txt"))) {
+  if (existsSync17(join23(path2, "pyproject.toml")) || existsSync17(join23(path2, "requirements.txt"))) {
     return "Python";
   }
-  if (existsSync16(join23(path2, "Cargo.toml"))) {
+  if (existsSync17(join23(path2, "Cargo.toml"))) {
     return "Rust";
   }
-  if (existsSync16(join23(path2, "go.mod"))) {
+  if (existsSync17(join23(path2, "go.mod"))) {
     return "Go";
   }
-  if (existsSync16(join23(path2, "mix.exs"))) {
+  if (existsSync17(join23(path2, "mix.exs"))) {
     return "Elixir";
   }
-  if (existsSync16(join23(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
+  if (existsSync17(join23(path2, "tsconfig.json")) || packageJsonMentionsTypeScript(path2)) {
     return "TypeScript";
   }
-  if (existsSync16(join23(path2, "package.json"))) {
+  if (existsSync17(join23(path2, "package.json"))) {
     return "JavaScript";
   }
   return "Project";
@@ -51890,7 +52725,7 @@ function packageJsonMentionsTypeScript(path2) {
   }
 }
 function hasGitMetadata(path2) {
-  return existsSync16(join23(path2, ".git"));
+  return existsSync17(join23(path2, ".git"));
 }
 function childDirectories(root) {
   try {
@@ -52011,9 +52846,10 @@ secure mission control for all your agents on your computers
 // src/index.ts
 init_onboardingDiscoveryChildProcess();
 init_runner();
+init_runnerLockTakeover();
 init_claudeCodeSession();
 init_authCache();
-import { existsSync as existsSync17, readFileSync as readFileSync22, realpathSync as realpathSync7 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync22, realpathSync as realpathSync7 } from "node:fs";
 import { homedir as homedir17 } from "node:os";
 import { resolve as resolve11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
@@ -52109,7 +52945,7 @@ init_kandanTls();
 init_protocol();
 init_json();
 init_defaultUrls();
-import { existsSync as existsSync14, mkdirSync as mkdirSync13, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync13, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "node:fs";
 import { dirname as dirname14, join as join21 } from "node:path";
 import { homedir as homedir14 } from "node:os";
 async function runAgentCliCommand(args, deps = {
@@ -52828,7 +53664,7 @@ function authorizationHeaders(token) {
   return { authorization: `Bearer ${token}` };
 }
 function readOptionalTextFile(path2) {
-  return existsSync14(path2) ? readFileSync18(path2, "utf8") : void 0;
+  return existsSync15(path2) ? readFileSync18(path2, "utf8") : void 0;
 }
 function writeTextFile(path2, content) {
   mkdirSync13(dirname14(path2), { recursive: true });
@@ -52919,7 +53755,7 @@ init_helloLinzumiProject();
 // src/commanderDaemon.ts
 init_runnerLogger();
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   closeSync as closeSync3,
   mkdirSync as mkdirSync14,
   openSync as openSync4,
@@ -53013,7 +53849,7 @@ function startCommanderDaemon(options) {
 }
 function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), processIdentityReader = readProcessIdentity) {
   const statusFile = commanderStatusFile(runnerId, statusDir);
-  if (!existsSync15(statusFile)) {
+  if (!existsSync16(statusFile)) {
     return { status: "missing", runnerId, statusFile };
   }
   const record = parseRecord(readFileSync19(statusFile, "utf8"));
@@ -53021,7 +53857,7 @@ function commanderDaemonStatus(runnerId, statusDir = commanderStatusDir(), proce
 }
 async function waitForCommanderDaemon(options) {
   const now = options.now ?? (() => Date.now());
-  const readTextFile = options.readTextFile ?? ((path2) => existsSync15(path2) ? readFileSync19(path2, "utf8") : void 0);
+  const readTextFile = options.readTextFile ?? ((path2) => existsSync16(path2) ? readFileSync19(path2, "utf8") : void 0);
   const statusImpl = options.statusImpl ?? commanderDaemonStatus;
   const deadline = now() + options.timeoutMs;
   while (now() <= deadline) {
@@ -66236,6 +67072,11 @@ var flagDefinitions = /* @__PURE__ */ new Map([
   ["command", { kind: "value" }],
   ["owner-username", { kind: "value" }],
   ["include-token", { kind: "boolean" }],
+  // Interactive lock-conflict resolution on connect: --take-over stops a live
+  // holder without a prompt (automation); --no-input forces non-interactive so
+  // a TTY never blocks on the takeover prompt (falls back to report + exit 1).
+  ["take-over", { kind: "boolean" }],
+  ["no-input", { kind: "boolean" }],
   ["help", { kind: "boolean" }]
 ]);
 var helloFlagDefinitions = /* @__PURE__ */ new Map([
@@ -66252,8 +67093,11 @@ if (isMainModule()) {
   try {
     await main(process.argv.slice(2));
   } catch (error) {
-    process.stderr.write(`${cliErrorMessage(error)}
+    const message = cliErrorMessage(error);
+    if (message !== "") {
+      process.stderr.write(`${message}
 `);
+    }
     process.exit(1);
   }
 }
@@ -66676,6 +67520,9 @@ async function runCommanderDaemonCommand(args) {
   }
 }
 function cliErrorMessage(error) {
+  if (isRunnerLockConflictReportedError(error)) {
+    return "";
+  }
   return signupPromptCancelMessage2(error) ?? userFacingErrorMessage(error, { includeSupportLine: true });
 }
 function signupPromptCancelMessage2(error) {
@@ -66963,7 +67810,7 @@ async function parseAgentRunnerArgs(args, deps = {
   };
 }
 function readAgentTokenTextFile(path2) {
-  return existsSync17(path2) ? readFileSync22(path2, "utf8") : void 0;
+  return existsSync18(path2) ? readFileSync22(path2, "utf8") : void 0;
 }
 function rejectAgentRunnerTargetingFlags(values) {
   const unsupportedFlags = [
@@ -67138,7 +67985,11 @@ async function parseRunnerArgs(args, deps = {
     workspaceSlug: workspaceSlug ?? singleWorkspaceScopeFromAccessToken(token),
     runtimeDefaults: runnerRuntimeDefaultsFromValues(values),
     onboardingDiscovery,
-    channelSession: void 0
+    channelSession: void 0,
+    lockTakeover: {
+      takeOverWithoutPrompt: values.get("take-over") === true,
+      forceNonInteractive: values.get("no-input") === true
+    }
   };
 }
 function runnerRuntimeDefaultsFromValues(values) {
@@ -67488,6 +68339,8 @@ Connection:
 
 Workspace:
   --workspace <slug>          Workspace slug
+  --take-over                 If another runner already holds this workspace, stop it and run here (no prompt)
+  --no-input                  Never prompt; if the workspace is held, print the conflict and exit
 
 Codex:
   --cwd <path>                Working directory for Codex, default current directory