lark-coding-assistant 0.2.3 → 0.2.5

package/dist/daemon-entry.js

@@ -12,6 +12,7 @@ function runFile(file, args, options = {}) {
       {
         cwd: options.cwd,
         timeout: options.timeoutMs ?? 1e4,
+        signal: options.signal,
         encoding: "utf8",
         maxBuffer: 4 * 1024 * 1024
       },
@@ -110,8 +111,8 @@ import { isAbsolute, normalize, resolve } from "path";
 var AppError = class extends Error {
   code;
   context;
-  constructor(code, message, context = {}, options = {}) {
-    super(message, options);
+  constructor(code, message2, context = {}, options = {}) {
+    super(message2, options);
     this.name = "AppError";
     this.code = code;
     this.context = context;
@@ -120,6 +121,13 @@ var AppError = class extends Error {
 function isAppError(error) {
   return error instanceof AppError;
 }
+function asAppError(error, code = "UNKNOWN", context = {}) {
+  if (isAppError(error)) {
+    if (Object.keys(context).length === 0) return error;
+    return new AppError(error.code, error.message, { ...context, ...error.context }, { cause: error });
+  }
+  return new AppError(code, errorMessage(error), context, { cause: error });
+}
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -293,16 +301,138 @@ function validSessionId(value) {
 
 // src/session/startup-failure.ts
 function sessionStartupFailure(result2, fallback) {
-  if (result2.ok || result2.errorCode !== "AGENT_EXITED_DURING_STARTUP") return void 0;
+  if (result2.ok || result2.errorCode !== "AGENT_EXITED_DURING_STARTUP" && result2.errorCode !== "SESSION_START_TIMEOUT") return void 0;
   const context = result2.errorContext ?? {};
   return {
     sessionId: typeof context.sessionId === "string" ? context.sessionId : fallback.sessionId,
     agent: fallback.agent,
+    reason: result2.errorCode === "SESSION_START_TIMEOUT" ? "timeout" : "exited",
+    ...typeof context.cwd === "string" ? { cwd: context.cwd } : {},
+    ...typeof context.stage === "string" ? { stage: context.stage } : {},
+    ...typeof context.elapsedMs === "number" ? { elapsedMs: context.elapsedMs } : {},
     ...typeof context.exitStatus === "number" ? { exitStatus: context.exitStatus } : {},
     terminalExcerpt: typeof context.terminalExcerpt === "string" && context.terminalExcerpt.trim() ? context.terminalExcerpt : "Agent \u672A\u8F93\u51FA\u53EF\u7528\u9519\u8BEF\u4FE1\u606F\u3002"
   };
 }
 
+// src/session/start-coordinator.ts
+import { randomUUID } from "crypto";
+var SessionStartCoordinator = class {
+  constructor(timeoutMs = 3e4, log = async () => void 0) {
+    this.timeoutMs = timeoutMs;
+    this.log = log;
+  }
+  timeoutMs;
+  log;
+  active = /* @__PURE__ */ new Map();
+  async run(descriptor, execute, cleanup) {
+    const existing = this.active.get(descriptor.sessionId);
+    if (existing) {
+      return {
+        ok: false,
+        error: new AppError("SESSION_STARTING", `session is already starting: ${descriptor.sessionId}`, {
+          sessionId: descriptor.sessionId,
+          agent: descriptor.agent,
+          cwd: descriptor.cwd,
+          startId: existing.startId,
+          elapsedMs: Date.now() - existing.startedAt
+        })
+      };
+    }
+    const startId = randomUUID();
+    const startedAt = Date.now();
+    const deadline = startedAt + this.timeoutMs;
+    const controller = new AbortController();
+    let currentStage = "initializing";
+    const fields = logFields({ ...descriptor, startId });
+    const context = {
+      ...descriptor,
+      startId,
+      startedAt,
+      deadline,
+      signal: controller.signal,
+      remainingMs: () => Math.max(1, deadline - Date.now()),
+      stage: async (name, operation2) => {
+        if (controller.signal.aborted || Date.now() >= deadline) {
+          throw timeoutError(descriptor, startId, name, startedAt, this.timeoutMs);
+        }
+        currentStage = name;
+        const stageStartedAt = Date.now();
+        await this.record(`session start stage requested: ${fields} stage=${name}`);
+        try {
+          const value = await operation2();
+          await this.record(`session start stage succeeded: ${fields} stage=${name} elapsedMs=${Date.now() - stageStartedAt}`);
+          return value;
+        } catch (error) {
+          const normalized = controller.signal.aborted || Date.now() >= deadline ? timeoutError(descriptor, startId, name, startedAt, this.timeoutMs) : asAppError(error, "START_FAILED", startErrorContext(descriptor, startId, name, startedAt));
+          await this.record(`session start stage failed: ${fields} stage=${name} code=${normalized.code} elapsedMs=${Date.now() - stageStartedAt}`);
+          throw normalized;
+        } finally {
+          if (currentStage === name) currentStage = "finalizing";
+        }
+      }
+    };
+    this.active.set(descriptor.sessionId, { startId, startedAt });
+    await this.record(`session start requested: ${fields}`);
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        const error = timeoutError(descriptor, startId, currentStage, startedAt, this.timeoutMs);
+        controller.abort(error);
+        reject(error);
+      }, this.timeoutMs);
+    });
+    const operation = execute(context);
+    try {
+      const value = await Promise.race([operation, timeout]);
+      await this.record(`session start succeeded: ${fields} elapsedMs=${Date.now() - startedAt}`);
+      return { ok: true, value };
+    } catch (error) {
+      const normalized = controller.signal.aborted || Date.now() >= deadline ? timeoutError(descriptor, startId, errorStage(error), startedAt, this.timeoutMs) : asAppError(error, "START_FAILED", startErrorContext(descriptor, startId, errorStage(error), startedAt));
+      if (!controller.signal.aborted) controller.abort(normalized);
+      await operation.catch(() => void 0);
+      await cleanup(context, normalized).catch(async (cleanupError) => {
+        await this.record(`session start cleanup failed: ${fields} code=${normalized.code} detail=${message(cleanupError)}`);
+      });
+      await this.record(`${normalized.code === "SESSION_START_TIMEOUT" ? "session start timed out" : "session start failed"}: ${fields} code=${normalized.code} stage=${String(normalized.context.stage ?? "unknown")} elapsedMs=${Date.now() - startedAt}`);
+      return { ok: false, error: normalized };
+    } finally {
+      if (timer) clearTimeout(timer);
+      this.active.delete(descriptor.sessionId);
+    }
+  }
+  async record(message2) {
+    await this.log(message2).catch(() => void 0);
+  }
+};
+function timeoutError(descriptor, startId, stage, startedAt, timeoutMs) {
+  return new AppError("SESSION_START_TIMEOUT", `session start exceeded ${timeoutMs} ms: ${descriptor.sessionId}`, {
+    ...startErrorContext(descriptor, startId, stage, startedAt),
+    timeoutMs
+  });
+}
+function startErrorContext(descriptor, startId, stage, startedAt) {
+  return {
+    sessionId: descriptor.sessionId,
+    agent: descriptor.agent,
+    cwd: descriptor.cwd,
+    resume: descriptor.resume?.mode ?? "new",
+    source: descriptor.source,
+    startId,
+    stage,
+    elapsedMs: Date.now() - startedAt
+  };
+}
+function errorStage(error) {
+  return error instanceof AppError && typeof error.context.stage === "string" ? error.context.stage : "unknown";
+}
+function logFields(descriptor) {
+  return `startId=${descriptor.startId} source=${descriptor.source} session=${descriptor.sessionId} agent=${descriptor.agent} cwd=${JSON.stringify(descriptor.cwd)} resume=${descriptor.resume?.mode ?? "new"}`;
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/session/reconciler.ts
 var SessionReconciler = class {
   constructor(tmux, sessionPrefix = "lark-coding-assistant", missingThreshold = 3, log = async () => void 0, resolveAgentVersion = async () => "unknown") {
@@ -318,11 +448,12 @@ var SessionReconciler = class {
   log;
   resolveAgentVersion;
   misses = /* @__PURE__ */ new Map();
-  async reconcile(input, discover = false) {
+  async reconcile(input, discover = false, signal) {
     const sessions = { ...input.sessions };
     let changed = false;
     for (const [id, session] of Object.entries(sessions)) {
-      const result2 = await this.confirm(session);
+      if (signal?.aborted) throw signal.reason;
+      const result2 = await this.confirm(session, signal);
       if (result2.status === "unavailable") {
         await this.log(`tmux inspection unavailable for ${id}: ${errorMessage2(result2.error)}`);
         continue;
@@ -336,7 +467,7 @@ var SessionReconciler = class {
         continue;
       }
       if (result2.status === "dead") {
-        await this.tmux.killSession(result2.pane.sessionName).catch((error) => this.log(
+        await this.tmux.killSession(result2.pane.sessionName, signal).catch((error) => this.log(
           `failed to clean dead tmux session ${result2.pane.sessionName}: ${errorMessage2(error)}`
         ));
         delete sessions[id];
@@ -352,7 +483,7 @@ var SessionReconciler = class {
       changed = true;
     }
     if (discover) {
-      changed = await this.discover(sessions) || changed;
+      changed = await this.discover(sessions, signal) || changed;
     }
     const activeSessionId = input.activeSessionId && sessions[input.activeSessionId] ? input.activeSessionId : Object.keys(sessions)[0];
     if (activeSessionId !== input.activeSessionId) changed = true;
@@ -360,17 +491,17 @@ var SessionReconciler = class {
     const state = changed ? { ...input, sessions, activeSessionId, updatedAt: Date.now() } : input;
     return { state, liveSessions: Object.values(sessions), removedActive, changed };
   }
-  async confirm(session) {
-    const direct = await this.tmux.inspectStatus(session.paneId);
+  async confirm(session, signal) {
+    const direct = await this.tmux.inspectStatus(session.paneId, signal);
     if (direct.status === "live" || direct.status === "unavailable") return direct;
-    const byName = await this.tmux.inspectSession(session.sessionName);
+    const byName = await this.tmux.inspectSession(session.sessionName, signal);
     if (byName.status === "live" || byName.status === "unavailable") return byName;
     return byName.status === "dead" ? byName : direct;
   }
-  async discover(sessions) {
+  async discover(sessions, signal) {
     let panes;
     try {
-      panes = await this.tmux.listSessions(`${this.sessionPrefix}-`);
+      panes = await this.tmux.listSessions(`${this.sessionPrefix}-`, signal);
     } catch (error) {
       await this.log(`tmux session discovery unavailable: ${errorMessage2(error)}`);
       return false;
@@ -379,11 +510,12 @@ var SessionReconciler = class {
     const seen = /* @__PURE__ */ new Set();
     const liveSessionNames = new Set(panes.filter((pane) => !pane.dead).map((pane) => pane.sessionName));
     for (const pane of panes) {
+      if (signal?.aborted) throw signal.reason;
       if (seen.has(pane.sessionName)) continue;
       seen.add(pane.sessionName);
       if (pane.dead) {
         if (!liveSessionNames.has(pane.sessionName)) {
-          await this.tmux.killSession(pane.sessionName).catch((error) => this.log(
+          await this.tmux.killSession(pane.sessionName, signal).catch((error) => this.log(
             `failed to clean orphaned dead tmux session ${pane.sessionName}: ${errorMessage2(error)}`
           ));
         }
@@ -395,19 +527,19 @@ var SessionReconciler = class {
           sessions[registered.id] = { ...registered, paneId: pane.paneId, updatedAt: Date.now() };
           changed = true;
         }
-        if (!await this.tmux.readMetadata(pane.sessionName)) {
-          await this.writeMetadata(pane, registered).catch((error) => this.log(
+        if (!await this.tmux.readMetadata(pane.sessionName, signal)) {
+          await this.writeMetadata(pane, registered, signal).catch((error) => this.log(
             `failed to backfill tmux metadata for ${registered.id}: ${errorMessage2(error)}`
           ));
         }
         continue;
       }
-      const metadata = await this.tmux.readMetadata(pane.sessionName);
-      const recovered = metadata ? this.fromMetadata(pane, metadata) : await this.fromLegacy(pane);
+      const metadata = await this.tmux.readMetadata(pane.sessionName, signal);
+      const recovered = metadata ? this.fromMetadata(pane, metadata) : await this.fromLegacy(pane, signal);
       if (!recovered || sessions[recovered.id]) continue;
       if (!metadata) {
         try {
-          await this.writeMetadata(pane, recovered);
+          await this.writeMetadata(pane, recovered, signal);
         } catch (error) {
           await this.log(`failed to persist recovered tmux metadata for ${recovered.id}: ${errorMessage2(error)}`);
           continue;
@@ -433,11 +565,11 @@ var SessionReconciler = class {
       updatedAt: Date.now()
     };
   }
-  async fromLegacy(pane) {
+  async fromLegacy(pane, signal) {
     const id = pane.sessionName.startsWith(`${this.sessionPrefix}-`) ? pane.sessionName.slice(this.sessionPrefix.length + 1) : "";
     const agent = inferLegacyAgent(pane);
     if (!validSessionId(id) || !agent) return void 0;
-    const agentVersion = await this.resolveAgentVersion(agent).catch(() => "unknown");
+    const agentVersion = await this.resolveAgentVersion(agent, signal).catch(() => "unknown");
     return {
       id,
       agent,
@@ -448,7 +580,7 @@ var SessionReconciler = class {
       updatedAt: Date.now()
     };
   }
-  writeMetadata(pane, session) {
+  writeMetadata(pane, session, signal) {
     return this.tmux.writeMetadata(pane.sessionName, {
       managed: true,
       sessionId: session.id,
@@ -456,7 +588,7 @@ var SessionReconciler = class {
       cwd: session.cwd,
       agentVersion: session.agentVersion,
       agentSessionId: session.agentSessionId
-    });
+    }, signal);
   }
 };
 function inferLegacyAgent(pane) {
@@ -476,17 +608,17 @@ import { readdir, readFile as readFile2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { join } from "path";
 var UUID = "[0-9a-fA-F-]{32,36}";
-async function resolveNativeAgentSessionId(agent, pid, home = homedir2()) {
+async function resolveNativeAgentSessionId(agent, pid, home = homedir2(), signal) {
   if (!Number.isInteger(pid) || pid <= 0) return void 0;
   if (agent === "traex") {
     const peer = await resolveTraexPeer(pid, home);
     if (peer) return peer;
     return matchPath(
-      await processOpenFiles(pid),
+      await processOpenFiles(pid, signal),
       new RegExp(`/\\.trae/cli/sessions/.+/rollout-[^/]+-(${UUID})\\.jsonl(?:\\.lock)?$`)
     );
   }
-  const openFiles = await processOpenFiles(pid);
+  const openFiles = await processOpenFiles(pid, signal);
   if (agent === "codex") return matchPath(openFiles, new RegExp(`/\\.codex/thread-writer-locks/(${UUID})\\.lock$`));
   return matchPath(openFiles, new RegExp(`/\\.claude/projects/[^/]+/(${UUID})\\.jsonl$`));
 }
@@ -502,8 +634,8 @@ async function resolveTraexPeer(pid, home) {
   }
   return void 0;
 }
-async function processOpenFiles(pid) {
-  const result2 = await runFile("lsof", ["-Fn", "-p", String(pid)], { timeoutMs: 3e3 }).catch(() => void 0);
+async function processOpenFiles(pid, signal) {
+  const result2 = await runFile("lsof", ["-Fn", "-p", String(pid)], { timeoutMs: 3e3, signal }).catch(() => void 0);
   if (!result2) return [];
   return result2.stdout.split("\n").filter((line) => line.startsWith("n")).map((line) => line.slice(1));
 }
@@ -558,7 +690,7 @@ var TmuxController = class {
         { sessionId: options.sessionName }
       );
     }
-    if (await this.hasSession(options.sessionName)) {
+    if (await this.hasSession(options.sessionName, options.signal)) {
       throw new AppError(
         "SESSION_EXISTS",
         `tmux session already exists: ${options.sessionName}`,
@@ -590,34 +722,34 @@ var TmuxController = class {
     if (options.preserveOnExit) {
       createArgs.push(";", "set-option", "-w", "-t", `=${options.sessionName}:`, "remain-on-exit", "on");
     }
-    await runFile(this.binary, createArgs);
-    const pane = await this.findBySession(options.sessionName);
+    await runFile(this.binary, createArgs, { signal: options.signal });
+    const pane = await this.findBySession(options.sessionName, options.signal);
     if (!pane) throw new Error("tmux created a session without a discoverable pane");
     return pane;
   }
-  async hasSession(sessionName) {
+  async hasSession(sessionName, signal) {
     try {
-      await runFile(this.binary, ["has-session", "-t", `=${sessionName}`]);
+      await runFile(this.binary, ["has-session", "-t", `=${sessionName}`], { signal });
       return true;
     } catch {
       return false;
     }
   }
-  async findBySession(sessionName) {
+  async findBySession(sessionName, signal) {
     const { stdout } = await runFile(this.binary, [
       "list-panes",
       "-t",
       `=${sessionName}`,
       "-F",
       PANE_FORMAT
-    ]);
+    ], { signal });
     return stdout.split("\n").map(parsePane).find(Boolean);
   }
-  async inspect(paneId) {
-    const result2 = await this.inspectStatus(paneId);
+  async inspect(paneId, signal) {
+    const result2 = await this.inspectStatus(paneId, signal);
     return result2.status === "live" || result2.status === "dead" ? result2.pane : void 0;
   }
-  async inspectStatus(paneId) {
+  async inspectStatus(paneId, signal) {
     assertSafeTmuxTarget(paneId);
     try {
       const { stdout } = await runFile(this.binary, [
@@ -626,7 +758,7 @@ var TmuxController = class {
         "-t",
         paneId,
         PANE_FORMAT
-      ]);
+      ], { signal });
       if (!stdout.trim()) return { status: "missing" };
       const pane = parsePane(stdout.trim());
       if (!pane) return { status: "unavailable", error: new Error("invalid tmux pane response") };
@@ -635,20 +767,20 @@ var TmuxController = class {
       return tmuxTargetMissing(error) ? { status: "missing" } : { status: "unavailable", error };
     }
   }
-  async inspectSession(sessionName) {
+  async inspectSession(sessionName, signal) {
     try {
-      const pane = await this.findBySession(sessionName);
+      const pane = await this.findBySession(sessionName, signal);
       if (!pane) return { status: "missing" };
       return pane.dead ? { status: "dead", pane } : { status: "live", pane };
     } catch (error) {
       return tmuxTargetMissing(error) ? { status: "missing" } : { status: "unavailable", error };
     }
   }
-  async listSessions(prefix) {
-    const { stdout } = await runFile(this.binary, ["list-panes", "-a", "-F", PANE_FORMAT]);
+  async listSessions(prefix, signal) {
+    const { stdout } = await runFile(this.binary, ["list-panes", "-a", "-F", PANE_FORMAT], { signal });
     return stdout.split("\n").map(parsePane).filter((pane) => Boolean(pane?.sessionName.startsWith(prefix)));
   }
-  async writeMetadata(sessionName, metadata) {
+  async writeMetadata(sessionName, metadata, signal) {
     const values = {
       managed: "1",
       sessionId: metadata.sessionId,
@@ -660,16 +792,16 @@ var TmuxController = class {
     for (const [key, option2] of Object.entries(METADATA_OPTIONS)) {
       const value = values[key];
       if (value === void 0) {
-        await runFile(this.binary, ["set-option", "-u", "-t", sessionName, option2]).catch(() => void 0);
+        await runFile(this.binary, ["set-option", "-u", "-t", sessionName, option2], { signal }).catch(() => void 0);
       } else {
-        await runFile(this.binary, ["set-option", "-t", sessionName, option2, value]);
+        await runFile(this.binary, ["set-option", "-t", sessionName, option2, value], { signal });
       }
     }
   }
-  async readMetadata(sessionName) {
+  async readMetadata(sessionName, signal) {
     const values = {};
     for (const [key, option2] of Object.entries(METADATA_OPTIONS)) {
-      const result2 = await runFile(this.binary, ["show-options", "-t", sessionName, "-v", option2]).catch(() => void 0);
+      const result2 = await runFile(this.binary, ["show-options", "-t", sessionName, "-v", option2], { signal }).catch(() => void 0);
       if (!result2) {
         if (key === "agentSessionId") continue;
         return void 0;
@@ -686,7 +818,7 @@ var TmuxController = class {
       agentSessionId: values.agentSessionId || void 0
     };
   }
-  async capture(paneId, lines = 200) {
+  async capture(paneId, lines = 200, signal) {
     assertSafeTmuxTarget(paneId);
     const { stdout } = await runFile(this.binary, [
       "capture-pane",
@@ -697,10 +829,10 @@ var TmuxController = class {
       paneId,
       "-S",
       `-${Math.max(1, lines)}`
-    ]);
+    ], { signal });
     return stdout;
   }
-  async preserveOnExit(sessionName, enabled) {
+  async preserveOnExit(sessionName, enabled, signal) {
     await runFile(this.binary, [
       "set-option",
       "-w",
@@ -708,7 +840,7 @@ var TmuxController = class {
       `=${sessionName}:`,
       "remain-on-exit",
       enabled ? "on" : "off"
-    ]);
+    ], { signal });
   }
   sendText(paneId, input, submit = true) {
     assertSafeTmuxTarget(paneId);
@@ -727,16 +859,16 @@ var TmuxController = class {
     this.writes = this.writes.then(operation, operation);
     return this.writes;
   }
-  async sendKey(paneId, key) {
+  async sendKey(paneId, key, signal) {
     assertSafeTmuxTarget(paneId);
     if (!/^(Enter|Escape|Space|Tab|BSpace|Up|Down|Left|Right|PPage|NPage|C-c|C-u|C-k|C-Enter|[yandpcq1-9])$/.test(key)) {
       throw new Error(`unsupported tmux key: ${key}`);
     }
-    await runFile(this.binary, ["send-keys", "-t", paneId, key]);
+    await runFile(this.binary, ["send-keys", "-t", paneId, key], { signal });
   }
-  async killSession(sessionName) {
+  async killSession(sessionName, signal) {
     try {
-      await runFile(this.binary, ["kill-session", "-t", `=${sessionName}`]);
+      await runFile(this.binary, ["kill-session", "-t", `=${sessionName}`], { signal });
     } catch (error) {
       if (!tmuxTargetMissing(error)) throw error;
     }
@@ -766,9 +898,9 @@ function parsePane(line) {
   };
 }
 function tmuxTargetMissing(error) {
-  const message = error instanceof Error ? error.message : String(error);
+  const message2 = error instanceof Error ? error.message : String(error);
   const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr) : "";
-  return /can't find (?:pane|session|window)|no such (?:pane|session|window)|(?:pane|session|window) not found|no server running/i.test(`${message}
+  return /can't find (?:pane|session|window)|no such (?:pane|session|window)|(?:pane|session|window) not found|no server running/i.test(`${message2}
 ${stderr}`);
 }
 
@@ -1823,6 +1955,25 @@ function sessionCreateFailureCard(chatId, content, signer) {
   ], "red");
 }
 function sessionStartupFailureCard(chatId, failure, signer) {
+  if (failure.reason === "timeout") {
+    const details = [
+      `\u26A0\uFE0F **Session**  \`${escapeInlineCode(failure.sessionId)}\``,
+      `**Agent**  ${escapeMarkdown(getAgentAdapter(failure.agent).displayName)}`,
+      `**\u5DE5\u4F5C\u76EE\u5F55**  \`${escapeInlineCode(failure.cwd ?? "\u672A\u77E5")}\``,
+      `**\u7ED3\u679C**  \u542F\u52A8\u8D85\u8FC7 30 \u79D2\uFF0C\u5DF2\u53D6\u6D88\u5E76\u6E05\u7406`,
+      `**\u8D85\u65F6\u9636\u6BB5**  \`${escapeInlineCode(failure.stage ?? "unknown")}\``
+    ].join("\n");
+    const output = failure.terminalExcerpt.trim() ? [{ tag: "markdown", content: `**\u6700\u8FD1\u7EC8\u7AEF\u8F93\u51FA**
+
+\`\`\`text
+${escapeFence(failure.terminalExcerpt)}
+\`\`\`` }] : [];
+    return cardElements("Session \u542F\u52A8\u5931\u8D25", [
+      { tag: "markdown", content: details },
+      ...output,
+      ...sessionFailureActions(chatId, failure.sessionId, failure.agent, signer)
+    ], "red");
+  }
   const exitStatus = failure.exitStatus === void 0 ? "\u672A\u77E5" : String(failure.exitStatus);
   return cardElements("Session \u542F\u52A8\u5931\u8D25", [
     {
@@ -2133,7 +2284,7 @@ var LarkGateway = class {
       httpTimeoutMs: 3e4,
       respectProxyEnv: true
     });
-    this.channel.on("message", async (message) => this.handler.onMessage(message));
+    this.channel.on("message", async (message2) => this.handler.onMessage(message2));
     this.channel.on("cardAction", async (event) => {
       console.error(`[lca] card action received: tag=${event.action.tag ?? "unknown"} name=${event.action.name ?? "-"} message=${event.messageId}`);
       const mappedFormAction = event.action.formValue && event.action.name ? this.formActions.get(event.messageId)?.get(event.action.name) : void 0;
@@ -2383,22 +2534,22 @@ var LarkGateway = class {
     await Promise.all([...chats].map((chatId) => this.clearProcessing(chatId)));
     await this.channel.disconnect();
   }
-  async startProcessing(message) {
-    await this.clearProcessing(message.chatId);
-    const generation = this.processingGenerations.get(message.chatId) ?? 0;
+  async startProcessing(message2) {
+    await this.clearProcessing(message2.chatId);
+    const generation = this.processingGenerations.get(message2.chatId) ?? 0;
     try {
-      const reactionId = await this.channel.addReaction(message.messageId, "Typing");
-      if (this.processingGenerations.get(message.chatId) !== generation) {
-        await this.removeProcessingReaction(message.messageId, reactionId);
+      const reactionId = await this.channel.addReaction(message2.messageId, "Typing");
+      if (this.processingGenerations.get(message2.chatId) !== generation) {
+        await this.removeProcessingReaction(message2.messageId, reactionId);
         return;
       }
       const timer = setTimeout(() => {
-        void this.clearProcessing(message.chatId, generation);
+        void this.clearProcessing(message2.chatId, generation);
       }, 10 * 6e4);
       timer.unref?.();
-      this.processingReactions.set(message.chatId, { messageId: message.messageId, reactionId, timer, generation });
+      this.processingReactions.set(message2.chatId, { messageId: message2.messageId, reactionId, timer, generation });
     } catch (error) {
-      console.error(`[lca] failed to add processing reaction: chat=${message.chatId} message=${message.messageId} detail=${cardErrorDetail(error)}`);
+      console.error(`[lca] failed to add processing reaction: chat=${message2.chatId} message=${message2.messageId} detail=${cardErrorDetail(error)}`);
     }
   }
   sendText(chatId, text) {
@@ -2561,8 +2712,8 @@ function cardErrorDetail(error) {
   const data = response && typeof response === "object" ? response.data : void 0;
   const record = data && typeof data === "object" ? data : void 0;
   const code = typeof record?.code === "number" || typeof record?.code === "string" ? String(record.code) : void 0;
-  const message = typeof record?.msg === "string" ? record.msg : error instanceof Error ? error.message : String(error);
-  const sanitized = message.replace(/(?:authorization\s*:\s*bearer|bearer)\s+[^\s,'"\]}]+/gi, "Bearer [REDACTED]").replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 1200);
+  const message2 = typeof record?.msg === "string" ? record.msg : error instanceof Error ? error.message : String(error);
+  const sanitized = message2.replace(/(?:authorization\s*:\s*bearer|bearer)\s+[^\s,'"\]}]+/gi, "Bearer [REDACTED]").replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 1200);
   return code ? `code=${code} ${sanitized}` : sanitized;
 }
 
@@ -2915,7 +3066,7 @@ var WorkspaceSnapshotStore = class {
 
 // src/daemon/server.ts
 var AssistantDaemon = class {
-  constructor(store, paths2, gatewayFactory = (config, secrets, handler) => new LarkGateway(config, secrets, handler), sessionName = "lark-coding-assistant", stopHookCommand = "lark-coding-assistant-hook", completionQuietMs = 2500, appVersion = "dev") {
+  constructor(store, paths2, gatewayFactory = (config, secrets, handler) => new LarkGateway(config, secrets, handler), sessionName = "lark-coding-assistant", stopHookCommand = "lark-coding-assistant-hook", completionQuietMs = 2500, appVersion = "dev", sessionStartTimeoutMs = 3e4) {
     this.store = store;
     this.paths = paths2;
     this.gatewayFactory = gatewayFactory;
@@ -2923,6 +3074,7 @@ var AssistantDaemon = class {
     this.stopHookCommand = stopHookCommand;
     this.completionQuietMs = completionQuietMs;
     this.appVersion = appVersion;
+    this.sessionStarts = new SessionStartCoordinator(sessionStartTimeoutMs, (message2) => this.log(message2));
   }
   store;
   paths;
@@ -2955,6 +3107,8 @@ var AssistantDaemon = class {
   pendingResumePickers = /* @__PURE__ */ new Map();
   pendingStartupConflicts = /* @__PURE__ */ new Map();
   workspaceSnapshots = new WorkspaceSnapshotStore();
+  sessionStarts;
+  startStateWrites = Promise.resolve();
   pendingInteractionInput;
   attachAttempts = /* @__PURE__ */ new Map();
   server = createServer((socket) => this.handleSocket(socket));
@@ -2969,10 +3123,10 @@ var AssistantDaemon = class {
       this.tmux,
       this.sessionName,
       3,
-      (message) => this.log(message),
-      async (agent) => {
+      (message2) => this.log(message2),
+      async (agent, signal) => {
         const adapter = getAgentAdapter(agent);
-        return (await runFile(adapter.binary(this.config), [...adapter.versionArgs])).stdout.trim();
+        return (await runFile(adapter.binary(this.config), [...adapter.versionArgs], { signal })).stdout.trim();
       }
     );
     const secrets = await this.store.loadSecrets();
@@ -2987,7 +3141,7 @@ var AssistantDaemon = class {
       });
       await chmod3(this.paths.socket, 384);
       this.gateway = this.gatewayFactory(config, secrets, {
-        onMessage: (message) => this.onLarkMessage(message),
+        onMessage: (message2) => this.onLarkMessage(message2),
         onAction: (event, action) => this.onLarkAction(event, action),
         onResumePickerDeliveryFailure: (session) => this.handleResumePickerDeliveryFailure(session)
       });
@@ -3091,14 +3245,36 @@ var AssistantDaemon = class {
         return this.handleTurnComplete(request.candidate);
     }
   }
-  async startSession(sessionId, cwd, agentId, resume) {
+  async startSession(sessionId, cwd, agentId, resume, source = "cli") {
     try {
       const validated = await validateStartSessionRequest({ sessionId, cwd, agent: agentId, resume });
       cwd = validated.cwd;
     } catch (error) {
       return fail(error);
     }
-    await this.reconcileSessions(true);
+    let createdSessionName;
+    const outcome = await this.sessionStarts.run(
+      { sessionId, cwd, agent: agentId, resume, source },
+      async (context) => {
+        const result2 = await this.startSessionCore(
+          sessionId,
+          cwd,
+          agentId,
+          resume,
+          context,
+          (sessionName) => {
+            createdSessionName = sessionName;
+          }
+        );
+        if (!result2.ok) throw daemonResultAppError(result2);
+        return result2.value;
+      },
+      async (_context, error) => this.cleanupStartTransaction(sessionId, createdSessionName, error)
+    );
+    return outcome.ok ? { ok: true, value: outcome.value } : fail(outcome.error);
+  }
+  async startSessionCore(sessionId, cwd, agentId, resume, context, created) {
+    await context.stage("reconcile", () => this.reconcileSessions(true, context.signal));
     const existing = this.state.sessions?.[sessionId];
     if (existing) {
       return fail(new AppError(
@@ -3118,14 +3294,17 @@ var AssistantDaemon = class {
     const binary = adapter.binary(this.config);
     let agentVersion;
     try {
-      agentVersion = (await runFile(binary, [...adapter.versionArgs])).stdout.trim();
+      agentVersion = (await context.stage("agent-version", () => runFile(binary, [...adapter.versionArgs], {
+        timeoutMs: context.remainingMs(),
+        signal: context.signal
+      }))).stdout.trim();
     } catch (error) {
-      return fail(systemErrorCode(error) === "ENOENT" ? new AppError("BINARY_NOT_FOUND", `command not found: ${binary}`, { binary }, { cause: error }) : new AppError("START_FAILED", `failed to inspect agent binary: ${binary}`, { sessionId }, { cause: error }));
+      return fail(isAppError(error) ? error : systemErrorCode(error) === "ENOENT" ? new AppError("BINARY_NOT_FOUND", `command not found: ${binary}`, { binary }, { cause: error }) : new AppError("START_FAILED", `failed to inspect agent binary: ${binary}`, { sessionId }, { cause: error }));
     }
     const tmuxSessionName = `${this.sessionName}-${sessionId}`;
     let pane;
     try {
-      pane = await this.tmux.create({
+      pane = await context.stage("tmux-create", () => this.tmux.create({
         sessionName: tmuxSessionName,
         cwd,
         binary,
@@ -3138,8 +3317,10 @@ var AssistantDaemon = class {
           LARK_CODING_ASSISTANT_SESSION_ID: sessionId,
           LARK_CODING_ASSISTANT_AGENT: agentId
         },
-        preserveOnExit: true
-      });
+        preserveOnExit: true,
+        signal: context.signal
+      }));
+      created(pane.sessionName);
     } catch (error) {
       return fail(isAppError(error) ? error : new AppError("START_FAILED", "failed to create tmux session", { sessionId }, { cause: error }));
     }
@@ -3154,81 +3335,128 @@ var AssistantDaemon = class {
       updatedAt: Date.now()
     };
     const pendingClaim = this.pendingAgentSessionClaims.get(sessionId);
-    if (pendingClaim?.agent === agentId) {
-      const owner = this.findAgentSessionOwner(agentId, pendingClaim.agentSessionId, sessionId);
-      if (owner) {
-        this.pendingAgentSessionClaims.delete(sessionId);
-        await this.tmux.killSession(pane.sessionName).catch(() => void 0);
-        return fail(agentSessionInUse(sessionId, owner.id));
-      }
-      session.agentSessionId = pendingClaim.agentSessionId;
-      this.pendingAgentSessionClaims.delete(sessionId);
-    }
-    try {
-      await this.tmux.writeMetadata(pane.sessionName, {
-        managed: true,
-        sessionId,
-        agent: agentId,
-        cwd,
-        agentVersion,
-        agentSessionId: session.agentSessionId
-      });
-    } catch (error) {
-      await this.tmux.killSession(pane.sessionName).catch((cleanupError) => this.log(
-        `failed to clean session ${sessionId} after metadata error: ${errorMessage3(cleanupError)}`
-      ));
-      return fail(new AppError("START_FAILED", "failed to persist tmux session metadata", { sessionId }, { cause: error }));
-    }
-    const nextState = {
-      ...this.state,
-      sessions: { ...this.state.sessions, [sessionId]: session },
-      activeSessionId: this.state.activeSessionId ?? sessionId,
-      boundChatId: binding.mode === "reused" ? this.state.boundChatId : void 0,
-      bindCodeHash: binding.mode === "code" ? hashBindCode(binding.bindCode) : void 0,
-      bindCodeExpiresAt: binding.mode === "code" ? Date.now() + 10 * 6e4 : void 0,
-      updatedAt: Date.now()
-    };
-    try {
-      await this.store.saveState(nextState);
-    } catch (error) {
-      await this.tmux.killSession(pane.sessionName).catch((cleanupError) => this.log(
-        `failed to clean session ${sessionId} after state error: ${errorMessage3(cleanupError)}`
-      ));
-      return fail(new AppError("START_FAILED", "failed to persist session state", { sessionId }, { cause: error }));
-    }
-    this.state = nextState;
-    const lateClaim = this.pendingAgentSessionClaims.get(sessionId);
-    if (lateClaim) {
-      const claimed = await this.handleAgentSessionStarted(lateClaim);
-      if (!claimed.ok) {
-        await this.stopSession(sessionId).catch(() => void 0);
-        return claimed;
-      }
+    if (pendingClaim) {
+      const claimed = this.claimStartingAgentSession(session, pendingClaim);
+      if (!claimed.ok) return claimed;
     }
     if (resume && resume.mode !== "picker") {
-      const initialClaim = await this.waitForInitialAgentSessionClaim(sessionId, pane.pid);
+      const initialClaim = await context.stage(
+        "agent-identity",
+        () => this.waitForInitialAgentSessionClaim(session, pane.pid, context.signal)
+      );
       if (!initialClaim.ok) {
-        await this.stopSession(sessionId).catch(() => void 0);
         return initialClaim;
       }
-    } else if (!resume) {
-      const stable = await this.waitForStartupStability(session, 500);
+    } else {
+      const stable = await context.stage(
+        "startup-stability",
+        () => this.waitForStartupStability(session, 500, context.signal)
+      );
       if (!stable.ok) {
-        await this.stopSession(sessionId).catch(() => void 0);
         return stable;
       }
     }
+    const resumePicker = resume?.mode === "picker" && context.source === "lark" ? await context.stage("resume-picker", async () => {
+      const picker = await this.waitForResumePicker(
+        session,
+        void 0,
+        context.remainingMs(),
+        context.signal
+      );
+      if (!picker) {
+        throw new AppError("START_FAILED", "agent resume picker did not become available", {
+          sessionId,
+          agent: agentId
+        });
+      }
+      return picker;
+    }) : void 0;
     if (resume?.mode !== "picker") {
-      await this.tmux.preserveOnExit(session.sessionName, false).catch((error) => this.log(
+      await this.tmux.preserveOnExit(session.sessionName, false, context.signal).catch((error) => this.log(
         `failed to disable startup preservation for ${sessionId}: ${errorMessage3(error)}`
       ));
       await this.rememberSessionWorkspace(session.cwd);
     }
+    const lateClaim = this.pendingAgentSessionClaims.get(sessionId);
+    if (lateClaim) {
+      const claimed = this.claimStartingAgentSession(session, lateClaim);
+      if (!claimed.ok) return claimed;
+    }
+    try {
+      await context.stage("metadata", () => this.tmux.writeMetadata(pane.sessionName, {
+        managed: true,
+        sessionId,
+        agent: agentId,
+        cwd,
+        agentVersion,
+        agentSessionId: session.agentSessionId
+      }, context.signal));
+      await context.stage("state", () => this.commitStartedSession(session, binding));
+    } catch (error) {
+      return fail(isAppError(error) ? error : new AppError("START_FAILED", "failed to persist completed session", { sessionId }, { cause: error }));
+    }
+    const postCommitClaim = this.pendingAgentSessionClaims.get(sessionId);
+    if (postCommitClaim) {
+      const claimed = await this.handleAgentSessionStarted(postCommitClaim);
+      if (!claimed.ok) return claimed;
+    }
     await this.log(
       `session created: session=${session.id} agent=${session.agent} pane=${session.paneId} active=${this.state.activeSessionId === session.id}`
     );
-    await this.poll().catch((error) => this.log(`initial poll failed for ${sessionId}: ${errorMessage3(error)}`));
-    return { ok: true, value: { pane, session, binding, active: this.state.activeSessionId === sessionId } };
+    return {
+      ok: true,
+      value: { pane, session, binding, active: this.state.activeSessionId === sessionId, resumePicker }
+    };
+  }
+  async cleanupStartTransaction(sessionId, createdSessionName, error) {
+    const session = this.state.sessions?.[sessionId];
+    const ownsSession = Boolean(createdSessionName && session?.sessionName === createdSessionName);
+    const createdPane = createdSessionName ? await this.tmux.findBySession(createdSessionName, AbortSignal.timeout(750)).catch(() => void 0) : void 0;
+    const paneId = ownsSession ? session?.paneId : createdPane?.paneId;
+    if (paneId && !error.context.terminalExcerpt) {
+      const terminalExcerpt = await this.tmux.capture(paneId, 40, AbortSignal.timeout(1e3)).then((output) => startupTerminalExcerpt(tailScreen(output, 40).slice(-3e3))).catch(() => "");
+      if (terminalExcerpt) error.context.terminalExcerpt = terminalExcerpt;
+    }
+    if (session && ownsSession) {
+      await this.stopSession(sessionId, AbortSignal.timeout(2e3)).catch((cleanupError) => this.log(
+        `session start state cleanup failed: session=${sessionId} detail=${errorMessage3(cleanupError)}`
+      ));
+      if (this.state.sessions?.[sessionId]?.sessionName === createdSessionName) {
+        await this.forgetSessionState(sessionId).catch((cleanupError) => this.log(
+          `session start forced state cleanup failed: session=${sessionId} detail=${errorMessage3(cleanupError)}`
+        ));
+      }
+    } else if (createdSessionName) {
+      await this.tmux.killSession(createdSessionName, AbortSignal.timeout(2e3)).catch((cleanupError) => this.log(
+        `session start tmux cleanup failed: session=${sessionId} detail=${errorMessage3(cleanupError)}`
+      ));
+    }
+    this.pendingAgentSessionClaims.delete(sessionId);
+    this.pendingResumePickers.delete(sessionId);
+    this.pendingStartupConflicts.delete(sessionId);
+  }
+  commitStartedSession(session, binding) {
+    const commit = async () => {
+      if (this.state.sessions?.[session.id]) {
+        throw new AppError("SESSION_EXISTS", `managed coding-agent session is already running: ${session.id}`, {
+          sessionId: session.id
+        });
+      }
+      const nextState = {
+        ...this.state,
+        sessions: { ...this.state.sessions, [session.id]: session },
+        activeSessionId: this.state.activeSessionId ?? session.id,
+        boundChatId: binding.mode === "reused" ? this.state.boundChatId : void 0,
+        bindCodeHash: binding.mode === "code" ? hashBindCode(binding.bindCode) : void 0,
+        bindCodeExpiresAt: binding.mode === "code" ? Date.now() + 10 * 6e4 : void 0,
+        updatedAt: Date.now()
+      };
+      await this.store.saveState(nextState);
+      this.state = nextState;
+    };
+    const pending = this.startStateWrites.then(commit, commit);
+    this.startStateWrites = pending.catch(() => void 0);
+    return pending;
   }
   createSessionBinding() {
     if (this.state.ownerOpenId && this.state.boundChatId && !this.state.autoBindDisabled) {
@@ -3291,26 +3519,26 @@ var AssistantDaemon = class {
     await this.tmux.sendText(session.paneId, text);
     return { ok: true };
   }
-  async onLarkMessage(message) {
-    if (message.chatType !== "p2p" || message.senderIsBot || message.senderType === "bot") return;
-    const text = message.content.trim();
+  async onLarkMessage(message2) {
+    if (message2.chatType !== "p2p" || message2.senderIsBot || message2.senderType === "bot") return;
+    const text = message2.content.trim();
     const attachCode = text.match(/^\/attach\s+([^\s]+)\s*$/)?.[1];
     if (!this.state.boundChatId) {
-      if (this.canAutoBind(message)) {
-        await this.bindChat(message, true);
+      if (this.canAutoBind(message2)) {
+        await this.bindChat(message2, true);
       } else {
         if (!attachCode) return;
-        await this.handleAttach(message, attachCode);
+        await this.handleAttach(message2, attachCode);
         return;
       }
     }
-    if (message.senderId !== this.state.ownerOpenId || message.chatId !== this.state.boundChatId) return;
+    if (message2.senderId !== this.state.ownerOpenId || message2.chatId !== this.state.boundChatId) return;
     if (text === "/start") {
       try {
-        await this.gateway?.sendSessionCreate(message.chatId, await this.createSessionWorkspaceView(message.chatId));
+        await this.gateway?.sendSessionCreate(message2.chatId, await this.createSessionWorkspaceView(message2.chatId));
       } catch (error) {
         await this.log(`session create card failed: ${errorMessage3(error)}`);
-        await this.gateway?.sendText(message.chatId, "\u65B0\u5EFA Session \u8868\u5355\u53D1\u9001\u5931\u8D25\u3002\u8BF7\u4F7F\u7528 /start <name> --agent <agent> --cwd <\u7EDD\u5BF9\u8DEF\u5F84>\u3002");
+        await this.gateway?.sendText(message2.chatId, "\u65B0\u5EFA Session \u8868\u5355\u53D1\u9001\u5931\u8D25\u3002\u8BF7\u4F7F\u7528 /start <name> --agent <agent> --cwd <\u7EDD\u5BF9\u8DEF\u5F84>\u3002");
       }
       return;
     }
@@ -3319,37 +3547,37 @@ var AssistantDaemon = class {
       try {
         request = parseStartCommand(text);
       } catch (error) {
-        await this.gateway?.sendText(message.chatId, remoteError(fail(error)));
+        await this.gateway?.sendText(message2.chatId, remoteError(fail(error)));
         return;
       }
       const result3 = await this.startRemoteSession(request);
       if (!result3.ok) {
         const failure = sessionStartupFailure(result3.error, request);
-        if (failure) await this.gateway?.sendSessionStartupFailure(message.chatId, failure);
-        else await this.gateway?.sendText(message.chatId, remoteError(result3.error));
+        if (failure) await this.gateway?.sendSessionStartupFailure(message2.chatId, failure);
+        else await this.gateway?.sendText(message2.chatId, remoteError(result3.error));
       } else if (result3.state === "picker") {
         try {
-          await this.gateway?.sendResumePicker(message.chatId, result3.session, result3.picker);
+          await this.gateway?.sendResumePicker(message2.chatId, result3.session, result3.picker);
         } catch (error) {
           await this.handleResumePickerDeliveryFailure(result3.session);
           await this.log(`resume picker notification failed: session=${result3.session.id} error=${errorMessage3(error)}`);
-          await this.gateway?.sendText(message.chatId, "Resume Picker \u5361\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u4E34\u65F6 Session \u5DF2\u6E05\u7406\uFF0C\u8BF7\u91CD\u8BD5\u3002");
+          await this.gateway?.sendText(message2.chatId, "Resume Picker \u5361\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u4E34\u65F6 Session \u5DF2\u6E05\u7406\uFF0C\u8BF7\u91CD\u8BD5\u3002");
         }
-      } else if (result3.state === "conflict") await this.gateway?.sendStartupConflict(message.chatId, result3.request, result3.owner);
-      else await this.gateway?.sendText(message.chatId, remoteStartSuccess(result3.session));
+      } else if (result3.state === "conflict") await this.gateway?.sendStartupConflict(message2.chatId, result3.request, result3.owner);
+      else await this.gateway?.sendText(message2.chatId, remoteStartSuccess(result3.session));
       return;
     }
     const tailMatch = text.match(/^\/tail(?:\s+(\d+))?$/);
     if (tailMatch) {
       const lines = tailMatch[1] ? Number(tailMatch[1]) : 80;
       if (!Number.isInteger(lines) || lines < 20 || lines > 300) {
-        await this.gateway?.sendText(message.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
+        await this.gateway?.sendText(message2.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
         return;
       }
       const output = await this.tail(lines).catch((error) => `\u8BFB\u53D6\u5931\u8D25\uFF1A${errorMessage3(error)}`);
       const session = this.activeSession();
       const metadata = session ? `**${session.id} \xB7 ${getAgentAdapter(session.agent).displayName}**  \xB7  \u72B6\u6001 \`${this.screen?.state ?? "unknown"}\`  \xB7  ${manualTimestamp()}` : "**\u5F53\u524D\u6CA1\u6709 active session**";
-      await this.gateway?.sendMarkdown(message.chatId, `${metadata}
+      await this.gateway?.sendMarkdown(message2.chatId, `${metadata}
 
 \`\`\`text
 ${escapeFence2(output).slice(-6800)}
@@ -3357,20 +3585,20 @@ ${escapeFence2(output).slice(-6800)}
       return;
     }
     if (text.startsWith("/tail")) {
-      await this.gateway?.sendText(message.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
+      await this.gateway?.sendText(message2.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
       return;
     }
     if (text === "/manual") {
       await this.poll();
       const view2 = this.currentManualView();
-      if (!view2) await this.gateway?.sendText(message.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u9065\u63A7\u7684 active tmux session\u3002");
+      if (!view2) await this.gateway?.sendText(message2.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u9065\u63A7\u7684 active tmux session\u3002");
       else {
         try {
-          await this.gateway?.sendManual(message.chatId, view2);
+          await this.gateway?.sendManual(message2.chatId, view2);
         } catch (error) {
           await this.log(`manual card failed: ${errorMessage3(error)}`);
           await this.gateway?.sendText(
-            message.chatId,
+            message2.chatId,
             "\u624B\u52A8\u9065\u63A7\u5361\u53D1\u9001\u5931\u8D25\u3002\u53EF\u4F7F\u7528 /tail 120 \u67E5\u770B\u7EC8\u7AEF\uFF0C\u6216\u4F7F\u7528 /key\u3001/type\u3001/submit \u64CD\u4F5C\u3002"
           );
         }
@@ -3379,44 +3607,44 @@ ${escapeFence2(output).slice(-6800)}
     }
     const manualKey = text.match(/^\/key\s+(up|down|left|right|enter|esc|tab|space|backspace|ctrl-c)$/i)?.[1];
     if (manualKey) {
-      await this.executeManualCommand(message.chatId, `\u6309\u952E ${manualKey}`, async (session) => {
+      await this.executeManualCommand(message2.chatId, `\u6309\u952E ${manualKey}`, async (session) => {
         await this.tmux.sendKey(session.paneId, manualTmuxKey(manualKey));
       });
       return;
     }
     if (text.startsWith("/key")) {
-      await this.gateway?.sendText(message.chatId, "\u7528\u6CD5\uFF1A/key up|down|left|right|enter|esc|tab|space|backspace|ctrl-c");
+      await this.gateway?.sendText(message2.chatId, "\u7528\u6CD5\uFF1A/key up|down|left|right|enter|esc|tab|space|backspace|ctrl-c");
       return;
     }
     const typeMatch = text.match(/^\/(type|submit)\s+([\s\S]+)$/);
     if (typeMatch?.[1] && typeMatch[2]?.trim()) {
       const submit = typeMatch[1] === "submit";
-      await this.executeManualCommand(message.chatId, submit ? "\u8F93\u5165\u5E76\u63D0\u4EA4" : "\u4EC5\u8F93\u5165", async (session) => {
+      await this.executeManualCommand(message2.chatId, submit ? "\u8F93\u5165\u5E76\u63D0\u4EA4" : "\u4EC5\u8F93\u5165", async (session) => {
         await this.tmux.sendText(session.paneId, typeMatch[2], submit);
       });
       return;
     }
     if (text === "/type" || text === "/submit") {
-      await this.gateway?.sendText(message.chatId, `\u7528\u6CD5\uFF1A${text} <\u6587\u672C>`);
+      await this.gateway?.sendText(message2.chatId, `\u7528\u6CD5\uFF1A${text} <\u6587\u672C>`);
       return;
     }
     if (text === "/status") {
       const status = await this.runtimeStatus();
-      await this.gateway?.sendStatus(message.chatId, status);
+      await this.gateway?.sendStatus(message2.chatId, status);
       return;
     }
     if (text === "/sessions") {
       const sessions = await this.reconcileSessions(true);
       try {
         await this.gateway?.sendSessionPicker(
-          message.chatId,
+          message2.chatId,
           sessions,
           this.state.activeSessionId
         );
       } catch (error) {
         await this.log(`session picker notification failed: ${errorMessage3(error)}`);
         await this.gateway?.sendText(
-          message.chatId,
+          message2.chatId,
           "Session \u9009\u62E9\u5361\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u4E5F\u53EF\u4EE5\u53D1\u9001 /use <session \u540D\u79F0> \u8FDB\u884C\u5207\u6362\u3002"
         );
       }
@@ -3428,7 +3656,7 @@ ${escapeFence2(output).slice(-6800)}
       const target = this.state.sessions?.[useSessionId];
       const reply = result3.ok ? `\u5DF2\u8FDE\u63A5\u5230 ${target ? getAgentAdapter(target.agent).displayName : "coding agent"} session\uFF1A${useSessionId}` : `\u5207\u6362\u5931\u8D25\uFF1A${result3.error}`;
       await this.gateway?.sendText(
-        message.chatId,
+        message2.chatId,
         reply
       );
       return;
@@ -3445,16 +3673,16 @@ ${escapeFence2(output).slice(-6800)}
         updatedAt: Date.now()
       };
       await this.store.saveState(this.state);
-      await this.gateway?.sendText(message.chatId, "\u5DF2\u89E3\u9664\u672C\u6B21\u98DE\u4E66\u7ED1\u5B9A\uFF1Bcoding agent \u548C tmux \u4ECD\u5728\u8FD0\u884C\u3002");
+      await this.gateway?.sendText(message2.chatId, "\u5DF2\u89E3\u9664\u672C\u6B21\u98DE\u4E66\u7ED1\u5B9A\uFF1Bcoding agent \u548C tmux \u4ECD\u5728\u8FD0\u884C\u3002");
       return;
     }
     if (text === "/stop") {
       await this.poll();
       const session = this.activeSession();
       if (!session || !this.screen) {
-        await this.gateway?.sendText(message.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u505C\u6B62\u7684 coding agent \u4F1A\u8BDD\u3002");
+        await this.gateway?.sendText(message2.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u505C\u6B62\u7684 coding agent \u4F1A\u8BDD\u3002");
       } else {
-        await this.gateway?.sendStopConfirmation(message.chatId, session.paneId, this.screen.fingerprint, session.agent);
+        await this.gateway?.sendStopConfirmation(message2.chatId, session.paneId, this.screen.fingerprint, session.agent);
       }
       return;
     }
@@ -3463,15 +3691,15 @@ ${escapeFence2(output).slice(-6800)}
       const session = this.activeSession();
       if (!session || session.id !== pendingInput.sessionId) {
         this.pendingInteractionInput = void 0;
-        await this.gateway?.sendText(message.chatId, "\u4EA4\u4E92\u4F1A\u8BDD\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u64CD\u4F5C\u3002");
+        await this.gateway?.sendText(message2.chatId, "\u4EA4\u4E92\u4F1A\u8BDD\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u64CD\u4F5C\u3002");
         return;
       }
-      await this.tmux.sendText(session.paneId, message.content, pendingInput.submitOnInput);
+      await this.tmux.sendText(session.paneId, message2.content, pendingInput.submitOnInput);
       this.pendingInteractionInput = void 0;
       if (pendingInput.submitOnInput) {
         await this.waitForInteractionChange(pendingInput.interactionId);
         if (this.screen?.interaction?.interactionId === pendingInput.interactionId) {
-          await this.gateway?.sendText(message.chatId, "\u8865\u5145\u5185\u5BB9\u5DF2\u8F93\u5165\uFF0C\u4F46\u7EC8\u7AEF\u4ECD\u505C\u7559\u5728\u539F\u95EE\u9898\uFF0C\u8BF7\u7528 /tail \u68C0\u67E5\u3002");
+          await this.gateway?.sendText(message2.chatId, "\u8865\u5145\u5185\u5BB9\u5DF2\u8F93\u5165\uFF0C\u4F46\u7EC8\u7AEF\u4ECD\u505C\u7559\u5728\u539F\u95EE\u9898\uFF0C\u8BF7\u7528 /tail \u68C0\u67E5\u3002");
           return;
         }
         const content = `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u8865\u5145\u5185\u5BB9\u3002`;
@@ -3481,12 +3709,12 @@ ${escapeFence2(output).slice(-6800)}
       }
       if (pendingInput.role === "custom-input") {
         const refreshed = await this.withInteractionNotificationsSuppressed(async () => {
-          await this.waitForCustomInputValue(pendingInput.interactionId, pendingInput.controlId, message.content);
+          await this.waitForCustomInputValue(pendingInput.interactionId, pendingInput.controlId, message2.content);
           const current = this.screen;
           if (current?.interaction?.semantics && (current.interaction.actionConfidence ?? 0) >= 0.85) {
             await this.gateway?.updateChoice(
               pendingInput.cardMessageId,
-              message.chatId,
+              message2.chatId,
               session.paneId,
               current,
               session.agent
@@ -3497,43 +3725,43 @@ ${escapeFence2(output).slice(-6800)}
         });
         if (refreshed) return;
       }
-      await this.gateway?.sendText(message.chatId, `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u8865\u5145\u5185\u5BB9\u3002`);
+      await this.gateway?.sendText(message2.chatId, `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u8865\u5145\u5185\u5BB9\u3002`);
       return;
     }
-    await this.gateway?.startProcessing(message);
+    await this.gateway?.startProcessing(message2);
     await this.poll();
     if (this.shouldQueueMessage()) {
       if (this.pendingMessages.length >= 100) {
-        await this.gateway?.sendText(message.chatId, "\u5F85\u53D1\u9001\u961F\u5217\u5DF2\u6EE1\uFF0C\u8BF7\u5148\u5904\u7406\u5F53\u524D\u7EC8\u7AEF\u72B6\u6001\u3002");
+        await this.gateway?.sendText(message2.chatId, "\u5F85\u53D1\u9001\u961F\u5217\u5DF2\u6EE1\uFF0C\u8BF7\u5148\u5904\u7406\u5F53\u524D\u7EC8\u7AEF\u72B6\u6001\u3002");
         return;
       }
-      this.pendingMessages.push(message.content);
-      await this.gateway?.sendText(message.chatId, `\u5F53\u524D\u7EC8\u7AEF\u6682\u4E0D\u53EF\u5B89\u5168\u5199\u5165\uFF0C\u6D88\u606F\u5DF2\u6392\u961F\uFF08${this.pendingMessages.length} \u6761\uFF09\u3002`);
+      this.pendingMessages.push(message2.content);
+      await this.gateway?.sendText(message2.chatId, `\u5F53\u524D\u7EC8\u7AEF\u6682\u4E0D\u53EF\u5B89\u5168\u5199\u5165\uFF0C\u6D88\u606F\u5DF2\u6392\u961F\uFF08${this.pendingMessages.length} \u6761\uFF09\u3002`);
       return;
     }
-    const result2 = await this.send(message.content);
-    if (!result2.ok) await this.gateway?.sendText(message.chatId, `\u672A\u53D1\u9001\uFF1A${result2.error}`);
+    const result2 = await this.send(message2.content);
+    if (!result2.ok) await this.gateway?.sendText(message2.chatId, `\u672A\u53D1\u9001\uFF1A${result2.error}`);
   }
-  async handleAttach(message, code) {
-    if (this.state.ownerOpenId && message.senderId !== this.state.ownerOpenId) return;
-    if (!this.allowAttachAttempt(message.senderId)) return;
+  async handleAttach(message2, code) {
+    if (this.state.ownerOpenId && message2.senderId !== this.state.ownerOpenId) return;
+    if (!this.allowAttachAttempt(message2.senderId)) return;
     const valid = Boolean(
       this.state.bindCodeHash && this.state.bindCodeExpiresAt && this.state.bindCodeExpiresAt >= Date.now() && verifyBindCode(code, this.state.bindCodeHash)
     );
     if (!valid) {
-      await this.gateway?.sendText(message.chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u7ED1\u5B9A\u7801\u65E0\u6548\u6216\u5DF2\u8FC7\u671F\u3002");
+      await this.gateway?.sendText(message2.chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u7ED1\u5B9A\u7801\u65E0\u6548\u6216\u5DF2\u8FC7\u671F\u3002");
       return;
     }
-    await this.bindChat(message, false);
+    await this.bindChat(message2, false);
   }
-  canAutoBind(message) {
-    return !this.state.autoBindDisabled && Boolean(this.state.ownerOpenId) && message.senderId === this.state.ownerOpenId;
+  canAutoBind(message2) {
+    return !this.state.autoBindDisabled && Boolean(this.state.ownerOpenId) && message2.senderId === this.state.ownerOpenId;
   }
-  async bindChat(message, automatic) {
+  async bindChat(message2, automatic) {
     this.state = {
       ...this.state,
-      ownerOpenId: this.state.ownerOpenId ?? message.senderId,
-      boundChatId: message.chatId,
+      ownerOpenId: this.state.ownerOpenId ?? message2.senderId,
+      boundChatId: message2.chatId,
       autoBindDisabled: false,
       bindCodeHash: void 0,
       bindCodeExpiresAt: void 0,
@@ -3541,7 +3769,7 @@ ${escapeFence2(output).slice(-6800)}
     };
     await this.store.saveState(this.state);
     await this.gateway?.sendText(
-      message.chatId,
+      message2.chatId,
       automatic ? "\u5DF2\u81EA\u52A8\u8FDE\u63A5\u5F53\u524D coding agent \u4F1A\u8BDD\u3002\u4E4B\u540E\u76F4\u63A5\u53D1\u9001\u666E\u901A\u6D88\u606F\u5373\u53EF\u3002" : "\u7ED1\u5B9A\u6210\u529F\u3002\u4E4B\u540E\u7684\u666E\u901A\u6D88\u606F\u4F1A\u53D1\u9001\u5230\u5F53\u524D tmux \u4E2D\u7684 coding agent\uFF1B\u53EF\u7528 /tail\u3001/status\u3001/sessions\u3001/detach\u3001/stop\u3002"
     );
     this.previousScreen = void 0;
@@ -3810,21 +4038,42 @@ ${escapeFence2(output).slice(-6800)}
     const optionId = action.action.startsWith("select:") ? action.action.slice("select:".length) : "";
     const option2 = picker.options.find((candidate) => candidate.id === optionId);
     if (!option2) return { type: "resume-picker", content: "\u6240\u9009\u9879\u5DF2\u53D8\u5316\uFF0C\u5DF2\u5237\u65B0\u3002", session, picker };
-    const delta = option2.visibleIndex - picker.selectedIndex;
-    const key = delta < 0 ? "Up" : "Down";
-    for (let step = 0; step < Math.abs(delta); step += 1) await this.tmux.sendKey(session.paneId, key);
-    const pane = await this.tmux.inspect(session.paneId);
-    if (!pane || pane.dead) {
-      this.pendingResumePickers.delete(sessionId);
-      return larkStartupError(fail(await this.startupExitedError(session, pane)), request);
-    }
-    await this.tmux.sendKey(session.paneId, "Enter");
-    this.pendingResumePickers.delete(sessionId);
-    const claimed = await this.waitForInitialAgentSessionClaim(sessionId, pane.pid);
-    if (!claimed.ok) {
-      await this.stopSession(sessionId).catch(() => void 0);
-      if (claimed.errorCode === "AGENT_SESSION_IN_USE") {
-        const ownerSessionId = typeof claimed.errorContext?.ownerSessionId === "string" ? claimed.errorContext.ownerSessionId : void 0;
+    const restored = await this.sessionStarts.run(
+      { sessionId, agent: session.agent, cwd: session.cwd, resume: request.resume, source: "resume-picker" },
+      async (context) => {
+        const restoringSession = { ...session };
+        const delta = option2.visibleIndex - picker.selectedIndex;
+        const key = delta < 0 ? "Up" : "Down";
+        await context.stage("resume-selection", async () => {
+          for (let step = 0; step < Math.abs(delta); step += 1) {
+            await this.tmux.sendKey(session.paneId, key, context.signal);
+          }
+          const pane = await this.tmux.inspect(session.paneId, context.signal);
+          if (!pane || pane.dead) throw await this.startupExitedError(session, pane);
+          await this.tmux.sendKey(session.paneId, "Enter", context.signal);
+          this.pendingResumePickers.delete(sessionId);
+          const claimed = await this.waitForInitialAgentSessionClaim(restoringSession, pane.pid, context.signal);
+          if (!claimed.ok) throw daemonResultAppError(claimed);
+          if (restoringSession.agentSessionId) {
+            const persisted = await this.handleAgentSessionStarted({
+              sessionId,
+              agent: session.agent,
+              agentSessionId: restoringSession.agentSessionId,
+              cwd: session.cwd,
+              source: "resume-picker"
+            });
+            if (!persisted.ok) throw daemonResultAppError(persisted);
+          }
+          await this.tmux.preserveOnExit(session.sessionName, false, context.signal);
+        });
+        return session;
+      },
+      async (_context, error) => this.cleanupStartTransaction(sessionId, session.sessionName, error)
+    );
+    if (!restored.ok) {
+      const failed = fail(restored.error);
+      if (restored.error.code === "AGENT_SESSION_IN_USE") {
+        const ownerSessionId = typeof restored.error.context.ownerSessionId === "string" ? restored.error.context.ownerSessionId : void 0;
         const owner = ownerSessionId ? this.state.sessions?.[ownerSessionId] : void 0;
         if (owner) {
           this.pendingStartupConflicts.set(sessionId, { request, ownerSessionId: owner.id });
@@ -3836,18 +4085,17 @@ ${escapeFence2(output).slice(-6800)}
           };
         }
       }
-      return larkStartupError(claimed, request);
+      return larkStartupError(failed, request);
     }
-    await this.tmux.preserveOnExit(session.sessionName, false).catch(() => void 0);
     const selected = await this.useSession(sessionId);
     if (!selected.ok) return { type: "error", content: remoteError(selected) };
     await this.rememberSessionWorkspace(session.cwd);
     return { type: "session-created", content: remoteStartSuccess(session), session };
   }
-  async readResumePicker(session) {
-    const pane = await this.tmux.inspect(session.paneId);
+  async readResumePicker(session, signal) {
+    const pane = await this.tmux.inspect(session.paneId, signal);
     if (!pane || pane.dead) return void 0;
-    const raw = await this.tmux.capture(session.paneId, 120).catch(() => "");
+    const raw = await this.tmux.capture(session.paneId, 120, signal).catch(() => "");
     return parseResumePicker(raw, session.agent);
   }
   async handleResumePickerDeliveryFailure(candidate) {
@@ -3856,13 +4104,14 @@ ${escapeFence2(output).slice(-6800)}
     await this.log(`resume picker delivery failed; rolling back provisional session: session=${candidate.id} pane=${candidate.paneId}`);
     await this.stopSession(candidate.id);
   }
-  async waitForResumePicker(session, previousFingerprint, timeoutMs = 2500) {
+  async waitForResumePicker(session, previousFingerprint, timeoutMs = 2500, signal) {
     const deadline = Date.now() + timeoutMs;
     let latest;
     while (Date.now() < deadline) {
-      latest = await this.readResumePicker(session);
+      if (signal?.aborted) throw signal.reason;
+      latest = await this.readResumePicker(session, signal);
       if (latest && (!previousFingerprint || latest.fingerprint !== previousFingerprint)) return latest;
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      await abortableDelay(100, signal);
     }
     return latest;
   }
@@ -4087,13 +4336,25 @@ ${escapeFence2(output).slice(-6500)}
       if (focusedIndex === targetIndex) return { ok: true };
       const direction = targetIndex > focusedIndex ? "Down" : "Up";
       await this.tmux.sendKey(paneId, direction);
-      await new Promise((resolve2) => setTimeout(resolve2, 40));
-      await this.poll();
-      const nextFocused = this.screen?.actions.findIndex(({ focused }) => focused) ?? -1;
-      if (nextFocused === focusedIndex) return { ok: false, error: "terminal focus did not move as expected" };
+      const moved = await this.waitForFocusMove(interactionId, focusedIndex);
+      if (!moved.ok) return moved;
     }
     return { ok: false, error: "terminal focus navigation exceeded its safe step limit" };
   }
+  async waitForFocusMove(interactionId, previousIndex) {
+    const deadline = Date.now() + 1200;
+    while (Date.now() < deadline) {
+      await new Promise((resolve2) => setTimeout(resolve2, 60));
+      await this.poll();
+      const interaction = this.screen?.interaction;
+      if (!interaction || interaction.interactionId !== interactionId) {
+        return { ok: false, error: "interaction changed while navigating; refusing action" };
+      }
+      const focusedIndex = this.screen?.actions.findIndex(({ focused }) => focused) ?? -1;
+      if (focusedIndex !== -1 && focusedIndex !== previousIndex) return { ok: true };
+    }
+    return { ok: false, error: "terminal focus did not move before the navigation timeout" };
+  }
   async waitForInteractionChange(interactionId) {
     const deadline = Date.now() + 1500;
     while (Date.now() < deadline) {
@@ -4180,7 +4441,7 @@ ${escapeFence2(output).slice(-6500)}
     }
     return { ok: true, committed: false };
   }
-  async stopSession(sessionId = this.state.activeSessionId) {
+  async stopSession(sessionId = this.state.activeSessionId, signal) {
     if (!sessionId) {
       return fail(new AppError("SESSION_NOT_FOUND", "no active managed session", { sessionId: "default" }));
     }
@@ -4188,9 +4449,11 @@ ${escapeFence2(output).slice(-6500)}
     if (!session) {
       return fail(new AppError("SESSION_NOT_FOUND", `unknown session: ${sessionId}`, { sessionId }));
     }
-    if (await this.tmux.hasSession(session.sessionName)) {
-      await this.tmux.killSession(session.sessionName);
-    }
+    await this.tmux.killSession(session.sessionName, signal);
+    await this.forgetSessionState(sessionId);
+    return { ok: true };
+  }
+  async forgetSessionState(sessionId) {
     const sessions = { ...this.state.sessions };
     delete sessions[sessionId];
     this.pendingResumePickers.delete(sessionId);
@@ -4217,7 +4480,6 @@ ${escapeFence2(output).slice(-6500)}
       this.unresolvedNotified.clear();
     }
     await this.store.saveState(this.state);
-    return { ok: true };
   }
   async resetOwner() {
     this.pendingMessages.length = 0;
@@ -4426,37 +4688,75 @@ ${escapeFence2(output).slice(-6500)}
       });
     }
   }
-  async waitForInitialAgentSessionClaim(sessionId, panePid) {
+  async waitForInitialAgentSessionClaim(session, panePid, signal) {
     const deadline = Date.now() + 3500;
     while (Date.now() < deadline) {
-      const session2 = this.state.sessions?.[sessionId];
-      if (!session2) return { ok: false, error: `session disappeared during startup: ${sessionId}` };
-      if (session2.agentSessionId) return { ok: true };
-      const pane2 = await this.tmux.inspect(session2.paneId);
-      if (!pane2 || pane2.dead) return fail(await this.startupExitedError(session2, pane2));
-      const agentSessionId = await resolveNativeAgentSessionId(session2.agent, panePid).catch(() => void 0);
+      if (session.agentSessionId) return { ok: true };
+      const committedClaim2 = this.state.sessions?.[session.id]?.agentSessionId;
+      if (committedClaim2) {
+        session.agentSessionId = committedClaim2;
+        return { ok: true };
+      }
+      const pending2 = this.pendingAgentSessionClaims.get(session.id);
+      if (pending2) {
+        const claimed = this.claimStartingAgentSession(session, pending2);
+        if (!claimed.ok || session.agentSessionId) return claimed;
+      }
+      if (signal?.aborted) throw signal.reason;
+      const pane2 = await this.tmux.inspect(session.paneId, signal);
+      if (signal?.aborted) throw signal.reason;
+      if (!pane2 || pane2.dead) return fail(await this.startupExitedError(session, pane2));
+      const agentSessionId = await resolveNativeAgentSessionId(
+        session.agent,
+        panePid,
+        void 0,
+        signal
+      ).catch(() => void 0);
       if (agentSessionId) {
-        return this.handleAgentSessionStarted({
-          sessionId,
-          agent: session2.agent,
+        return this.claimStartingAgentSession(session, {
+          sessionId: session.id,
+          agent: session.agent,
           agentSessionId,
-          cwd: session2.cwd,
+          cwd: session.cwd,
           source: "startup-discovery"
         });
       }
-      await new Promise((resolve2) => setTimeout(resolve2, 100));
+      await abortableDelay(100, signal);
     }
-    const session = this.state.sessions?.[sessionId];
-    if (!session) return fail(new AppError("SESSION_NOT_FOUND", `session disappeared during startup: ${sessionId}`, { sessionId }));
-    const pane = await this.tmux.inspect(session.paneId);
+    const pane = await this.tmux.inspect(session.paneId, signal);
+    if (signal?.aborted) throw signal.reason;
     if (!pane || pane.dead) return fail(await this.startupExitedError(session, pane));
-    if (session.agentSessionId || this.pendingAgentSessionClaims.has(sessionId)) return { ok: true };
+    const pending = this.pendingAgentSessionClaims.get(session.id);
+    if (pending) return this.claimStartingAgentSession(session, pending);
+    const committedClaim = this.state.sessions?.[session.id]?.agentSessionId;
+    if (committedClaim) {
+      session.agentSessionId = committedClaim;
+      return { ok: true };
+    }
+    if (session.agentSessionId) return { ok: true };
     return fail(new AppError(
       "AGENT_IDENTITY_TIMEOUT",
-      `unable to identify resumed native session: ${sessionId}`,
-      { sessionId, agent: session.agent }
+      `unable to identify resumed native session: ${session.id}`,
+      { sessionId: session.id, agent: session.agent }
     ));
   }
+  claimStartingAgentSession(session, candidate) {
+    if (candidate.agent !== session.agent) {
+      return fail(new AppError("START_FAILED", "agent-session candidate does not match starting session", {
+        sessionId: session.id,
+        agent: session.agent
+      }));
+    }
+    const owner = this.findAgentSessionOwner(candidate.agent, candidate.agentSessionId, session.id);
+    if (owner) {
+      this.pendingAgentSessionClaims.delete(session.id);
+      return fail(agentSessionInUse(session.id, owner.id));
+    }
+    session.agentSessionId = candidate.agentSessionId;
+    session.updatedAt = Date.now();
+    this.pendingAgentSessionClaims.delete(session.id);
+    return { ok: true };
+  }
   async startupExitedError(session, pane) {
     const terminalTail = await this.tmux.capture(session.paneId, 40).then((output) => tailScreen(output, 40).slice(-3e3)).catch(() => "");
     return new AppError(
@@ -4470,12 +4770,14 @@ ${escapeFence2(output).slice(-6500)}
       }
     );
   }
-  async waitForStartupStability(session, durationMs) {
+  async waitForStartupStability(session, durationMs, signal) {
     const deadline = Date.now() + durationMs;
     while (Date.now() < deadline) {
-      const pane = await this.tmux.inspect(session.paneId);
+      if (signal?.aborted) throw signal.reason;
+      const pane = await this.tmux.inspect(session.paneId, signal);
+      if (signal?.aborted) throw signal.reason;
       if (!pane || pane.dead) return fail(await this.startupExitedError(session, pane));
-      await new Promise((resolve2) => setTimeout(resolve2, 80));
+      await abortableDelay(80, signal);
     }
     return { ok: true };
   }
@@ -4538,13 +4840,13 @@ ${output}`
     const session = this.activeSession();
     if (!session || this.shouldQueueMessage()) return;
     while (this.pendingMessages.length > 0 && !this.shouldQueueMessage()) {
-      const message = this.pendingMessages[0];
-      if (!message) {
+      const message2 = this.pendingMessages[0];
+      if (!message2) {
         this.pendingMessages.shift();
         continue;
       }
       this.clearPendingCompletion();
-      await this.tmux.sendText(session.paneId, message);
+      await this.tmux.sendText(session.paneId, message2);
       this.pendingMessages.shift();
     }
     if (this.pendingMessages.length === 0 && this.state.boundChatId) {
@@ -4553,9 +4855,9 @@ ${output}`
   activeSession() {
     return this.state.activeSessionId ? this.state.sessions?.[this.state.activeSessionId] : void 0;
   }
-  async reconcileSessions(discover = false) {
+  async reconcileSessions(discover = false, signal) {
     const previousActive = this.state.activeSessionId;
-    const result2 = await this.reconciler.reconcile(this.state, discover);
+    const result2 = await this.reconciler.reconcile(this.state, discover, signal);
     if (!result2.changed) return result2.liveSessions;
     const activeChanged = result2.state.activeSessionId !== previousActive;
     if (result2.removedActive) {
@@ -4612,7 +4914,7 @@ ${output}`
     await this.log(
       `remote session create requested: session=${request.sessionId} agent=${request.agent} resume=${request.resume?.mode ?? "new"}`
     );
-    const started = await this.startSession(request.sessionId, request.cwd, request.agent, request.resume);
+    const started = await this.startSession(request.sessionId, request.cwd, request.agent, request.resume, "lark");
     if (!started.ok) {
       await this.log(`remote session create failed: session=${request.sessionId} code=${started.errorCode ?? "UNKNOWN"}`);
       if (started.errorCode === "AGENT_SESSION_IN_USE") {
@@ -4632,7 +4934,7 @@ ${output}`
     }
     const session = selected.value;
     if (request.resume?.mode === "picker") {
-      const picker = await this.waitForResumePicker(session);
+      const picker = started.value.resumePicker;
       if (picker) {
         this.pendingResumePickers.set(session.id, request);
         return { ok: true, state: "picker", session, picker };
@@ -4704,14 +5006,36 @@ ${output}`
       `failed to persist recent workspace: cwd=${cwd} error=${errorMessage3(error)}`
     ));
   }
-  async log(message) {
-    await appendFile(this.paths.logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
+  async log(message2) {
+    await appendFile(this.paths.logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${message2}
 `, { mode: 384 });
   }
 };
 function fail(error) {
   return { ok: false, ...serializeAppError(error) };
 }
+function daemonResultAppError(result2) {
+  return new AppError(
+    result2.errorCode ?? "START_FAILED",
+    result2.error,
+    result2.errorContext ?? {}
+  );
+}
+function abortableDelay(ms, signal) {
+  if (!signal) return new Promise((resolve2) => setTimeout(resolve2, ms));
+  if (signal.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", aborted);
+      resolve2();
+    }, ms);
+    const aborted = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", aborted, { once: true });
+  });
+}
 function agentSessionInUse(sessionId, ownerSessionId) {
   return new AppError(
     "AGENT_SESSION_IN_USE",
@@ -4786,6 +5110,21 @@ function remoteError(result2) {
   switch (result2.errorCode) {
     case "SESSION_EXISTS":
       return context.source === "tmux" ? `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\uFF1A\u68C0\u6D4B\u5230\u540C\u540D tmux \u4F1A\u8BDD\uFF0C\u4F46\u5B83\u672A\u767B\u8BB0\u4E3A\u53EF\u8FDE\u63A5\u7684 LCA session\u3002\u8BF7\u6362\u4E00\u4E2A\u540D\u79F0\uFF0C\u6216\u5728\u672C\u673A\u68C0\u67E5 tmux \u4F1A\u8BDD\u3002` : `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\uFF1A\u8BE5 session \u5DF2\u5728\u8FD0\u884C\u3002\u8BF7\u6362\u4E00\u4E2A\u540D\u79F0\uFF0C\u6216\u7528 /sessions \u8FDE\u63A5\u73B0\u6709 session\u3002`;
+    case "SESSION_STARTING":
+      return `session\u300C${sessionId}\u300D\u6B63\u5728\u542F\u52A8\uFF0C\u8BF7\u7B49\u5F85\u5F53\u524D\u64CD\u4F5C\u5B8C\u6210\u540E\u518D\u8BD5\u3002`;
+    case "SESSION_START_TIMEOUT": {
+      const agent = typeof context.agent === "string" ? context.agent : "Agent";
+      const cwd = typeof context.cwd === "string" ? context.cwd : "\u672A\u77E5\u76EE\u5F55";
+      const stage = typeof context.stage === "string" ? context.stage : "unknown";
+      const excerpt = typeof context.terminalExcerpt === "string" && context.terminalExcerpt.trim() ? `
+
+\u6700\u8FD1\u7EC8\u7AEF\u8F93\u51FA\uFF1A
+${context.terminalExcerpt}` : "";
+      return `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\uFF1A${agent} \u542F\u52A8\u8D85\u8FC7 30 \u79D2\uFF0C\u5DF2\u53D6\u6D88\u5E76\u6E05\u7406\u3002
+
+\u5DE5\u4F5C\u76EE\u5F55\uFF1A${cwd}
+\u8D85\u65F6\u9636\u6BB5\uFF1A${stage}${excerpt}`;
+    }
     case "AGENT_SESSION_IN_USE": {
       const ownerSessionId = typeof context.ownerSessionId === "string" ? context.ownerSessionId : "\u73B0\u6709 session";
       return `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\uFF1A\u8BE5 Agent \u539F\u751F session \u5DF2\u7531 LCA session\u300C${ownerSessionId}\u300D\u8FDE\u63A5\u3002\u8BF7\u7528 /sessions \u8FDE\u63A5\u73B0\u6709 session\u3002`;