lark-coding-assistant 0.1.3 → 0.2.1

package/dist/daemon-entry.js

@@ -1,5 +1,5 @@
 // src/daemon/server.ts
-import { appendFile, chmod as chmod3, open as open2, readFile as readFile2, rm } from "fs/promises";
+import { appendFile, chmod as chmod3, open as open2, readFile as readFile3, rm } from "fs/promises";
 import { createServer } from "net";
 
 // src/platform/process.ts
@@ -92,6 +92,14 @@ async function writeJsonAtomic(path, value, mode = 384) {
   await chmod(path, mode);
 }
 
+// src/agents/types.ts
+var AGENT_IDS = ["codex", "traex", "claude"];
+function normalizeAgentId(value) {
+  if (value === "trae-cli") return "traex";
+  if (value === "claude-code") return "claude";
+  return AGENT_IDS.includes(value) ? value : void 0;
+}
+
 // src/core/store.ts
 var AppStore = class {
   constructor(paths2) {
@@ -108,8 +116,21 @@ var AppStore = class {
       chmod2(this.paths.logsDir, 448)
     ]);
   }
-  loadConfig() {
-    return readJson(this.paths.config);
+  async loadConfig() {
+    const config = await readJson(this.paths.config);
+    if (!config) return void 0;
+    const binaries = config.agentBinaries ?? {};
+    return {
+      tenant: config.tenant,
+      appId: config.appId,
+      tmuxBinary: config.tmuxBinary,
+      agentBinaries: {
+        codex: binaries.codex ?? "codex",
+        traex: binaries.traex ?? binaries["trae-cli"] ?? "trae-cli",
+        claude: binaries.claude ?? binaries["claude-code"] ?? "claude"
+      },
+      pollIntervalMs: config.pollIntervalMs
+    };
   }
   saveConfig(config) {
     return writeJsonAtomic(this.paths.config, config);
@@ -121,7 +142,13 @@ var AppStore = class {
     return writeJsonAtomic(this.paths.secrets, secrets);
   }
   async loadState() {
-    return await readJson(this.paths.state) ?? emptyState();
+    const state = await readJson(this.paths.state);
+    if (!state) return emptyState();
+    const sessions = Object.fromEntries(Object.entries(state.sessions ?? {}).flatMap(([id, session]) => {
+      const agent = normalizeAgentId(session.agent);
+      return agent ? [[id, { ...session, agent }]] : [];
+    }));
+    return { ...state, sessions };
   }
   saveState(state) {
     return writeJsonAtomic(this.paths.state, state);
@@ -171,6 +198,246 @@ function serializeAppError(error) {
     ...Object.keys(errorContext).length > 0 ? { errorContext } : {}
   };
 }
+function systemErrorCode(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+
+// src/session/start-request.ts
+import { stat } from "fs/promises";
+import { isAbsolute } from "path";
+async function validateStartSessionRequest(request) {
+  if (!validSessionId(request.sessionId)) {
+    throw new AppError(
+      "INVALID_SESSION_NAME",
+      "session name must use letters, digits, underscore, or dash",
+      { sessionId: request.sessionId }
+    );
+  }
+  if (!isAbsolute(request.cwd)) {
+    throw new AppError("INVALID_CWD", "working directory must be absolute", { cwd: request.cwd });
+  }
+  const info = await stat(request.cwd).catch((error) => {
+    throw new AppError("INVALID_CWD", `working directory is unavailable: ${request.cwd}`, { cwd: request.cwd }, { cause: error });
+  });
+  if (!info.isDirectory()) {
+    throw new AppError("INVALID_CWD", `working directory is not a directory: ${request.cwd}`, { cwd: request.cwd });
+  }
+  if (request.resume?.mode === "session" && !request.resume.sessionId.trim()) {
+    throw new AppError("INVALID_RESUME", "resume session id must not be empty", {
+      reason: "\u6062\u590D\u5386\u53F2\u4F1A\u8BDD\u65F6\u5FC5\u987B\u63D0\u4F9B session ID"
+    });
+  }
+  return request;
+}
+function validSessionId(value) {
+  return /^[a-zA-Z0-9_-]{1,40}$/.test(value);
+}
+
+// src/session/startup-failure.ts
+function sessionStartupFailure(result2, fallback) {
+  if (result2.ok || result2.errorCode !== "AGENT_EXITED_DURING_STARTUP") return void 0;
+  const context = result2.errorContext ?? {};
+  return {
+    sessionId: typeof context.sessionId === "string" ? context.sessionId : fallback.sessionId,
+    agent: fallback.agent,
+    ...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/reconciler.ts
+var SessionReconciler = class {
+  constructor(tmux, sessionPrefix = "lark-coding-assistant", missingThreshold = 3, log = async () => void 0, resolveAgentVersion = async () => "unknown") {
+    this.tmux = tmux;
+    this.sessionPrefix = sessionPrefix;
+    this.missingThreshold = missingThreshold;
+    this.log = log;
+    this.resolveAgentVersion = resolveAgentVersion;
+  }
+  tmux;
+  sessionPrefix;
+  missingThreshold;
+  log;
+  resolveAgentVersion;
+  misses = /* @__PURE__ */ new Map();
+  async reconcile(input, discover = false) {
+    const sessions = { ...input.sessions };
+    let changed = false;
+    for (const [id, session] of Object.entries(sessions)) {
+      const result2 = await this.confirm(session);
+      if (result2.status === "unavailable") {
+        await this.log(`tmux inspection unavailable for ${id}: ${errorMessage2(result2.error)}`);
+        continue;
+      }
+      if (result2.status === "live") {
+        this.misses.delete(id);
+        if (result2.pane.paneId !== session.paneId || result2.pane.sessionName !== session.sessionName) {
+          sessions[id] = { ...session, paneId: result2.pane.paneId, sessionName: result2.pane.sessionName, updatedAt: Date.now() };
+          changed = true;
+        }
+        continue;
+      }
+      const misses = (this.misses.get(id) ?? 0) + 1;
+      this.misses.set(id, misses);
+      if (misses < this.missingThreshold) continue;
+      delete sessions[id];
+      this.misses.delete(id);
+      changed = true;
+    }
+    if (discover) {
+      changed = await this.discover(sessions) || changed;
+    }
+    const activeSessionId = input.activeSessionId && sessions[input.activeSessionId] ? input.activeSessionId : Object.keys(sessions)[0];
+    if (activeSessionId !== input.activeSessionId) changed = true;
+    const removedActive = input.activeSessionId && !sessions[input.activeSessionId] ? input.sessions?.[input.activeSessionId] : void 0;
+    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);
+    if (direct.status === "live" || direct.status === "unavailable") return direct;
+    const byName = await this.tmux.inspectSession(session.sessionName);
+    if (byName.status === "live" || byName.status === "unavailable") return byName;
+    return byName.status === "dead" ? byName : direct;
+  }
+  async discover(sessions) {
+    let panes;
+    try {
+      panes = await this.tmux.listSessions(`${this.sessionPrefix}-`);
+    } catch (error) {
+      await this.log(`tmux session discovery unavailable: ${errorMessage2(error)}`);
+      return false;
+    }
+    let changed = false;
+    const seen = /* @__PURE__ */ new Set();
+    for (const pane of panes) {
+      if (seen.has(pane.sessionName) || pane.dead) continue;
+      seen.add(pane.sessionName);
+      const registered = Object.values(sessions).find((session) => session.sessionName === pane.sessionName);
+      if (registered) {
+        if (registered.paneId !== pane.paneId) {
+          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(
+            `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);
+      if (!recovered || sessions[recovered.id]) continue;
+      if (!metadata) {
+        try {
+          await this.writeMetadata(pane, recovered);
+        } catch (error) {
+          await this.log(`failed to persist recovered tmux metadata for ${recovered.id}: ${errorMessage2(error)}`);
+          continue;
+        }
+      }
+      sessions[recovered.id] = recovered;
+      this.misses.delete(recovered.id);
+      changed = true;
+      await this.log(`recovered managed session ${recovered.id} from tmux`);
+    }
+    return changed;
+  }
+  fromMetadata(pane, metadata) {
+    if (!validSessionId(metadata.sessionId) || pane.sessionName !== `${this.sessionPrefix}-${metadata.sessionId}`) return void 0;
+    return {
+      id: metadata.sessionId,
+      agent: metadata.agent,
+      sessionName: pane.sessionName,
+      paneId: pane.paneId,
+      cwd: metadata.cwd,
+      agentVersion: metadata.agentVersion,
+      agentSessionId: metadata.agentSessionId,
+      updatedAt: Date.now()
+    };
+  }
+  async fromLegacy(pane) {
+    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");
+    return {
+      id,
+      agent,
+      sessionName: pane.sessionName,
+      paneId: pane.paneId,
+      cwd: pane.cwd,
+      agentVersion,
+      updatedAt: Date.now()
+    };
+  }
+  writeMetadata(pane, session) {
+    return this.tmux.writeMetadata(pane.sessionName, {
+      managed: true,
+      sessionId: session.id,
+      agent: session.agent,
+      cwd: session.cwd,
+      agentVersion: session.agentVersion,
+      agentSessionId: session.agentSessionId
+    });
+  }
+};
+function inferLegacyAgent(pane) {
+  const command = `${pane.startCommand}
+${pane.currentCommand}`;
+  if (/(?:^|[\s/'"])(?:trae-cli|traex)(?:[\s/'"]|$)/i.test(command)) return "traex";
+  if (/(?:^|[\s/'"])claude(?:[\s/'"]|$)/i.test(command)) return "claude";
+  if (/(?:^|[\s/'"])codex(?:[\s/'"]|$)/i.test(command)) return "codex";
+  return void 0;
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/session/native-session.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var UUID = "[0-9a-fA-F-]{32,36}";
+async function resolveNativeAgentSessionId(agent, pid, home = homedir()) {
+  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),
+      new RegExp(`/\\.trae/cli/sessions/.+/rollout-[^/]+-(${UUID})\\.jsonl(?:\\.lock)?$`)
+    );
+  }
+  const openFiles = await processOpenFiles(pid);
+  if (agent === "codex") return matchPath(openFiles, new RegExp(`/\\.codex/thread-writer-locks/(${UUID})\\.lock$`));
+  return matchPath(openFiles, new RegExp(`/\\.claude/projects/[^/]+/(${UUID})\\.jsonl$`));
+}
+async function resolveTraexPeer(pid, home) {
+  const directory = join(home, ".trae", "cli", "session-peers");
+  const entries = await readdir(directory).catch(() => []);
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const value = await readFile2(join(directory, entry), "utf8").then(JSON.parse).catch(() => void 0);
+    if (!value || typeof value !== "object") continue;
+    const peer = value;
+    if (peer.pid === pid && typeof peer.threadId === "string" && peer.threadId) return peer.threadId;
+  }
+  return void 0;
+}
+async function processOpenFiles(pid) {
+  const result2 = await runFile("lsof", ["-Fn", "-p", String(pid)], { timeoutMs: 3e3 }).catch(() => void 0);
+  if (!result2) return [];
+  return result2.stdout.split("\n").filter((line) => line.startsWith("n")).map((line) => line.slice(1));
+}
+function matchPath(paths2, pattern) {
+  for (const path of paths2) {
+    const match = path.match(pattern);
+    if (match?.[1]) return match[1];
+  }
+  return void 0;
+}
 
 // src/tmux/controller.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -189,7 +456,15 @@ function shellQuote(value) {
 }
 
 // src/tmux/controller.ts
-var PANE_FORMAT = "#{session_name}	#{pane_id}	#{pane_pid}	#{pane_current_command}	#{pane_current_path}	#{pane_dead}	#{cursor_x}	#{cursor_y}";
+var PANE_FORMAT = "#{session_name}	#{pane_id}	#{pane_pid}	#{pane_start_command}	#{pane_current_command}	#{pane_current_path}	#{pane_dead}	#{pane_dead_status}	#{cursor_x}	#{cursor_y}";
+var METADATA_OPTIONS = {
+  managed: "@lca-managed",
+  sessionId: "@lca-session-id",
+  agent: "@lca-agent",
+  cwd: "@lca-cwd",
+  agentVersion: "@lca-agent-version",
+  agentSessionId: "@lca-agent-session-id"
+};
 var TmuxController = class {
   constructor(binary = "tmux") {
     this.binary = binary;
@@ -223,7 +498,7 @@ var TmuxController = class {
       options.binary,
       ...options.args ?? []
     ].map(shellQuote).join(" ");
-    await runFile(this.binary, [
+    const createArgs = [
       "new-session",
       "-d",
       "-s",
@@ -235,7 +510,11 @@ var TmuxController = class {
       "-y",
       "40",
       command
-    ]);
+    ];
+    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);
     if (!pane) throw new Error("tmux created a session without a discoverable pane");
     return pane;
@@ -259,6 +538,10 @@ var TmuxController = class {
     return stdout.split("\n").map(parsePane).find(Boolean);
   }
   async inspect(paneId) {
+    const result2 = await this.inspectStatus(paneId);
+    return result2.status === "live" || result2.status === "dead" ? result2.pane : void 0;
+  }
+  async inspectStatus(paneId) {
     assertSafeTmuxTarget(paneId);
     try {
       const { stdout } = await runFile(this.binary, [
@@ -268,11 +551,65 @@ var TmuxController = class {
         paneId,
         PANE_FORMAT
       ]);
-      return parsePane(stdout.trim());
-    } catch {
-      return void 0;
+      if (!stdout.trim()) return { status: "missing" };
+      const pane = parsePane(stdout.trim());
+      if (!pane) return { status: "unavailable", error: new Error("invalid tmux pane response") };
+      return pane.dead ? { status: "dead", pane } : { status: "live", pane };
+    } catch (error) {
+      return tmuxTargetMissing(error) ? { status: "missing" } : { status: "unavailable", error };
+    }
+  }
+  async inspectSession(sessionName) {
+    try {
+      const pane = await this.findBySession(sessionName);
+      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]);
+    return stdout.split("\n").map(parsePane).filter((pane) => Boolean(pane?.sessionName.startsWith(prefix)));
+  }
+  async writeMetadata(sessionName, metadata) {
+    const values = {
+      managed: "1",
+      sessionId: metadata.sessionId,
+      agent: metadata.agent,
+      cwd: metadata.cwd,
+      agentVersion: metadata.agentVersion,
+      agentSessionId: metadata.agentSessionId
+    };
+    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);
+      } else {
+        await runFile(this.binary, ["set-option", "-t", sessionName, option2, value]);
+      }
     }
   }
+  async readMetadata(sessionName) {
+    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);
+      if (!result2) {
+        if (key === "agentSessionId") continue;
+        return void 0;
+      }
+      values[key] = result2.stdout.trim();
+    }
+    if (values.managed !== "1" || !values.sessionId || !values.cwd || !values.agentVersion || values.agent !== "codex" && values.agent !== "traex" && values.agent !== "claude") return void 0;
+    return {
+      managed: true,
+      sessionId: values.sessionId,
+      agent: values.agent,
+      cwd: values.cwd,
+      agentVersion: values.agentVersion,
+      agentSessionId: values.agentSessionId || void 0
+    };
+  }
   async capture(paneId, lines = 200) {
     assertSafeTmuxTarget(paneId);
     const { stdout } = await runFile(this.binary, [
@@ -287,6 +624,16 @@ var TmuxController = class {
     ]);
     return stdout;
   }
+  async preserveOnExit(sessionName, enabled) {
+    await runFile(this.binary, [
+      "set-option",
+      "-w",
+      "-t",
+      `=${sessionName}:`,
+      "remain-on-exit",
+      enabled ? "on" : "off"
+    ]);
+  }
   sendText(paneId, input, submit = true) {
     assertSafeTmuxTarget(paneId);
     const text = sanitizeRemoteInput(input);
@@ -306,25 +653,47 @@ var TmuxController = class {
   }
   async sendKey(paneId, key) {
     assertSafeTmuxTarget(paneId);
-    if (!/^(Enter|Escape|Space|Tab|BSpace|Up|Down|Left|Right|C-c|C-u|C-k|C-Enter|[yandpcq1-9])$/.test(key)) {
+    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]);
   }
   async killSession(sessionName) {
-    await runFile(this.binary, ["kill-session", "-t", `=${sessionName}`]);
+    try {
+      await runFile(this.binary, ["kill-session", "-t", `=${sessionName}`]);
+    } catch (error) {
+      if (!tmuxTargetMissing(error)) throw error;
+    }
   }
 };
 function displaySessionId(sessionName) {
   return sessionName.replace(/^lark-coding-assistant-/, "");
 }
 function parsePane(line) {
-  const [sessionName, paneId, pidText, currentCommand, cwd, deadText, cursorXText, cursorYText] = line.trim().split("	");
+  const [sessionName, paneId, pidText, startCommand, currentCommand, cwd, deadText, exitStatusText, cursorXText, cursorYText] = line.trim().split("	");
   const pid = Number(pidText);
   const cursorX = Number(cursorXText);
   const cursorY = Number(cursorYText);
-  if (!sessionName || !paneId || !Number.isInteger(pid) || !currentCommand || !cwd || !Number.isInteger(cursorX) || !Number.isInteger(cursorY)) return void 0;
-  return { sessionName, paneId, pid, currentCommand, cwd, dead: deadText === "1", cursorX, cursorY };
+  if (!sessionName || !paneId || !Number.isInteger(pid) || !startCommand || !currentCommand || !cwd && deadText !== "1" || !Number.isInteger(cursorX) || !Number.isInteger(cursorY)) return void 0;
+  const exitStatus = exitStatusText === "" ? void 0 : Number(exitStatusText);
+  return {
+    sessionName,
+    paneId,
+    pid,
+    startCommand,
+    currentCommand,
+    cwd: cwd || "/",
+    dead: deadText === "1",
+    exitStatus: Number.isInteger(exitStatus) ? exitStatus : void 0,
+    cursorX,
+    cursorY
+  };
+}
+function tmuxTargetMissing(error) {
+  const message = 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/i.test(`${message}
+${stderr}`);
 }
 
 // src/screen/detector.ts
@@ -348,12 +717,12 @@ var CODEX_DIALECT = {
 };
 var TRAE_DIALECT = {
   ...CODEX_DIALECT,
-  id: "trae-cli",
+  id: "traex",
   headerPatterns: [...commonHeaders, /^\s*Question\s+\d+\/\d+/i],
   customInputControls: [/^(?:other|none of the above|add notes)$/i]
 };
 var CLAUDE_DIALECT = {
-  id: "claude-code",
+  id: "claude",
   headerPatterns: [
     ...commonHeaders,
     /^\s*(?:←\s*)?[☐☑☒]\s+.+?(?:\s+✔\s+Submit\s*→)?\s*$/i,
@@ -701,11 +1070,18 @@ function claudeResumeArgs(resume) {
 // src/agents/stop-hook.ts
 function codexStyleStopHookArgs(command) {
   const hook = `{hooks=[{type="command",command=${JSON.stringify(command)},timeout=5}]}`;
-  return ["--dangerously-bypass-hook-trust", "-c", `hooks.Stop=[${hook}]`];
+  return [
+    "--dangerously-bypass-hook-trust",
+    "-c",
+    `hooks.SessionStart=[${hook}]`,
+    "-c",
+    `hooks.Stop=[${hook}]`
+  ];
 }
 function claudeStopHookArgs(command) {
   return ["--settings", JSON.stringify({
     hooks: {
+      SessionStart: [{ hooks: [{ type: "command", command, timeout: 5 }] }],
       Stop: [{ hooks: [{ type: "command", command, timeout: 5 }] }]
     }
   })];
@@ -714,7 +1090,7 @@ function claudeStopHookArgs(command) {
 // src/agents/codex.ts
 var codexAdapter = {
   id: "codex",
-  displayName: "Codex",
+  displayName: "codex",
   groupOrder: 10,
   binary: (config) => config.agentBinaries.codex,
   versionArgs: ["--version"],
@@ -727,10 +1103,10 @@ var codexAdapter = {
 
 // src/agents/trae-cli.ts
 var traeCliAdapter = {
-  id: "trae-cli",
-  displayName: "Trae CLI",
+  id: "traex",
+  displayName: "traex",
   groupOrder: 20,
-  binary: (config) => config.agentBinaries["trae-cli"],
+  binary: (config) => config.agentBinaries.traex,
   versionArgs: ["--version"],
   buildLaunchArgs: ({ resume, stopHookCommand }) => [
     ...codexStyleStopHookArgs(stopHookCommand),
@@ -741,10 +1117,10 @@ var traeCliAdapter = {
 
 // src/agents/claude-code.ts
 var claudeCodeAdapter = {
-  id: "claude-code",
-  displayName: "Claude Code",
+  id: "claude",
+  displayName: "claude",
   groupOrder: 30,
-  binary: (config) => config.agentBinaries["claude-code"],
+  binary: (config) => config.agentBinaries.claude,
   versionArgs: ["--version"],
   buildLaunchArgs: ({ resume, stopHookCommand }) => [
     ...claudeStopHookArgs(stopHookCommand),
@@ -753,9 +1129,6 @@ var claudeCodeAdapter = {
   detectScreen: detectClaudeScreen
 };
 
-// src/agents/types.ts
-var AGENT_IDS = ["codex", "trae-cli", "claude-code"];
-
 // src/agents/registry.ts
 var adapters = /* @__PURE__ */ new Map([
   [codexAdapter.id, codexAdapter],
@@ -771,10 +1144,15 @@ function listAgentAdapters() {
   return [...adapters.values()].sort((left, right) => left.groupOrder - right.groupOrder);
 }
 function isAgentId(value) {
-  return AGENT_IDS.includes(value);
+  return normalizeAgentId(value) === value;
 }
 
 // src/agents/stop-event.ts
+function validSessionStartCandidate(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.sessionId === "string" && candidate.sessionId.length > 0 && (candidate.agent === "codex" || candidate.agent === "traex" || candidate.agent === "claude") && typeof candidate.agentSessionId === "string" && candidate.agentSessionId.length > 0 && typeof candidate.cwd === "string" && candidate.cwd.length > 0;
+}
 function validTurnCompleteCandidate(value) {
   if (!value || typeof value !== "object") return false;
   const candidate = value;
@@ -852,11 +1230,10 @@ function withoutSignature(value) {
 function isSignedAction(value) {
   if (!value || typeof value !== "object") return false;
   const item = value;
-  return item.v === 1 && (item.kind === "choice" || item.kind === "stop" || item.kind === "session" || item.kind === "manual") && (item.kind !== "choice" || item.interactionKind === "approval" || item.interactionKind === "question" || item.interactionKind === "choice") && (item.kind !== "manual" || typeof item.sessionId === "string" && (item.manualMode === "explicit" || item.manualMode === "fallback")) && typeof item.agent === "string" && isAgentId(item.agent) && typeof item.action === "string" && typeof item.paneId === "string" && typeof item.fingerprint === "string" && typeof item.chatId === "string" && typeof item.nonce === "string" && typeof item.expiresAt === "number" && typeof item.sig === "string";
+  return item.v === 1 && (item.kind === "choice" || item.kind === "stop" || item.kind === "session" || item.kind === "session-stop" || item.kind === "session-create" || item.kind === "session-start-error" || item.kind === "startup-conflict" || item.kind === "resume-picker" || item.kind === "manual") && (item.kind !== "choice" || item.interactionKind === "approval" || item.interactionKind === "question" || item.interactionKind === "choice") && (item.kind !== "manual" || typeof item.sessionId === "string" && (item.manualMode === "explicit" || item.manualMode === "fallback")) && (item.kind !== "session-stop" && item.kind !== "session-start-error" && item.kind !== "resume-picker" && item.kind !== "startup-conflict" || typeof item.sessionId === "string") && typeof item.agent === "string" && isAgentId(item.agent) && typeof item.action === "string" && typeof item.paneId === "string" && typeof item.fingerprint === "string" && typeof item.chatId === "string" && typeof item.nonce === "string" && typeof item.expiresAt === "number" && typeof item.sig === "string";
 }
 
 // src/lark/cards.ts
-import { homedir } from "os";
 function choiceCard(chatId, paneId, screen, signer, agent = "codex") {
   if (!screen.interaction) throw new Error("choice card requires a structured interaction");
   const interaction = screen.interaction;
@@ -1011,37 +1388,37 @@ function interactionInputCard(agent, label) {
 var MANUAL_TEXT_FIELD = "manual_text";
 var MANUAL_TYPE_ACTION = "type";
 var MANUAL_SUBMIT_ACTION = "submit";
-function manualControlCard(chatId, view, signer) {
-  const state = view.state ?? "active";
-  const mode = view.mode ?? "fallback";
-  const agentName = getAgentAdapter(view.session.agent).displayName;
-  const fingerprint = view.screen.fingerprint;
+function manualControlCard(chatId, view2, signer) {
+  const state = view2.state ?? "active";
+  const mode = view2.mode ?? "fallback";
+  const agentName = getAgentAdapter(view2.session.agent).displayName;
+  const fingerprint = view2.screen.fingerprint;
   const sign = (action) => signer.sign({
     kind: "manual",
-    sessionId: view.session.id,
+    sessionId: view2.session.id,
     manualMode: mode,
-    agent: view.session.agent,
+    agent: view2.session.agent,
     action,
-    paneId: view.session.paneId,
+    paneId: view2.session.paneId,
     fingerprint,
     chatId
   }, 10 * 6e4);
-  const status = state === "recovered" ? "\u2705 \u5DF2\u6062\u590D\u7ED3\u6784\u5316\u8BC6\u522B\uFF0C\u8BF7\u4F7F\u7528\u65B0\u53D1\u9001\u7684\u8BED\u4E49\u5316\u64CD\u4F5C\u5361\u3002" : state === "exited" ? "\u2705 \u5DF2\u9000\u51FA\u624B\u52A8\u9065\u63A7\u6A21\u5F0F\uFF0C\u672C\u5730 Agent \u548C tmux \u4ECD\u5728\u8FD0\u884C\u3002" : state === "stale" ? "\u26A0\uFE0F \u7EC8\u7AEF\u753B\u9762\u5DF2\u53D8\u5316\uFF0C\u65E7\u64CD\u4F5C\u672A\u6267\u884C\uFF1B\u8BF7\u786E\u8BA4\u6700\u65B0\u753B\u9762\u540E\u91CD\u8BD5\u3002" : state === "error" ? `\u26A0\uFE0F ${escapeMarkdown(view.notice ?? "\u624B\u52A8\u64CD\u4F5C\u5931\u8D25\uFF0C\u8BF7\u786E\u8BA4\u6700\u65B0\u753B\u9762\u3002")}` : mode === "explicit" ? "\u26A0\uFE0F \u5DF2\u9501\u5B9A\u624B\u52A8\u9065\u63A7\uFF1B\u5373\u4F7F\u6062\u590D\u7ED3\u6784\u5316\u8BC6\u522B\uFF0C\u4E5F\u4F1A\u7EE7\u7EED\u7531\u4F60\u76F4\u63A5\u64CD\u4F5C\u7EC8\u7AEF\u3002" : "\u26A0\uFE0F \u5F53\u524D\u4E3A\u624B\u52A8\u9065\u63A7\u6A21\u5F0F\uFF0C\u6240\u6709\u64CD\u4F5C\u90FD\u4E0D\u4F1A\u8FDB\u884C\u8BED\u4E49\u5B89\u5168\u5224\u65AD\u3002";
+  const status = state === "recovered" ? "\u2705 \u5DF2\u6062\u590D\u7ED3\u6784\u5316\u8BC6\u522B\uFF0C\u8BF7\u4F7F\u7528\u65B0\u53D1\u9001\u7684\u8BED\u4E49\u5316\u64CD\u4F5C\u5361\u3002" : state === "exited" ? "\u2705 \u5DF2\u9000\u51FA\u624B\u52A8\u9065\u63A7\u6A21\u5F0F\uFF0C\u672C\u5730 Agent \u548C tmux \u4ECD\u5728\u8FD0\u884C\u3002" : state === "stale" ? "\u26A0\uFE0F \u7EC8\u7AEF\u753B\u9762\u5DF2\u53D8\u5316\uFF0C\u65E7\u64CD\u4F5C\u672A\u6267\u884C\uFF1B\u8BF7\u786E\u8BA4\u6700\u65B0\u753B\u9762\u540E\u91CD\u8BD5\u3002" : state === "error" ? `\u26A0\uFE0F ${escapeMarkdown(view2.notice ?? "\u624B\u52A8\u64CD\u4F5C\u5931\u8D25\uFF0C\u8BF7\u786E\u8BA4\u6700\u65B0\u753B\u9762\u3002")}` : mode === "explicit" ? "\u26A0\uFE0F \u5DF2\u9501\u5B9A\u624B\u52A8\u9065\u63A7\uFF1B\u5373\u4F7F\u6062\u590D\u7ED3\u6784\u5316\u8BC6\u522B\uFF0C\u4E5F\u4F1A\u7EE7\u7EED\u7531\u4F60\u76F4\u63A5\u64CD\u4F5C\u7EC8\u7AEF\u3002" : "\u26A0\uFE0F \u5F53\u524D\u4E3A\u624B\u52A8\u9065\u63A7\u6A21\u5F0F\uFF0C\u6240\u6709\u64CD\u4F5C\u90FD\u4E0D\u4F1A\u8FDB\u884C\u8BED\u4E49\u5B89\u5168\u5224\u65AD\u3002";
   const metadata = [
-    `**Session**  \`${escapeInlineCode(view.session.id)}\`  \xB7  **Agent**  ${escapeMarkdown(agentName)}`,
-    `**\u72B6\u6001**  \`${view.screen.state}\`  \xB7  **\u91C7\u96C6\u65F6\u95F4**  ${formatHandledAt(view.capturedAt)}`,
-    view.lastOperation ? `**\u6700\u8FD1\u64CD\u4F5C**  ${escapeMarkdown(view.lastOperation)}` : void 0,
-    view.notice && state !== "error" ? escapeMarkdown(view.notice) : void 0
+    `**Session**  \`${escapeInlineCode(view2.session.id)}\`  \xB7  **Agent**  ${escapeMarkdown(agentName)}`,
+    `**\u72B6\u6001**  \`${view2.screen.state}\`  \xB7  **\u91C7\u96C6\u65F6\u95F4**  ${formatHandledAt(view2.capturedAt)}`,
+    view2.lastOperation ? `**\u6700\u8FD1\u64CD\u4F5C**  ${escapeMarkdown(view2.lastOperation)}` : void 0,
+    view2.notice && state !== "error" ? escapeMarkdown(view2.notice) : void 0
   ].filter(Boolean).join("\n");
   const elements = [
     { tag: "markdown", content: status },
     { tag: "markdown", content: metadata },
     { tag: "markdown", content: `\`\`\`text
-${escapeFence(view.output).slice(-5e3)}
+${escapeFence(view2.output).slice(-5e3)}
 \`\`\`` }
   ];
   if (state === "recovered" || state === "exited") {
-    return cardElements(`${view.session.id} \xB7 ${agentName} \u624B\u52A8\u9065\u63A7`, elements, state === "recovered" ? "green" : "grey");
+    return cardElements(`${view2.session.id} \xB7 ${agentName} \u624B\u52A8\u9065\u63A7`, elements, state === "recovered" ? "green" : "grey");
   }
   elements.push(
     manualButtonRow([
@@ -1086,7 +1463,7 @@ ${escapeFence(view.output).slice(-5e3)}
       manualButton("\u7ED3\u675F\u9065\u63A7", sign("exit"))
     ])
   );
-  return cardElements(`${view.session.id} \xB7 ${agentName} \u624B\u52A8\u9065\u63A7`, elements, "orange");
+  return cardElements(`${view2.session.id} \xB7 ${agentName} \u624B\u52A8\u9065\u63A7`, elements, "orange");
 }
 function manualButton(label, value, type = "default") {
   return {
@@ -1142,7 +1519,7 @@ function statusCard(status) {
   }
   const adapter = getAgentAdapter(session.agent);
   const visual = statusVisual(status);
-  const path = formatDisplayPath(session.cwd);
+  const path = session.cwd;
   return {
     schema: "2.0",
     config: { update_multi: true },
@@ -1181,7 +1558,7 @@ function statusCard(status) {
     }
   };
 }
-function sessionPickerCard(chatId, sessions, activeSessionId, signer) {
+function sessionPickerCard(chatId, sessions, activeSessionId, signer, confirmingStopSessionId, allowCreate = true) {
   const groups = listAgentAdapters().map((adapter) => ({ adapter, sessions: sessions.filter((session) => session.agent === adapter.id) })).filter(({ sessions: group }) => group.length > 0);
   const elements = groups.flatMap(({ adapter, sessions: group }, groupIndex) => [
     ...groupIndex > 0 ? [{ tag: "hr", margin: "6px 0px" }] : [],
@@ -1191,8 +1568,37 @@ function sessionPickerCard(chatId, sessions, activeSessionId, signer) {
       text_size: "heading",
       margin: "2px 0px 0px 0px"
     },
-    ...group.map((session) => sessionCard(chatId, session, session.id === activeSessionId, signer))
+    ...group.map((session) => sessionCard(
+      chatId,
+      session,
+      session.id === activeSessionId,
+      signer,
+      confirmingStopSessionId === session.id
+    ))
   ]);
+  if (elements.length > 0) elements.push({ tag: "hr", margin: "8px 0px" });
+  else elements.push({ tag: "markdown", content: "\u6682\u65E0\u53EF\u8FDE\u63A5\u7684 Coding Session\uFF0C\u53EF\u4EE5\u76F4\u63A5\u65B0\u5EFA\u4E00\u4E2A\u3002" });
+  elements.push(allowCreate ? {
+    tag: "button",
+    text: { tag: "plain_text", content: "\uFF0B \u65B0\u5EFA Session" },
+    type: "primary",
+    width: "fill",
+    size: "medium",
+    behaviors: [{
+      type: "callback",
+      value: signer.sign({
+        kind: "session-create",
+        agent: "codex",
+        action: "open",
+        paneId: "",
+        fingerprint: "create",
+        chatId
+      }, 10 * 6e4)
+    }]
+  } : {
+    tag: "markdown",
+    content: "\u2705 \u65B0\u5EFA Session \u8868\u5355\u5DF2\u53D1\u9001\uFF1B\u4ECD\u53EF\u67E5\u770B\u6216\u64CD\u4F5C\u4E0A\u65B9 Session\u3002"
+  });
   return {
     schema: "2.0",
     config: { update_multi: true },
@@ -1200,37 +1606,139 @@ function sessionPickerCard(chatId, sessions, activeSessionId, signer) {
     body: {
       vertical_spacing: "10px",
       padding: "12px",
-      elements: elements.length > 0 ? elements : [{ tag: "markdown", content: "\u6682\u65E0\u53EF\u8FDE\u63A5\u7684 Coding Session\u3002" }]
+      elements
+    }
+  };
+}
+var SESSION_CREATE_SUBMIT_ACTION = "session_create_submit";
+var SESSION_CREATE_NAME_FIELD = "session_name";
+var SESSION_CREATE_AGENT_FIELD = "session_agent";
+var SESSION_CREATE_CWD_FIELD = "session_cwd";
+var SESSION_CREATE_RESUME_FIELD = "session_resume";
+function sessionCreateCard() {
+  return cardElements("\u65B0\u5EFA Coding Session", [
+    { tag: "markdown", content: "\u5728\u672C\u673A\u53D7\u7BA1 tmux \u4E2D\u542F\u52A8\u4E00\u4E2A\u65B0\u4F1A\u8BDD\uFF1B\u521B\u5EFA\u6210\u529F\u540E\u4F1A\u81EA\u52A8\u8FDE\u63A5\u3002" },
+    {
+      tag: "form",
+      name: "session_create_form",
+      direction: "vertical",
+      vertical_spacing: "10px",
+      elements: [
+        {
+          tag: "input",
+          name: SESSION_CREATE_NAME_FIELD,
+          required: true,
+          placeholder: { tag: "plain_text", content: "Session \u540D\u79F0\uFF0C\u4F8B\u5982 helix" },
+          label: { tag: "plain_text", content: "Session \u540D\u79F0" }
+        },
+        {
+          tag: "select_static",
+          name: SESSION_CREATE_AGENT_FIELD,
+          required: true,
+          placeholder: { tag: "plain_text", content: "\u9009\u62E9 Agent" },
+          initial_option: "codex",
+          options: listAgentAdapters().map((adapter) => ({
+            text: { tag: "plain_text", content: adapter.displayName },
+            value: adapter.id
+          }))
+        },
+        {
+          tag: "input",
+          name: SESSION_CREATE_CWD_FIELD,
+          required: true,
+          placeholder: { tag: "plain_text", content: "/absolute/path/to/project" },
+          label: { tag: "plain_text", content: "\u5DE5\u4F5C\u76EE\u5F55\uFF08\u5FC5\u987B\u4E3A\u7EDD\u5BF9\u8DEF\u5F84\uFF09" }
+        },
+        {
+          tag: "select_static",
+          name: SESSION_CREATE_RESUME_FIELD,
+          placeholder: { tag: "plain_text", content: "\u9009\u62E9\u542F\u52A8\u65B9\u5F0F" },
+          initial_option: "new",
+          options: [
+            { text: { tag: "plain_text", content: "\u65B0\u4F1A\u8BDD" }, value: "new" },
+            { text: { tag: "plain_text", content: "\u6253\u5F00\u539F\u751F Resume Picker" }, value: "picker" }
+          ]
+        },
+        {
+          tag: "button",
+          name: SESSION_CREATE_SUBMIT_ACTION,
+          text: { tag: "plain_text", content: "\u542F\u52A8\u5E76\u8FDE\u63A5" },
+          type: "primary",
+          width: "fill",
+          size: "medium",
+          form_action_type: "submit"
+        }
+      ]
     }
+  ]);
+}
+function sessionCreateResultCard(success, content, session) {
+  const details = session ? `
+
+**Session**  \`${escapeInlineCode(session.id)}\`
+**Agent**  ${escapeMarkdown(getAgentAdapter(session.agent).displayName)}
+**\u5DE5\u4F5C\u76EE\u5F55**  \`${escapeInlineCode(session.cwd)}\`` : "";
+  return cardElements(
+    success ? "Session \u5DF2\u542F\u52A8" : "Session \u542F\u52A8\u5931\u8D25",
+    [{ tag: "markdown", content: `${success ? "\u2705" : "\u26A0\uFE0F"} ${escapeMarkdown(content)}${details}` }],
+    success ? "green" : "red"
+  );
+}
+function sessionCreateProgressCard() {
+  return cardElements("\u6B63\u5728\u542F\u52A8 Session", [
+    { tag: "markdown", content: "\u23F3 \u6B63\u5728\u521B\u5EFA tmux pane\uFF0C\u5E76\u786E\u8BA4 Agent \u548C\u539F\u751F Session \u72B6\u6001\u2026" }
+  ], "blue");
+}
+function sessionCreateOpenedCard() {
+  return cardElements("\u65B0\u5EFA\u8868\u5355\u5DF2\u6253\u5F00", [{
+    tag: "markdown",
+    content: "\u2705 \u8BF7\u5728\u6700\u65B0\u53D1\u9001\u7684\u201C\u65B0\u5EFA Coding Session\u201D\u5361\u7247\u4E2D\u7EE7\u7EED\u64CD\u4F5C\u3002\n\n\u5982\u9700\u67E5\u770B Session\uFF0C\u8BF7\u53D1\u9001 `/sessions`\u3002"
+  }], "grey");
+}
+function sessionCreateFailureCard(chatId, content, signer) {
+  return cardElements("Session \u542F\u52A8\u5931\u8D25", [
+    { tag: "markdown", content: `\u26A0\uFE0F ${escapeMarkdown(content)}` },
+    ...sessionFailureActions(chatId, "", "codex", signer)
+  ], "red");
+}
+function sessionStartupFailureCard(chatId, failure, signer) {
+  const exitStatus = failure.exitStatus === void 0 ? "\u672A\u77E5" : String(failure.exitStatus);
+  return cardElements("Session \u542F\u52A8\u5931\u8D25", [
+    {
+      tag: "markdown",
+      content: `\u26A0\uFE0F **Session**  \`${escapeInlineCode(failure.sessionId)}\`
+**Agent**  ${escapeMarkdown(getAgentAdapter(failure.agent).displayName)}
+**\u9000\u51FA\u7801**  \`${exitStatus}\``
+    },
+    { tag: "markdown", content: `**\u539F\u59CB\u9519\u8BEF**
+
+\`\`\`text
+${escapeFence(failure.terminalExcerpt)}
+\`\`\`` },
+    ...sessionFailureActions(chatId, failure.sessionId, failure.agent, signer)
+  ], "red");
+}
+function sessionFailureActions(chatId, sessionId, agent, signer) {
+  const common = {
+    kind: "session-start-error",
+    sessionId,
+    agent,
+    paneId: "",
+    fingerprint: "startup-error",
+    chatId
   };
+  return [
+    actionButton("\u65B0\u5EFA Session", "primary", signer.sign({ ...common, action: "create" }, 10 * 6e4)),
+    actionButton("\u67E5\u770B Sessions", "default", signer.sign({ ...common, action: "sessions" }, 10 * 6e4))
+  ];
 }
-function sessionCard(chatId, session, active, signer) {
+function sessionCard(chatId, session, active, signer, confirmingStop = false) {
   const content = [
     active ? `**${escapeMarkdown(session.id)}**  <text_tag color='green'>\u25CF \u5F53\u524D\u8FDE\u63A5</text_tag>` : `**${escapeMarkdown(session.id)}**`,
-    `\u{1F4C1} \`${escapeInlineCode(formatDisplayPath(session.cwd))}\``
+    `\u{1F4C1} \`${escapeInlineCode(session.cwd)}\``
   ].join("\n\n");
   const elements = [{ tag: "markdown", content }];
-  if (!active) {
-    elements.push({
-      tag: "button",
-      text: { tag: "plain_text", content: `\u8FDE\u63A5 ${session.id}` },
-      type: "primary",
-      width: "fill",
-      size: "medium",
-      margin: "2px 0px 0px 0px",
-      behaviors: [{
-        type: "callback",
-        value: signer.sign({
-          kind: "session",
-          agent: session.agent,
-          action: session.id,
-          paneId: session.paneId,
-          fingerprint: String(session.updatedAt),
-          chatId
-        })
-      }]
-    });
-  }
+  elements.push(confirmingStop ? sessionStopConfirmation(chatId, session, signer) : sessionActions(chatId, session, active, signer));
   const contentColumn = {
     tag: "column",
     width: "weighted",
@@ -1254,15 +1762,143 @@ function sessionCard(chatId, session, active, signer) {
     }, contentColumn] : [contentColumn]
   };
 }
-function formatDisplayPath(path, home = homedir(), maxLength = 44) {
-  const display = path === home ? "~" : path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
-  if (display.length <= maxLength) return display;
-  const segments = display.split("/").filter(Boolean);
-  return segments.length <= 2 ? display : `\u2026/${segments.slice(-2).join("/")}`;
+function sessionActions(chatId, session, active, signer) {
+  const buttons = [];
+  if (!active) buttons.push(actionButton(`\u8FDE\u63A5 ${session.id}`, "primary", signer.sign({
+    kind: "session",
+    agent: session.agent,
+    action: session.id,
+    paneId: session.paneId,
+    fingerprint: String(session.updatedAt),
+    chatId
+  })));
+  buttons.push(actionButton("\u5173\u95ED", "danger", signer.sign({
+    kind: "session-stop",
+    sessionId: session.id,
+    agent: session.agent,
+    action: "request",
+    paneId: session.paneId,
+    fingerprint: String(session.updatedAt),
+    chatId
+  })));
+  return buttonRow(buttons);
+}
+function sessionStopConfirmation(chatId, session, signer) {
+  const common = {
+    kind: "session-stop",
+    sessionId: session.id,
+    agent: session.agent,
+    paneId: session.paneId,
+    fingerprint: String(session.updatedAt),
+    chatId
+  };
+  return {
+    tag: "column_set",
+    flex_mode: "none",
+    columns: [{
+      tag: "column",
+      width: "weighted",
+      weight: 1,
+      background_style: "grey",
+      padding: "8px 10px",
+      vertical_spacing: "6px",
+      elements: [
+        { tag: "markdown", content: `\u26A0\uFE0F \u786E\u8BA4\u5173\u95ED **${escapeMarkdown(session.id)}**\uFF1FAgent \u548C tmux session \u5C06\u9000\u51FA\u3002` },
+        buttonRow([
+          actionButton("\u786E\u8BA4\u5173\u95ED", "danger", signer.sign({ ...common, action: "confirm" })),
+          actionButton("\u53D6\u6D88", "default", signer.sign({ ...common, action: "cancel" }))
+        ])
+      ]
+    }]
+  };
+}
+function resumePickerCard(chatId, session, picker, signer) {
+  const common = {
+    kind: "resume-picker",
+    sessionId: session.id,
+    agent: session.agent,
+    paneId: session.paneId,
+    fingerprint: picker.fingerprint,
+    chatId
+  };
+  const optionElements = picker.options.map((option2) => ({
+    tag: "column_set",
+    flex_mode: "none",
+    columns: [{
+      tag: "column",
+      width: "weighted",
+      weight: 1,
+      background_style: "grey",
+      padding: "9px 10px",
+      vertical_spacing: "5px",
+      elements: [
+        { tag: "markdown", content: `${option2.selected ? "\u25CF" : "\u25CB"} **${escapeMarkdown(option2.label)}**${option2.detail ? `
+${escapeMarkdown(option2.detail)}` : ""}` },
+        actionButton("\u6062\u590D\u6B64 Session", option2.selected ? "primary" : "default", signer.sign({ ...common, action: `select:${option2.id}` }, 10 * 6e4))
+      ]
+    }]
+  }));
+  const navigation = [
+    ...picker.canPrevious ? [actionButton("\u4E0A\u4E00\u9875", "default", signer.sign({ ...common, action: "previous" }, 10 * 6e4))] : [],
+    actionButton("\u5237\u65B0", "default", signer.sign({ ...common, action: "refresh" }, 10 * 6e4)),
+    ...picker.canNext ? [actionButton("\u4E0B\u4E00\u9875", "default", signer.sign({ ...common, action: "next" }, 10 * 6e4))] : [],
+    actionButton("\u53D6\u6D88", "danger", signer.sign({ ...common, action: "cancel" }, 10 * 6e4))
+  ];
+  return cardElements(
+    "\u9009\u62E9\u8981\u6062\u590D\u7684 Session",
+    [
+      { tag: "markdown", content: `**${escapeMarkdown(session.id)} \xB7 ${escapeMarkdown(getAgentAdapter(session.agent).displayName)}**${picker.position && picker.total ? `  \xB7  \u5F53\u524D ${picker.position}/${picker.total}` : ""}` },
+      ...optionElements,
+      buttonRow(navigation)
+    ],
+    "yellow"
+  );
+}
+function startupConflictCard(chatId, requested, owner, signer) {
+  const common = {
+    kind: "startup-conflict",
+    sessionId: requested.id,
+    agent: requested.agent,
+    paneId: owner.paneId,
+    fingerprint: String(owner.updatedAt),
+    chatId
+  };
+  return cardElements("Session \u5DF2\u7531\u5176\u4ED6\u8FDE\u63A5\u5360\u7528", [
+    {
+      tag: "markdown",
+      content: `\u8981\u6062\u590D\u7684 **${escapeMarkdown(requested.agent)}** \u539F\u751F Session \u5DF2\u7531 LCA Session **${escapeMarkdown(owner.id)}** \u8FDE\u63A5\u3002
+
+**\u8BF7\u6C42\u540D\u79F0**  \`${escapeInlineCode(requested.id)}\`
+**\u5DE5\u4F5C\u76EE\u5F55**  \`${escapeInlineCode(requested.cwd)}\``
+    },
+    buttonRow([
+      actionButton(`\u8FDE\u63A5 ${owner.id}`, "primary", signer.sign({ ...common, action: "connect" }, 10 * 6e4)),
+      actionButton("\u542F\u52A8\u65B0\u4F1A\u8BDD", "default", signer.sign({ ...common, action: "new" }, 10 * 6e4)),
+      actionButton("\u53D6\u6D88", "danger", signer.sign({ ...common, action: "cancel" }, 10 * 6e4))
+    ])
+  ], "yellow");
+}
+function actionButton(text, type, value) {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: text },
+    type,
+    size: "medium",
+    behaviors: [{ type: "callback", value }]
+  };
+}
+function buttonRow(buttons) {
+  return {
+    tag: "column_set",
+    flex_mode: "none",
+    horizontal_spacing: "8px",
+    margin: "2px 0px 0px 0px",
+    columns: buttons.map((button) => ({ tag: "column", width: "weighted", weight: 1, elements: [button] }))
+  };
 }
 function agentMarker(agent) {
   if (agent === "codex") return "\u{1F535}";
-  if (agent === "trae-cli") return "\u{1F7E3}";
+  if (agent === "traex") return "\u{1F7E3}";
   return "\u{1F7E0}";
 }
 function statusColumn(title, value) {
@@ -1300,6 +1936,12 @@ function handledActionCard(action, result2, handledAt = /* @__PURE__ */ new Date
   ].join("\n");
   return card(title, content, [], "green");
 }
+function expiredActionCard() {
+  return cardElements("\u5361\u7247\u5DF2\u5931\u6548", [{
+    tag: "markdown",
+    content: "\u26A0\uFE0F \u6B64\u5361\u7247\u6216\u6309\u94AE\u5DF2\u8FC7\u671F\u3001\u5DF2\u5904\u7406\uFF0C\u6216 bridge daemon \u5DF2\u91CD\u542F\u3002\n\n\u8BF7\u91CD\u65B0\u53D1\u9001\u5BF9\u5E94\u547D\u4EE4\u83B7\u53D6\u6700\u65B0\u5361\u7247\uFF1BSession \u76F8\u5173\u64CD\u4F5C\u53EF\u53D1\u9001 `/sessions`\u3002"
+  }], "grey");
+}
 function card(title, content, buttons, template = "blue") {
   return cardElements(title, [{ tag: "markdown", content }, ...buttons], template);
 }
@@ -1372,21 +2014,36 @@ var LarkGateway = class {
     });
     this.channel.on("message", async (message) => this.handler.onMessage(message));
     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;
       const action = this.signer.verify(event.action.value, event.chatId) ?? (mappedFormAction ? this.signer.verify(mappedFormAction, event.chatId) : void 0);
-      if (!action) return { toast: { type: "error", content: "\u64CD\u4F5C\u5DF2\u5931\u6548\uFF0C\u8BF7\u7B49\u5F85\u65B0\u5361\u7247\u3002" } };
-      if (event.action.formValue || action.kind === "manual") {
+      if (!action) {
+        if (this.formActionsInFlight.has(event.messageId)) {
+          return { toast: { type: "warning", content: "\u64CD\u4F5C\u6B63\u5728\u5904\u7406\u4E2D\uFF0C\u8BF7\u7A0D\u5019\u3002" } };
+        }
+        console.error(`[lca] card action rejected: signature or mapping invalid for message=${event.messageId}`);
+        void this.markExpiredCard(event);
+        return { toast: { type: "error", content: "\u5361\u7247\u6216\u6309\u94AE\u5DF2\u5931\u6548\uFF0C\u8BF7\u83B7\u53D6\u6700\u65B0\u5361\u7247\u3002" } };
+      }
+      if (event.action.formValue || action.kind === "manual" || action.kind === "session-create" || action.kind === "startup-conflict" || action.kind === "resume-picker" || action.kind === "session-stop" || action.kind === "session-start-error") {
         if (this.formActionsInFlight.has(event.messageId)) {
-          return { toast: { type: "warning", content: action.kind === "manual" ? "\u7EC8\u7AEF\u64CD\u4F5C\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7A0D\u5019\u3002" : "\u7B54\u6848\u6B63\u5728\u63D0\u4EA4\uFF0C\u8BF7\u7A0D\u5019\u3002" } };
+          return { toast: { type: "warning", content: inFlightToast(action) } };
         }
         this.formActionsInFlight.add(event.messageId);
         void this.handleDeferredCardAction(event, action).finally(() => {
           this.formActionsInFlight.delete(event.messageId);
         });
-        return { toast: { type: "success", content: action.kind === "manual" ? "\u6B63\u5728\u64CD\u4F5C\u672C\u5730\u7EC8\u7AEF\u2026" : "\u6B63\u5728\u63D0\u4EA4\u5230\u672C\u5730\u7EC8\u7AEF\u2026" } };
+        return { toast: { type: "success", content: progressToast(action) } };
       }
       const result2 = await this.handler.onAction(event, action);
       if (result2.type === "error") return { toast: result2 };
+      if (result2.type === "session-create-form") {
+        this.rememberSessionCreateFormAction(event.messageId, event.chatId);
+        return {
+          toast: { type: "success", content: result2.content },
+          card: { type: "raw", data: sessionCreateCard() }
+        };
+      }
       if (result2.type === "manual") {
         this.rememberManualFormActions(event.messageId, event.chatId, result2.view);
         return {
@@ -1407,22 +2064,129 @@ var LarkGateway = class {
           card: { type: "raw", data: interactionInputCard(result2.agent, result2.label) }
         };
       }
-      return {
-        toast: result2,
-        card: { type: "raw", data: handledActionCard(action, result2.content) }
-      };
-    });
-  }
-  handler;
-  channel;
-  signer;
-  formActions = /* @__PURE__ */ new Map();
-  formActionsInFlight = /* @__PURE__ */ new Set();
-  async handleDeferredCardAction(event, action) {
-    try {
-      const result2 = await this.handler.onAction(event, action);
-      if (result2.type === "error") {
-        await this.channel.send(event.chatId, { text: `\u5361\u7247\u64CD\u4F5C\u672A\u5B8C\u6210\uFF1A${result2.content}` });
+      if (result2.type === "session-created") {
+        this.formActions.delete(event.messageId);
+        return {
+          toast: { type: "success", content: result2.content },
+          card: { type: "raw", data: sessionCreateResultCard(true, result2.content, result2.session) }
+        };
+      }
+      if (result2.type === "session-start-failed") {
+        return {
+          toast: { type: "error", content: result2.content },
+          card: { type: "raw", data: sessionStartupFailureCard(event.chatId, result2.failure, this.signer) }
+        };
+      }
+      if (result2.type === "resume-picker") {
+        return {
+          toast: { type: "success", content: result2.content },
+          card: { type: "raw", data: resumePickerCard(event.chatId, result2.session, result2.picker, this.signer) }
+        };
+      }
+      if (result2.type === "startup-conflict") {
+        return {
+          toast: { type: "warning", content: result2.content },
+          card: { type: "raw", data: startupConflictCard(event.chatId, requestSession(result2.request), result2.owner, this.signer) }
+        };
+      }
+      if (result2.type === "session-picker") {
+        return {
+          toast: { type: "success", content: result2.content },
+          card: { type: "raw", data: sessionPickerCard(
+            event.chatId,
+            result2.sessions,
+            result2.activeSessionId,
+            this.signer,
+            result2.confirmingStopSessionId
+          ) }
+        };
+      }
+      return {
+        toast: result2,
+        card: { type: "raw", data: handledActionCard(action, result2.content) }
+      };
+    });
+  }
+  handler;
+  channel;
+  signer;
+  formActions = /* @__PURE__ */ new Map();
+  formActionsInFlight = /* @__PURE__ */ new Set();
+  async handleDeferredCardAction(event, action) {
+    let initialResumePicker;
+    try {
+      if (action.kind === "session-create" && action.action === "submit") {
+        await this.updateCardAfterAction(event.messageId, sessionCreateProgressCard());
+      }
+      const result2 = await this.handler.onAction(event, action);
+      if (result2.type === "error") {
+        if (action.kind === "session-create") {
+          await this.updateCardAfterAction(
+            event.messageId,
+            sessionCreateFailureCard(event.chatId, result2.content, this.signer)
+          );
+          this.formActions.delete(event.messageId);
+          return;
+        }
+        await this.channel.send(event.chatId, { text: `\u5361\u7247\u64CD\u4F5C\u672A\u5B8C\u6210\uFF1A${result2.content}` });
+        return;
+      }
+      if (result2.type === "session-created") {
+        await this.updateCardAfterAction(event.messageId, sessionCreateResultCard(true, result2.content, result2.session));
+        this.formActions.delete(event.messageId);
+        return;
+      }
+      if (result2.type === "session-start-failed") {
+        await this.updateCardAfterAction(
+          event.messageId,
+          sessionStartupFailureCard(event.chatId, result2.failure, this.signer)
+        );
+        this.formActions.delete(event.messageId);
+        return;
+      }
+      if (result2.type === "resume-picker") {
+        if (action.kind === "session-create") initialResumePicker = result2.session;
+        await this.updateCardAfterAction(event.messageId, resumePickerCard(event.chatId, result2.session, result2.picker, this.signer));
+        return;
+      }
+      if (result2.type === "startup-conflict") {
+        await this.updateCardAfterAction(
+          event.messageId,
+          startupConflictCard(event.chatId, requestSession(result2.request), result2.owner, this.signer)
+        );
+        return;
+      }
+      if (result2.type === "session-picker") {
+        if (action.kind === "session-start-error") {
+          await this.channel.send(event.chatId, { card: sessionPickerCard(
+            event.chatId,
+            result2.sessions,
+            result2.activeSessionId,
+            this.signer,
+            result2.confirmingStopSessionId
+          ) });
+          return;
+        }
+        await this.updateCardAfterAction(event.messageId, sessionPickerCard(
+          event.chatId,
+          result2.sessions,
+          result2.activeSessionId,
+          this.signer,
+          result2.confirmingStopSessionId
+        ));
+        return;
+      }
+      if (result2.type === "session-create-form") {
+        const sent = await this.channel.send(event.chatId, { card: sessionCreateCard() });
+        this.rememberSessionCreateFormAction(sent.messageId, event.chatId);
+        const sourceCard = action.kind === "session-create" && result2.sessions ? sessionPickerCard(event.chatId, result2.sessions, result2.activeSessionId, this.signer, void 0, false) : sessionCreateOpenedCard();
+        await this.updateCardAfterAction(event.messageId, sourceCard).catch(async (error) => {
+          const detail = cardErrorDetail(error);
+          console.error(`[lca] failed to retire session-create source card: message=${event.messageId} detail=${detail}`);
+          await this.channel.send(event.chatId, {
+            text: "\u65B0\u5EFA\u8868\u5355\u5DF2\u53D1\u9001\uFF0C\u4F46\u539F\u5361\u7247\u72B6\u6001\u66F4\u65B0\u5931\u8D25\uFF1B\u8BF7\u4F7F\u7528\u6700\u65B0\u7684\u201C\u65B0\u5EFA Coding Session\u201D\u5361\u7247\u7EE7\u7EED\u64CD\u4F5C\u3002"
+          }).catch(() => void 0);
+        });
         return;
       }
       if (result2.type === "refresh") {
@@ -1444,8 +2208,17 @@ var LarkGateway = class {
       }
       await this.updateCardAfterAction(event.messageId, handledActionCard(action, result2.content));
     } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      await this.channel.send(event.chatId, { text: `\u5361\u7247\u64CD\u4F5C\u540C\u6B65\u5931\u8D25\uFF1A${detail}` }).catch(() => void 0);
+      const detail = cardErrorDetail(error);
+      if (initialResumePicker) {
+        await this.handler.onResumePickerDeliveryFailure?.(initialResumePicker).catch((cleanupError) => {
+          console.error(`[lca] resume picker rollback failed: session=${initialResumePicker?.id} detail=${cardErrorDetail(cleanupError)}`);
+        });
+      }
+      if (action.kind === "session-create") this.formActions.delete(event.messageId);
+      console.error(`[lca] deferred card action failed: kind=${action.kind} action=${action.action} message=${event.messageId} detail=${detail}`);
+      await this.channel.send(event.chatId, {
+        text: action.kind === "session-create" ? `\u65B0\u5EFA Session \u8868\u5355\u6253\u5F00\u5931\u8D25\uFF1A${detail}\u3002\u8BF7\u91CD\u65B0\u53D1\u9001 /sessions\uFF0C\u6216\u76F4\u63A5\u4F7F\u7528 /start \u547D\u4EE4\u3002` : `\u5361\u7247\u64CD\u4F5C\u540C\u6B65\u5931\u8D25\uFF1A${detail}`
+      }).catch(() => void 0);
     }
   }
   async updateCardAfterAction(messageId, card2) {
@@ -1463,6 +2236,17 @@ var LarkGateway = class {
     }
     throw lastError;
   }
+  async markExpiredCard(event) {
+    try {
+      await this.updateCardAfterAction(event.messageId, expiredActionCard());
+    } catch (error) {
+      const detail = cardErrorDetail(error);
+      console.error(`[lca] failed to mark expired card: message=${event.messageId} detail=${detail}`);
+      await this.channel.send(event.chatId, {
+        text: "\u5361\u7247\u6216\u6309\u94AE\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u53D1\u9001\u5BF9\u5E94\u547D\u4EE4\u83B7\u53D6\u6700\u65B0\u5361\u7247\uFF1BSession \u76F8\u5173\u64CD\u4F5C\u53EF\u53D1\u9001 /sessions\u3002"
+      }).catch(() => void 0);
+    }
+  }
   connect() {
     return this.channel.connect();
   }
@@ -1488,23 +2272,23 @@ var LarkGateway = class {
     await this.channel.updateCard(messageId, handledActionCard(action, content));
     this.formActions.delete(messageId);
   }
-  async sendManual(chatId, view) {
-    const result2 = await this.channel.send(chatId, { card: manualControlCard(chatId, view, this.signer) });
-    this.rememberManualFormActions(result2.messageId, chatId, view);
+  async sendManual(chatId, view2) {
+    const result2 = await this.channel.send(chatId, { card: manualControlCard(chatId, view2, this.signer) });
+    this.rememberManualFormActions(result2.messageId, chatId, view2);
     return result2;
   }
-  rememberManualFormActions(messageId, chatId, view) {
-    if (view.state === "recovered" || view.state === "exited") {
+  rememberManualFormActions(messageId, chatId, view2) {
+    if (view2.state === "recovered" || view2.state === "exited") {
       this.formActions.delete(messageId);
       return;
     }
     const common = {
       kind: "manual",
-      sessionId: view.session.id,
-      manualMode: view.mode ?? "fallback",
-      agent: view.session.agent,
-      paneId: view.session.paneId,
-      fingerprint: view.screen.fingerprint,
+      sessionId: view2.session.id,
+      manualMode: view2.mode ?? "fallback",
+      agent: view2.session.agent,
+      paneId: view2.session.paneId,
+      fingerprint: view2.screen.fingerprint,
       chatId
     };
     this.formActions.set(messageId, /* @__PURE__ */ new Map([
@@ -1512,6 +2296,19 @@ var LarkGateway = class {
       [MANUAL_SUBMIT_ACTION, this.signer.sign({ ...common, action: MANUAL_SUBMIT_ACTION }, 10 * 6e4)]
     ]));
   }
+  rememberSessionCreateFormAction(messageId, chatId) {
+    this.formActions.set(messageId, /* @__PURE__ */ new Map([[
+      SESSION_CREATE_SUBMIT_ACTION,
+      this.signer.sign({
+        kind: "session-create",
+        agent: "codex",
+        action: "submit",
+        paneId: "",
+        fingerprint: "create",
+        chatId
+      }, 10 * 6e4)
+    ]]));
+  }
   rememberFormActions(messageId, chatId, paneId, screen, agent) {
     if (screen.interaction?.semantics?.activation !== "toggle") {
       this.formActions.delete(messageId);
@@ -1540,10 +2337,27 @@ var LarkGateway = class {
   sendSessionPicker(chatId, sessions, activeSessionId) {
     return this.channel.send(chatId, { card: sessionPickerCard(chatId, sessions, activeSessionId, this.signer) });
   }
+  sendResumePicker(chatId, session, picker) {
+    return this.channel.send(chatId, { card: resumePickerCard(chatId, session, picker, this.signer) });
+  }
+  sendStartupConflict(chatId, request, owner) {
+    return this.channel.send(chatId, { card: startupConflictCard(chatId, requestSession(request), owner, this.signer) });
+  }
+  async sendSessionCreate(chatId) {
+    const result2 = await this.channel.send(chatId, { card: sessionCreateCard() });
+    this.rememberSessionCreateFormAction(result2.messageId, chatId);
+    return result2;
+  }
+  sendSessionStartupFailure(chatId, failure) {
+    return this.channel.send(chatId, { card: sessionStartupFailureCard(chatId, failure, this.signer) });
+  }
   sendStopConfirmation(chatId, paneId, fingerprint, agent) {
     return this.channel.send(chatId, { card: stopCard(chatId, paneId, fingerprint, this.signer, agent) });
   }
 };
+function requestSession(request) {
+  return { id: request.sessionId, agent: request.agent, cwd: request.cwd };
+}
 function cardActionLocked(error) {
   if (typeof error === "string") return /card action is lock/i.test(error);
   if (error instanceof Error && /card action is lock/i.test(error.message)) return true;
@@ -1551,6 +2365,234 @@ function cardActionLocked(error) {
   const record = error;
   return ["message", "msg", "cause"].some((key) => cardActionLocked(record[key]));
 }
+function progressToast(action) {
+  if (action.kind === "manual") return "\u6B63\u5728\u64CD\u4F5C\u672C\u5730\u7EC8\u7AEF\u2026";
+  if (action.kind === "session-create") return action.action === "open" ? "\u6B63\u5728\u6253\u5F00\u65B0\u5EFA\u8868\u5355\u2026" : "\u6B63\u5728\u542F\u52A8 Session\u2026";
+  if (action.kind === "resume-picker") return action.action.startsWith("select:") ? "\u6B63\u5728\u6062\u590D Session\u2026" : "\u6B63\u5728\u66F4\u65B0 Resume Picker\u2026";
+  if (action.kind === "startup-conflict") return action.action === "new" ? "\u6B63\u5728\u542F\u52A8\u65B0 Session\u2026" : "\u6B63\u5728\u5904\u7406 Session \u51B2\u7A81\u2026";
+  if (action.kind === "session-stop") return "\u6B63\u5728\u5904\u7406 Session\u2026";
+  if (action.kind === "session-start-error") return action.action === "create" ? "\u6B63\u5728\u6253\u5F00\u65B0\u5EFA\u8868\u5355\u2026" : "\u6B63\u5728\u6253\u5F00 Sessions\u2026";
+  return "\u6B63\u5728\u63D0\u4EA4\u5230\u672C\u5730\u7EC8\u7AEF\u2026";
+}
+function inFlightToast(action) {
+  if (action.kind === "manual") return "\u7EC8\u7AEF\u64CD\u4F5C\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7A0D\u5019\u3002";
+  if (action.kind === "session-create") return action.action === "open" ? "\u6B63\u5728\u6253\u5F00\u65B0\u5EFA\u8868\u5355\uFF0C\u8BF7\u7A0D\u5019\u3002" : "Session \u6B63\u5728\u542F\u52A8\uFF0C\u8BF7\u7A0D\u5019\u3002";
+  if (action.kind === "resume-picker") return "Resume Picker \u64CD\u4F5C\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7A0D\u5019\u3002";
+  if (action.kind === "startup-conflict") return "Session \u51B2\u7A81\u64CD\u4F5C\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7A0D\u5019\u3002";
+  if (action.kind === "session-stop") return "Session \u64CD\u4F5C\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7A0D\u5019\u3002";
+  if (action.kind === "session-start-error") return "\u6B63\u5728\u5904\u7406\u542F\u52A8\u5931\u8D25\u64CD\u4F5C\uFF0C\u8BF7\u7A0D\u5019\u3002";
+  return "\u7B54\u6848\u6B63\u5728\u63D0\u4EA4\uFF0C\u8BF7\u7A0D\u5019\u3002";
+}
+function cardErrorDetail(error) {
+  const response = error && typeof error === "object" ? error.response : void 0;
+  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);
+  return code ? `code=${code} ${sanitized}` : sanitized;
+}
+
+// src/lark/start-command.ts
+function parseStartCommand(input) {
+  const tokens = tokenize(input);
+  if (tokens[0] !== "/start") throw invalid("\u547D\u4EE4\u5FC5\u987B\u4EE5 /start \u5F00\u5934");
+  const sessionId = tokens[1];
+  if (!sessionId || sessionId.startsWith("--")) throw invalid("\u8BF7\u63D0\u4F9B session \u540D\u79F0");
+  let agentValue;
+  let cwd;
+  let resume;
+  for (let index = 2; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--agent") {
+      if (agentValue !== void 0) throw invalid("--agent \u4E0D\u80FD\u91CD\u590D");
+      agentValue = requiredValue(tokens, ++index, "--agent");
+      continue;
+    }
+    if (token === "--cwd") {
+      if (cwd !== void 0) throw invalid("--cwd \u4E0D\u80FD\u91CD\u590D");
+      cwd = requiredValue(tokens, ++index, "--cwd");
+      continue;
+    }
+    if (token === "--resume-last") {
+      throw invalid("\u98DE\u4E66\u7AEF\u4E0D\u652F\u6301 --resume-last\uFF0C\u8BF7\u4F7F\u7528 --resume \u6253\u5F00\u539F\u751F Resume Picker");
+    }
+    if (token === "--resume") {
+      if (resume) throw invalid("\u53EA\u80FD\u9009\u62E9\u4E00\u79CD\u6062\u590D\u65B9\u5F0F");
+      const candidate = tokens[index + 1];
+      if (candidate && !candidate.startsWith("--")) {
+        throw invalid("\u98DE\u4E66\u7AEF\u4E0D\u652F\u6301\u8F93\u5165\u5386\u53F2 Session ID\uFF0C\u8BF7\u4F7F\u7528 --resume \u6253\u5F00\u539F\u751F Resume Picker");
+      }
+      resume = { mode: "picker" };
+      continue;
+    }
+    throw invalid(`\u65E0\u6CD5\u8BC6\u522B\u53C2\u6570\uFF1A${token}`);
+  }
+  const agent = agentValue ? normalizeAgentId(agentValue) : void 0;
+  if (!agentValue) throw invalid("\u8BF7\u63D0\u4F9B --agent");
+  if (!agent) throw invalid(`\u4E0D\u652F\u6301\u7684 agent\uFF1A${agentValue}\uFF1B\u53EF\u9009 codex\u3001traex\u3001claude`);
+  if (!cwd) throw invalid("\u8BF7\u63D0\u4F9B --cwd");
+  return { sessionId, agent, cwd, resume };
+}
+function tokenize(input) {
+  const tokens = [];
+  let current = "";
+  let quote;
+  let escaped = false;
+  const push = () => {
+    if (current) tokens.push(current);
+    current = "";
+  };
+  for (const char of input.trim()) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+    } else if (char === "\\" && quote !== "'") {
+      escaped = true;
+    } else if (quote) {
+      if (char === quote) quote = void 0;
+      else current += char;
+    } else if (char === "'" || char === '"') {
+      quote = char;
+    } else if (/\s/.test(char)) {
+      push();
+    } else {
+      current += char;
+    }
+  }
+  if (escaped) current += "\\";
+  if (quote) throw invalid("\u5F15\u53F7\u6CA1\u6709\u95ED\u5408");
+  push();
+  return tokens;
+}
+function requiredValue(tokens, index, option2) {
+  const value = tokens[index];
+  if (!value || value.startsWith("--")) throw invalid(`${option2} \u7F3A\u5C11\u53C2\u6570\u503C`);
+  return value;
+}
+function invalid(reason) {
+  return new AppError("INVALID_OPTIONS", reason, { reason });
+}
+
+// src/screen/resume-picker.ts
+import { createHash as createHash2 } from "crypto";
+function parseResumePicker(raw, agent) {
+  const normalized = normalizeScreen(raw);
+  return agent === "claude" ? parseClaudePicker(normalized, agent) : parseCodexStylePicker(normalized, agent);
+}
+function parseCodexStylePicker(normalized, agent) {
+  if (!/^\s*Resume a previous session\s*$/mi.test(normalized)) return void 0;
+  const lines = normalized.split("\n");
+  const start = lines.findIndex((line) => /Type to search/i.test(line));
+  const end = lines.findIndex((line, index) => index > start && /enter\s+resume/i.test(line));
+  if (start < 0 || end < 0) return void 0;
+  const options = [];
+  for (const line of lines.slice(start + 1, end)) {
+    const match = line.match(/^\s*(❯)?\s*(\d+\s*(?:m|h|d|w|mo|y)\s+ago)\s+(.+?)\s*$/i);
+    if (!match?.[3]) continue;
+    const label = match[3].trim();
+    options.push(option(options.length, label, match[2]?.replace(/\s+/g, ""), Boolean(match[1])));
+  }
+  if (options.length === 0) return void 0;
+  const positionMatch = normalized.match(/(\d+)\s*\/\s*(\d+)\s*·\s*(\d+)%/);
+  return view(
+    agent,
+    normalized,
+    options,
+    positionMatch ? Number(positionMatch[1]) : void 0,
+    positionMatch ? Number(positionMatch[2]) : void 0
+  );
+}
+function parseClaudePicker(normalized, agent) {
+  const header = normalized.match(/^\s*Resume session(?:\s*\((\d+)\s+of\s+(\d+)\))?\s*$/mi);
+  if (!header) return void 0;
+  const lines = normalized.split("\n");
+  const start = lines.findIndex((line) => /⌕\s*Search|Search…/i.test(line));
+  const end = lines.findIndex((line, index) => index > start && /Ctrl\+A to show all projects/i.test(line));
+  if (start < 0 || end < 0) return void 0;
+  const options = [];
+  const body = lines.slice(start + 1, end);
+  const navigation = {
+    canPrevious: body.some((line) => /^\s*↑/.test(line)),
+    canNext: body.some((line) => /^\s*↓/.test(line))
+  };
+  for (let index = 0; index < body.length - 1; index += 1) {
+    const title = body[index] ?? "";
+    const detail = body[index + 1] ?? "";
+    if (!/\b(?:minute|hour|day|week|month|year)s? ago\s*·/i.test(detail)) continue;
+    const selected = /^\s*❯/.test(title);
+    const label = title.replace(/^\s*[❯↓↑]?\s*/, "").trim();
+    if (!label || /^[↓↑]/.test(title.trim())) continue;
+    options.push(option(options.length, label, detail.trim(), selected));
+    index += 1;
+  }
+  if (options.length === 0) return void 0;
+  return view(
+    agent,
+    normalized,
+    options,
+    header[1] ? Number(header[1]) : void 0,
+    header[2] ? Number(header[2]) : void 0,
+    navigation
+  );
+}
+function option(visibleIndex, label, detail, selected) {
+  const id = createHash2("sha256").update(`${visibleIndex}
+${label}
+${detail ?? ""}`).digest("hex").slice(0, 16);
+  return { id, label, detail, selected, visibleIndex };
+}
+function view(agent, normalized, options, position, total, navigation) {
+  const selectedIndex = Math.max(0, options.findIndex((candidate) => candidate.selected));
+  const hasHiddenOptions = position !== void 0 && total !== void 0 && total > options.length;
+  return {
+    agent,
+    fingerprint: createHash2("sha256").update(normalized).digest("hex"),
+    options,
+    selectedIndex,
+    position,
+    total,
+    canPrevious: navigation?.canPrevious || hasHiddenOptions && position > 1,
+    canNext: navigation?.canNext || hasHiddenOptions && position < total
+  };
+}
+
+// src/terminal/startup-error.ts
+var MAX_LINES = 20;
+var MAX_CHARS = 2e3;
+var EMPTY_EXCERPT = "Agent \u672A\u8F93\u51FA\u53EF\u7528\u9519\u8BEF\u4FE1\u606F\u3002";
+function startupTerminalExcerpt(raw) {
+  const sanitized = redactSecrets(stripTerminalControls(raw));
+  const lines = sanitized.split("\n").map(cleanLine).filter((line) => line !== void 0);
+  while (lines[0] === "") lines.shift();
+  while (lines.at(-1) === "") lines.pop();
+  if (lines.length === 0) return EMPTY_EXCERPT;
+  const errorIndex = lines.findIndex((line) => /\b(?:error|failed|fatal)\b/i.test(line));
+  const selected = (errorIndex >= 0 ? lines.slice(errorIndex) : lines.slice(-MAX_LINES)).slice(0, MAX_LINES);
+  let excerpt = selected.join("\n").trim();
+  if (!excerpt) return EMPTY_EXCERPT;
+  const lineTruncated = errorIndex >= 0 ? lines.length - errorIndex > MAX_LINES : lines.length > MAX_LINES;
+  const charTruncated = excerpt.length > MAX_CHARS;
+  if (charTruncated) excerpt = excerpt.slice(0, MAX_CHARS).trimEnd();
+  if (lineTruncated || charTruncated) excerpt = `${excerpt}
+\u2026 \u8F93\u51FA\u5DF2\u622A\u65AD`;
+  return excerpt;
+}
+function stripTerminalControls(value) {
+  return value.replace(/\u001B\][^\u0007]*(?:\u0007|\u001B\\)/g, "").replace(/\u001B(?:[@-_][0-?]*[ -/]*[@-~]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\r/g, "\n").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001A\u001C-\u001F\u007F]/g, "");
+}
+function cleanLine(value) {
+  const line = value.replace(/[ \t]+$/g, "").trimStart();
+  if (/^Pane is dead(?:\s|\(|$)/i.test(line)) return void 0;
+  if (/^[╭╮╰╯┌┐└┘─━═│┃┊┋┄┅┈┉┼├┤┬┴┿╋+\-_=\s]+$/.test(line)) return void 0;
+  return line.replace(/^[│┃]\s?/, "").replace(/\s?[│┃]$/, "").trimEnd();
+}
+function redactSecrets(value) {
+  return value.replace(/\b(authorization\s*[:=]\s*)(?:Bearer\s+)?[^\s,;]+/gi, "$1[REDACTED]").replace(/\b(Bearer)\s+[^\s,'"\]}]+/gi, "$1 [REDACTED]").replace(
+    /\b(api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret|app[_-]?secret|cookie)\b(\s*[:=]\s*)([^\s,;]+)/gi,
+    "$1$2[REDACTED]"
+  ).replace(/([?&](?:api[_-]?key|access[_-]?token|token|secret|signature)=)[^&#\s]+/gi, "$1[REDACTED]");
+}
 
 // src/daemon/server.ts
 var AssistantDaemon = class {
@@ -1573,6 +2615,7 @@ var AssistantDaemon = class {
   config;
   state;
   tmux;
+  reconciler;
   screen;
   previousScreen;
   completedEvents = /* @__PURE__ */ new Set();
@@ -1589,6 +2632,9 @@ var AssistantDaemon = class {
   unresolvedCandidate;
   unresolvedNotified = /* @__PURE__ */ new Set();
   closedManualCards = /* @__PURE__ */ new Set();
+  pendingAgentSessionClaims = /* @__PURE__ */ new Map();
+  pendingResumePickers = /* @__PURE__ */ new Map();
+  pendingStartupConflicts = /* @__PURE__ */ new Map();
   pendingInteractionInput;
   attachAttempts = /* @__PURE__ */ new Map();
   server = createServer((socket) => this.handleSocket(socket));
@@ -1599,11 +2645,21 @@ var AssistantDaemon = class {
     this.config = config;
     this.state = await this.store.loadState();
     this.tmux = new TmuxController(config.tmuxBinary);
+    this.reconciler = new SessionReconciler(
+      this.tmux,
+      this.sessionName,
+      3,
+      (message) => this.log(message),
+      async (agent) => {
+        const adapter = getAgentAdapter(agent);
+        return (await runFile(adapter.binary(this.config), [...adapter.versionArgs])).stdout.trim();
+      }
+    );
     const secrets = await this.store.loadSecrets();
     if (!secrets) throw new Error("missing secrets; run lark-coding-assistant init again");
     await this.acquireRuntimeFiles();
     try {
-      await this.reconcileSessions();
+      await this.reconcileSessions(true);
       await rm(this.paths.socket, { force: true });
       await new Promise((resolve, reject) => {
         this.server.once("error", reject);
@@ -1612,9 +2668,11 @@ var AssistantDaemon = class {
       await chmod3(this.paths.socket, 384);
       this.gateway = this.gatewayFactory(config, secrets, {
         onMessage: (message) => this.onLarkMessage(message),
-        onAction: (event, action) => this.onLarkAction(event, action)
+        onAction: (event, action) => this.onLarkAction(event, action),
+        onResumePickerDeliveryFailure: (session) => this.handleResumePickerDeliveryFailure(session)
       });
       await this.gateway.connect();
+      await this.refreshNativeAgentSessionClaims();
       this.schedulePoll();
       await this.log("daemon started");
     } catch (error) {
@@ -1645,7 +2703,7 @@ var AssistantDaemon = class {
         return;
       } catch (error) {
         if (!isAlreadyExists(error)) throw error;
-        const existingPid = Number.parseInt(await readFile2(this.paths.pid, "utf8").catch(() => ""), 10);
+        const existingPid = Number.parseInt(await readFile3(this.paths.pid, "utf8").catch(() => ""), 10);
         if (Number.isInteger(existingPid) && processIsAlive(existingPid)) {
           throw new Error(`daemon is already running with PID ${existingPid}`);
         }
@@ -1656,7 +2714,7 @@ var AssistantDaemon = class {
   }
   async releaseRuntimeFiles() {
     if (!this.ownsRuntimeFiles) return;
-    const ownerPid = Number.parseInt(await readFile2(this.paths.pid, "utf8").catch(() => ""), 10);
+    const ownerPid = Number.parseInt(await readFile3(this.paths.pid, "utf8").catch(() => ""), 10);
     if (ownerPid === process.pid) {
       await Promise.all([rm(this.paths.socket, { force: true }), rm(this.paths.pid, { force: true })]);
     }
@@ -1707,20 +2765,21 @@ var AssistantDaemon = class {
         return this.rotateBindCode();
       case "resetOwner":
         return this.resetOwner();
+      case "agentSessionStarted":
+        return this.handleAgentSessionStarted(request.candidate);
       case "turnComplete":
         return this.handleTurnComplete(request.candidate);
     }
   }
   async startSession(sessionId, cwd, agentId, resume) {
-    if (!validSessionId(sessionId)) {
-      return fail(new AppError(
-        "INVALID_SESSION_NAME",
-        "session name must use letters, digits, underscore, or dash",
-        { sessionId }
-      ));
+    try {
+      await validateStartSessionRequest({ sessionId, cwd, agent: agentId, resume });
+    } catch (error) {
+      return fail(error);
     }
+    await this.reconcileSessions(true);
     const existing = this.state.sessions?.[sessionId];
-    if (existing && await this.tmux.inspect(existing.paneId)) {
+    if (existing) {
       return fail(new AppError(
         "SESSION_EXISTS",
         `managed coding-agent session is already running: ${sessionId}`,
@@ -1736,21 +2795,33 @@ var AssistantDaemon = class {
     }
     const adapter = getAgentAdapter(agentId);
     const binary = adapter.binary(this.config);
-    const agentVersion = (await runFile(binary, [...adapter.versionArgs])).stdout.trim();
-    const tmuxSessionName = existing?.sessionName ?? `${this.sessionName}-${sessionId}`;
-    const pane = await this.tmux.create({
-      sessionName: tmuxSessionName,
-      cwd,
-      binary,
-      args: adapter.buildLaunchArgs({
-        resume,
-        stopHookCommand: this.stopHookCommand
-      }),
-      env: {
-        LARK_CODING_ASSISTANT_SOCKET: this.paths.socket,
-        LARK_CODING_ASSISTANT_SESSION_ID: sessionId
-      }
-    });
+    let agentVersion;
+    try {
+      agentVersion = (await runFile(binary, [...adapter.versionArgs])).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 }));
+    }
+    const tmuxSessionName = `${this.sessionName}-${sessionId}`;
+    let pane;
+    try {
+      pane = await this.tmux.create({
+        sessionName: tmuxSessionName,
+        cwd,
+        binary,
+        args: adapter.buildLaunchArgs({
+          resume,
+          stopHookCommand: this.stopHookCommand
+        }),
+        env: {
+          LARK_CODING_ASSISTANT_SOCKET: this.paths.socket,
+          LARK_CODING_ASSISTANT_SESSION_ID: sessionId,
+          LARK_CODING_ASSISTANT_AGENT: agentId
+        },
+        preserveOnExit: true
+      });
+    } catch (error) {
+      return fail(isAppError(error) ? error : new AppError("START_FAILED", "failed to create tmux session", { sessionId }, { cause: error }));
+    }
     const binding = this.createSessionBinding();
     const session = {
       id: sessionId,
@@ -1761,7 +2832,33 @@ var AssistantDaemon = class {
       agentVersion,
       updatedAt: Date.now()
     };
-    this.state = {
+    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,
@@ -1770,8 +2867,45 @@ var AssistantDaemon = class {
       bindCodeExpiresAt: binding.mode === "code" ? Date.now() + 10 * 6e4 : void 0,
       updatedAt: Date.now()
     };
-    await this.store.saveState(this.state);
-    await this.poll();
+    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 (resume && resume.mode !== "picker") {
+      const initialClaim = await this.waitForInitialAgentSessionClaim(sessionId, pane.pid);
+      if (!initialClaim.ok) {
+        await this.stopSession(sessionId).catch(() => void 0);
+        return initialClaim;
+      }
+    } else if (!resume) {
+      const stable = await this.waitForStartupStability(session, 500);
+      if (!stable.ok) {
+        await this.stopSession(sessionId).catch(() => void 0);
+        return stable;
+      }
+    }
+    if (resume?.mode !== "picker") {
+      await this.tmux.preserveOnExit(session.sessionName, false).catch((error) => this.log(
+        `failed to disable startup preservation for ${sessionId}: ${errorMessage3(error)}`
+      ));
+    }
+    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 } };
   }
   createSessionBinding() {
@@ -1783,10 +2917,41 @@ var AssistantDaemon = class {
     }
     return { mode: "code", bindCode: createBindCode(), expiresInSeconds: 600 };
   }
-  async runtimeStatus(sessionId = this.state.activeSessionId) {
-    const session = sessionId ? this.state.sessions?.[sessionId] : void 0;
-    const pane = session ? await this.tmux.inspect(session.paneId) : void 0;
-    return { state: this.state, session, screen: sessionId === this.state.activeSessionId ? this.screen : void 0, paneAlive: Boolean(pane && !pane.dead) };
+  async runtimeStatus(sessionId) {
+    const selectedSessionId = sessionId ?? this.state.activeSessionId;
+    const selected = selectedSessionId ? this.state.sessions?.[selectedSessionId] : void 0;
+    const requestedSessions = sessionId ? selected ? [selected] : [] : Object.values(this.state.sessions ?? {});
+    const sessions = await Promise.all(requestedSessions.map((session) => this.sessionRuntimeStatus(session)));
+    const selectedRuntime = selected ? sessions.find(({ session }) => session.id === selected.id) ?? await this.sessionRuntimeStatus(selected) : void 0;
+    return {
+      state: this.state,
+      session: selected,
+      screen: selectedRuntime?.screen,
+      paneAlive: selectedRuntime?.paneAlive === true,
+      sessions
+    };
+  }
+  async sessionRuntimeStatus(session) {
+    const active = session.id === this.state.activeSessionId;
+    try {
+      const pane = await this.tmux.inspect(session.paneId);
+      if (!pane || pane.dead) {
+        return {
+          session,
+          screen: getAgentAdapter(session.agent).detectScreen("", false),
+          paneAlive: false,
+          active
+        };
+      }
+      const screen = active && this.screen ? this.screen : getAgentAdapter(session.agent).detectScreen(
+        await this.tmux.capture(session.paneId, 160),
+        true,
+        { x: pane.cursorX, y: pane.cursorY }
+      );
+      return { session, screen, paneAlive: true, active };
+    } catch {
+      return { session, active };
+    }
   }
   async tail(lines) {
     const session = this.activeSession();
@@ -1818,6 +2983,40 @@ var AssistantDaemon = class {
       }
     }
     if (message.senderId !== this.state.ownerOpenId || message.chatId !== this.state.boundChatId) return;
+    if (text === "/start") {
+      try {
+        await this.gateway?.sendSessionCreate(message.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");
+      }
+      return;
+    }
+    if (text.startsWith("/start ")) {
+      let request;
+      try {
+        request = parseStartCommand(text);
+      } catch (error) {
+        await this.gateway?.sendText(message.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));
+      } else if (result3.state === "picker") {
+        try {
+          await this.gateway?.sendResumePicker(message.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");
+        }
+      } 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));
+      return;
+    }
     const tailMatch = text.match(/^\/tail(?:\s+(\d+))?$/);
     if (tailMatch) {
       const lines = tailMatch[1] ? Number(tailMatch[1]) : 80;
@@ -1825,7 +3024,7 @@ var AssistantDaemon = class {
         await this.gateway?.sendText(message.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
         return;
       }
-      const output = await this.tail(lines).catch((error) => `\u8BFB\u53D6\u5931\u8D25\uFF1A${errorMessage2(error)}`);
+      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}
@@ -1841,13 +3040,13 @@ ${escapeFence2(output).slice(-6800)}
     }
     if (text === "/manual") {
       await this.poll();
-      const view = this.currentManualView();
-      if (!view) await this.gateway?.sendText(message.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u9065\u63A7\u7684 active tmux session\u3002");
+      const view2 = this.currentManualView();
+      if (!view2) await this.gateway?.sendText(message.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u9065\u63A7\u7684 active tmux session\u3002");
       else {
         try {
-          await this.gateway?.sendManual(message.chatId, view);
+          await this.gateway?.sendManual(message.chatId, view2);
         } catch (error) {
-          await this.log(`manual card failed: ${errorMessage2(error)}`);
+          await this.log(`manual card failed: ${errorMessage3(error)}`);
           await this.gateway?.sendText(
             message.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"
@@ -1885,7 +3084,7 @@ ${escapeFence2(output).slice(-6800)}
       return;
     }
     if (text === "/sessions") {
-      const sessions = await this.reconcileSessions();
+      const sessions = await this.reconcileSessions(true);
       try {
         await this.gateway?.sendSessionPicker(
           message.chatId,
@@ -1893,7 +3092,7 @@ ${escapeFence2(output).slice(-6800)}
           this.state.activeSessionId
         );
       } catch (error) {
-        await this.log(`session picker notification failed: ${errorMessage2(error)}`);
+        await this.log(`session picker notification failed: ${errorMessage3(error)}`);
         await this.gateway?.sendText(
           message.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"
@@ -2048,6 +3247,41 @@ ${escapeFence2(output).slice(-6800)}
       const result3 = await this.useSession(target.id);
       return result3.ok ? { type: "success", content: `\u5DF2\u8FDE\u63A5\u5230 ${target.id}` } : { type: "error", content: result3.error };
     }
+    if (action.kind === "session-stop") return this.handleSessionStopAction(action);
+    if (action.kind === "session-start-error") {
+      if (action.action === "create") return { type: "session-create-form", content: "\u8BF7\u586B\u5199\u542F\u52A8\u4FE1\u606F\u3002" };
+      if (action.action === "sessions") {
+        await this.reconcileSessions(true);
+        return this.sessionPickerActionResult("\u5DF2\u53D1\u9001\u6700\u65B0 Sessions\u3002");
+      }
+      return { type: "error", content: "\u65E0\u6CD5\u8BC6\u522B\u542F\u52A8\u5931\u8D25\u5361\u7247\u64CD\u4F5C\u3002" };
+    }
+    if (action.kind === "startup-conflict") return this.handleStartupConflictAction(action);
+    if (action.kind === "resume-picker") return this.handleResumePickerAction(action);
+    if (action.kind === "session-create") {
+      if (action.action === "open") {
+        return {
+          type: "session-create-form",
+          content: "\u8BF7\u586B\u5199\u542F\u52A8\u4FE1\u606F\u3002",
+          sessions: Object.values(this.state.sessions ?? {}),
+          activeSessionId: this.state.activeSessionId
+        };
+      }
+      if (action.action !== "submit" || !event.action.formValue) {
+        return { type: "error", content: "\u65E0\u6CD5\u8BC6\u522B\u65B0\u5EFA Session \u8868\u5355\uFF0C\u8BF7\u91CD\u65B0\u53D1\u9001 /sessions\u3002" };
+      }
+      const request = startRequestFromForm(event.action.formValue);
+      if (!request.ok) return { type: "error", content: request.error };
+      const result3 = await this.startRemoteSession(request.value);
+      if (!result3.ok) return larkStartupError(result3.error, request.value);
+      if (result3.state === "picker") {
+        return { type: "resume-picker", content: "\u8BF7\u9009\u62E9\u8981\u6062\u590D\u7684\u5386\u53F2 Session\u3002", session: result3.session, picker: result3.picker };
+      }
+      if (result3.state === "conflict") {
+        return { type: "startup-conflict", content: "\u76EE\u6807\u539F\u751F Session \u5DF2\u7531\u73B0\u6709 LCA Session \u8FDE\u63A5\u3002", request: result3.request, owner: result3.owner };
+      }
+      return { type: "session-created", content: remoteStartSuccess(result3.session), session: result3.session };
+    }
     if (action.kind === "manual") {
       return this.withInteractionNotificationsSuppressed(() => this.handleManualAction(action, event));
     }
@@ -2112,7 +3346,7 @@ ${escapeFence2(output).slice(-6800)}
       return {
         type: "manual",
         content: "\u624B\u52A8\u64CD\u4F5C\u5931\u8D25\u3002",
-        view: this.manualView(session, current2, "error", errorMessage2(error), operation, action.manualMode)
+        view: this.manualView(session, current2, "error", errorMessage3(error), operation, action.manualMode)
       };
     }
     const current = this.screen ?? screen;
@@ -2130,6 +3364,142 @@ ${escapeFence2(output).slice(-6800)}
       view: this.manualView(session, current, "active", void 0, operation, action.manualMode)
     };
   }
+  async handleSessionStopAction(action) {
+    const sessionId = action.sessionId ?? "";
+    const target = this.state.sessions?.[sessionId];
+    if (!target || target.agent !== action.agent || target.paneId !== action.paneId || String(target.updatedAt) !== action.fingerprint) {
+      return { type: "error", content: "\u76EE\u6807 session \u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u53D1\u9001 /sessions\u3002" };
+    }
+    if (action.action === "request") {
+      return this.sessionPickerActionResult(`\u8BF7\u786E\u8BA4\u662F\u5426\u5173\u95ED ${target.id}\u3002`, target.id);
+    }
+    if (action.action === "cancel") {
+      return this.sessionPickerActionResult(`\u5DF2\u53D6\u6D88\u5173\u95ED ${target.id}\u3002`);
+    }
+    if (action.action !== "confirm") return { type: "error", content: "\u65E0\u6CD5\u8BC6\u522B\u5173\u95ED\u64CD\u4F5C\uFF0C\u8BF7\u91CD\u65B0\u53D1\u9001 /sessions\u3002" };
+    const stopped = await this.stopSession(target.id);
+    if (!stopped.ok) return { type: "error", content: remoteError(stopped) };
+    return this.sessionPickerActionResult(`\u5DF2\u5173\u95ED ${target.id}\u3002`);
+  }
+  async handleStartupConflictAction(action) {
+    const requestedSessionId = action.sessionId ?? "";
+    const pending = this.pendingStartupConflicts.get(requestedSessionId);
+    const owner = pending ? this.state.sessions?.[pending.ownerSessionId] : void 0;
+    if (!pending || !owner || pending.request.agent !== action.agent || owner.paneId !== action.paneId || String(owner.updatedAt) !== action.fingerprint) {
+      return { type: "error", content: "Session \u51B2\u7A81\u72B6\u6001\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u521B\u5EFA Session\u3002" };
+    }
+    if (action.action === "cancel") {
+      this.pendingStartupConflicts.delete(requestedSessionId);
+      return { type: "success", content: `\u5DF2\u53D6\u6D88\u521B\u5EFA ${requestedSessionId}\u3002` };
+    }
+    if (action.action === "connect") {
+      const selected = await this.useSession(owner.id);
+      if (!selected.ok) return { type: "error", content: remoteError(selected) };
+      this.pendingStartupConflicts.delete(requestedSessionId);
+      return { type: "session-created", content: `\u5DF2\u8FDE\u63A5\u73B0\u6709 session\u300C${owner.id}\u300D\u3002`, session: owner };
+    }
+    if (action.action !== "new") return { type: "error", content: "\u65E0\u6CD5\u8BC6\u522B\u51B2\u7A81\u5904\u7406\u64CD\u4F5C\u3002" };
+    this.pendingStartupConflicts.delete(requestedSessionId);
+    const result2 = await this.startRemoteSession({ ...pending.request, resume: void 0 });
+    if (!result2.ok) return larkStartupError(result2.error, pending.request);
+    if (result2.state !== "ready") return { type: "error", content: "\u542F\u52A8\u65B0\u4F1A\u8BDD\u65F6\u51FA\u73B0\u4E86\u610F\u5916\u6062\u590D\u72B6\u6001\uFF0C\u8BF7\u91CD\u8BD5\u3002" };
+    return { type: "session-created", content: remoteStartSuccess(result2.session), session: result2.session };
+  }
+  sessionPickerActionResult(content, confirmingStopSessionId) {
+    return {
+      type: "session-picker",
+      content,
+      sessions: Object.values(this.state.sessions ?? {}),
+      activeSessionId: this.state.activeSessionId,
+      confirmingStopSessionId
+    };
+  }
+  async handleResumePickerAction(action) {
+    const sessionId = action.sessionId ?? "";
+    const request = this.pendingResumePickers.get(sessionId);
+    const session = this.state.sessions?.[sessionId];
+    if (!request || !session || session.agent !== action.agent || session.paneId !== action.paneId) {
+      return { type: "error", content: "Resume Picker \u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u521B\u5EFA Session\u3002" };
+    }
+    if (action.action === "cancel") {
+      this.pendingResumePickers.delete(sessionId);
+      const stopped = await this.stopSession(sessionId);
+      return stopped.ok ? { type: "success", content: `\u5DF2\u53D6\u6D88\u521B\u5EFA ${sessionId}\u3002` } : { type: "error", content: remoteError(stopped) };
+    }
+    let picker = await this.readResumePicker(session);
+    if (!picker) {
+      this.pendingResumePickers.delete(sessionId);
+      return { type: "error", content: "\u539F\u751F Resume Picker \u5F53\u524D\u65E0\u6CD5\u5B89\u5168\u8BC6\u522B\uFF0C\u5DF2\u5141\u8BB8\u624B\u52A8\u9065\u63A7\u515C\u5E95\uFF1B\u8BF7\u53D1\u9001 /manual\u3002" };
+    }
+    if (action.action !== "refresh" && picker.fingerprint !== action.fingerprint) {
+      return { type: "resume-picker", content: "Picker \u5DF2\u53D8\u5316\uFF0C\u5DF2\u5237\u65B0\u4E3A\u6700\u65B0\u5185\u5BB9\u3002", session, picker };
+    }
+    if (action.action === "refresh") {
+      return { type: "resume-picker", content: "\u5DF2\u5237\u65B0 Resume Picker\u3002", session, picker };
+    }
+    if (action.action === "previous" || action.action === "next") {
+      await this.tmux.sendKey(session.paneId, action.action === "previous" ? "PPage" : "NPage");
+      picker = await this.waitForResumePicker(session, picker.fingerprint) ?? picker;
+      return { type: "resume-picker", content: "\u5DF2\u5207\u6362 Picker \u9875\u9762\u3002", session, picker };
+    }
+    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 owner = ownerSessionId ? this.state.sessions?.[ownerSessionId] : void 0;
+        if (owner) {
+          this.pendingStartupConflicts.set(sessionId, { request, ownerSessionId: owner.id });
+          return {
+            type: "startup-conflict",
+            content: "\u6240\u9009\u539F\u751F Session \u5DF2\u7531\u73B0\u6709 LCA Session \u8FDE\u63A5\u3002",
+            request,
+            owner
+          };
+        }
+      }
+      return larkStartupError(claimed, 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) };
+    return { type: "session-created", content: remoteStartSuccess(session), session };
+  }
+  async readResumePicker(session) {
+    const pane = await this.tmux.inspect(session.paneId);
+    if (!pane || pane.dead) return void 0;
+    const raw = await this.tmux.capture(session.paneId, 120).catch(() => "");
+    return parseResumePicker(raw, session.agent);
+  }
+  async handleResumePickerDeliveryFailure(candidate) {
+    const current = this.state.sessions?.[candidate.id];
+    if (!current || current.paneId !== candidate.paneId || !this.pendingResumePickers.has(candidate.id)) return;
+    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) {
+    const deadline = Date.now() + timeoutMs;
+    let latest;
+    while (Date.now() < deadline) {
+      latest = await this.readResumePicker(session);
+      if (latest && (!previousFingerprint || latest.fingerprint !== previousFingerprint)) return latest;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return latest;
+  }
   currentManualView() {
     const session = this.activeSession();
     if (!session || !this.screen || this.screen.state === "exited") return void 0;
@@ -2176,7 +3546,7 @@ ${escapeFence2(output).slice(-6800)}
 ${escapeFence2(output).slice(-6500)}
 \`\`\``);
     } catch (error) {
-      await this.gateway?.sendText(chatId, `\u624B\u52A8\u64CD\u4F5C\u5931\u8D25\uFF1A${errorMessage2(error)}`);
+      await this.gateway?.sendText(chatId, `\u624B\u52A8\u64CD\u4F5C\u5931\u8D25\uFF1A${errorMessage3(error)}`);
     }
   }
   async handleChoiceAction(action, session, event) {
@@ -2457,6 +3827,11 @@ ${escapeFence2(output).slice(-6500)}
     }
     const sessions = { ...this.state.sessions };
     delete sessions[sessionId];
+    this.pendingResumePickers.delete(sessionId);
+    this.pendingStartupConflicts.delete(sessionId);
+    for (const [pendingId, conflict] of this.pendingStartupConflicts) {
+      if (conflict.ownerSessionId === sessionId) this.pendingStartupConflicts.delete(pendingId);
+    }
     const wasActive = this.state.activeSessionId === sessionId;
     const activeSessionId = wasActive ? Object.keys(sessions)[0] : this.state.activeSessionId;
     this.state = {
@@ -2515,7 +3890,7 @@ ${escapeFence2(output).slice(-6500)}
   }
   async runScheduledPoll() {
     const operation = this.poll().catch(async (error) => {
-      if (!this.closing) await this.log(`poll failed: ${errorMessage2(error)}`);
+      if (!this.closing) await this.log(`poll failed: ${errorMessage3(error)}`);
     });
     this.pollInFlight = operation;
     try {
@@ -2549,6 +3924,7 @@ ${escapeFence2(output).slice(-6500)}
     await this.maybeNotifyCompletion();
     await this.flushPending();
     await this.reconcileSessions();
+    await this.refreshNativeAgentSessionClaims();
   }
   async notifyTransition() {
     const current = this.screen;
@@ -2569,13 +3945,13 @@ ${escapeFence2(output).slice(-6500)}
         await this.gateway.sendText(this.state.boundChatId, `${agentName}/tmux pane \u5DF2\u9000\u51FA\u3002`);
       }
     } catch (error) {
-      await this.log(`notification failed: ${errorMessage2(error)}`);
+      await this.log(`notification failed: ${errorMessage3(error)}`);
     }
   }
   async maybeNotifyUnresolved() {
     const screen = this.screen;
     const session = this.activeSession();
-    if (this.interactionNotificationsSuppressed > 0 || !screen || !session || !this.gateway || !this.state.boundChatId || screen.state !== "input" && screen.state !== "unknown" || safeStructuredInteraction(screen)) {
+    if (this.interactionNotificationsSuppressed > 0 || !screen || !session || !this.gateway || !this.state.boundChatId || this.pendingResumePickers?.has(session.id) || screen.state !== "input" && screen.state !== "unknown" || safeStructuredInteraction(screen)) {
       this.unresolvedCandidate = void 0;
       return;
     }
@@ -2591,16 +3967,30 @@ ${escapeFence2(output).slice(-6500)}
         this.state.boundChatId,
         this.manualView(session, screen, "active", "\u5F53\u524D\u7EC8\u7AEF\u4EA4\u4E92\u65E0\u6CD5\u5B89\u5168\u8BC6\u522B\uFF0C\u5DF2\u81EA\u52A8\u8FDB\u5165\u624B\u52A8\u9065\u63A7\u515C\u5E95\u3002")
       );
+      await this.log(
+        `manual fallback sent: session=${session.id} agent=${session.agent} pane=${session.paneId} state=${screen.state} fingerprint=${screen.fingerprint}`
+      );
     } catch (error) {
-      await this.log(`manual fallback card failed: ${errorMessage2(error)}`);
+      await this.log(`manual fallback card failed: ${errorMessage3(error)}`);
       await this.gateway.sendText(
         this.state.boundChatId,
         "\u5F53\u524D\u7EC8\u7AEF\u4EA4\u4E92\u65E0\u6CD5\u5B89\u5168\u8BC6\u522B\uFF0C\u4E14\u624B\u52A8\u9065\u63A7\u5361\u53D1\u9001\u5931\u8D25\u3002\u53EF\u4F7F\u7528 /tail 120\u3001/key\u3001/type \u6216 /submit \u5904\u7406\u3002"
-      ).catch((sendError) => this.log(`manual fallback text failed: ${errorMessage2(sendError)}`));
+      ).catch((sendError) => this.log(`manual fallback text failed: ${errorMessage3(sendError)}`));
     }
   }
   async handleTurnComplete(candidate) {
     if (!validTurnCompleteCandidate(candidate)) return { ok: false, error: "invalid turn-complete candidate" };
+    const completingSession = this.state.sessions?.[candidate.sessionId];
+    if (completingSession) {
+      const claimed = await this.handleAgentSessionStarted({
+        sessionId: candidate.sessionId,
+        agent: completingSession.agent,
+        agentSessionId: candidate.agentSessionId,
+        cwd: candidate.cwd,
+        source: "Stop"
+      });
+      if (!claimed.ok) return claimed;
+    }
     const eventKey = `${candidate.agentSessionId}:${candidate.eventId}`;
     if (this.completedEvents.has(eventKey)) return { ok: true };
     remember(this.completedEvents, eventKey, 256);
@@ -2610,6 +4000,142 @@ ${escapeFence2(output).slice(-6500)}
     this.pendingCompletionAt = Date.now();
     return { ok: true };
   }
+  async handleAgentSessionStarted(candidate) {
+    if (!validSessionStartCandidate(candidate)) return { ok: false, error: "invalid agent-session candidate" };
+    const session = this.state.sessions?.[candidate.sessionId];
+    if (session && session.agent !== candidate.agent) {
+      return { ok: false, error: "agent-session candidate does not match managed session" };
+    }
+    const owner = this.findAgentSessionOwner(candidate.agent, candidate.agentSessionId, candidate.sessionId);
+    if (owner) {
+      this.pendingAgentSessionClaims.set(candidate.sessionId, candidate);
+      await this.log(
+        `agent session conflict: session=${candidate.sessionId} agent=${candidate.agent} agentSession=${candidate.agentSessionId} owner=${owner.id}`
+      );
+      setTimeout(() => void this.rejectDuplicateAgentSession(candidate, owner), 100);
+      return fail(agentSessionInUse(candidate.sessionId, owner.id));
+    }
+    if (!session) {
+      this.pendingAgentSessionClaims.set(candidate.sessionId, candidate);
+      return { ok: true };
+    }
+    if (session.agentSessionId === candidate.agentSessionId) return { ok: true };
+    const updated = { ...session, agentSessionId: candidate.agentSessionId, updatedAt: Date.now() };
+    this.state = {
+      ...this.state,
+      sessions: { ...this.state.sessions, [session.id]: updated },
+      updatedAt: Date.now()
+    };
+    this.pendingAgentSessionClaims.delete(session.id);
+    await this.store.saveState(this.state);
+    await this.tmux.writeMetadata(session.sessionName, {
+      managed: true,
+      sessionId: session.id,
+      agent: session.agent,
+      cwd: session.cwd,
+      agentVersion: session.agentVersion,
+      agentSessionId: candidate.agentSessionId
+    }).catch((error) => this.log(`failed to persist agent session claim for ${session.id}: ${errorMessage3(error)}`));
+    await this.log(
+      `agent session claimed: session=${session.id} agent=${session.agent} agentSession=${candidate.agentSessionId}`
+    );
+    return { ok: true };
+  }
+  async refreshNativeAgentSessionClaims() {
+    for (const session of Object.values(this.state.sessions ?? {})) {
+      if (session.agentSessionId) continue;
+      const pane = await this.tmux.inspect(session.paneId);
+      if (!pane || pane.dead) continue;
+      const agentSessionId = await resolveNativeAgentSessionId(session.agent, pane.pid).catch((error) => {
+        void this.log(`failed to resolve native agent session for ${session.id}: ${errorMessage3(error)}`);
+        return void 0;
+      });
+      if (!agentSessionId) continue;
+      await this.handleAgentSessionStarted({
+        sessionId: session.id,
+        agent: session.agent,
+        agentSessionId,
+        cwd: session.cwd,
+        source: "runtime-discovery"
+      });
+    }
+  }
+  async waitForInitialAgentSessionClaim(sessionId, panePid) {
+    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 (agentSessionId) {
+        return this.handleAgentSessionStarted({
+          sessionId,
+          agent: session2.agent,
+          agentSessionId,
+          cwd: session2.cwd,
+          source: "startup-discovery"
+        });
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    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);
+    if (!pane || pane.dead) return fail(await this.startupExitedError(session, pane));
+    if (session.agentSessionId || this.pendingAgentSessionClaims.has(sessionId)) return { ok: true };
+    return fail(new AppError(
+      "AGENT_IDENTITY_TIMEOUT",
+      `unable to identify resumed native session: ${sessionId}`,
+      { sessionId, agent: session.agent }
+    ));
+  }
+  async startupExitedError(session, pane) {
+    const terminalTail = await this.tmux.capture(session.paneId, 40).then((output) => tailScreen(output, 40).slice(-3e3)).catch(() => "");
+    return new AppError(
+      "AGENT_EXITED_DURING_STARTUP",
+      `agent exited during startup: ${session.id}`,
+      {
+        sessionId: session.id,
+        agent: session.agent,
+        terminalExcerpt: startupTerminalExcerpt(terminalTail),
+        exitStatus: pane?.exitStatus
+      }
+    );
+  }
+  async waitForStartupStability(session, durationMs) {
+    const deadline = Date.now() + durationMs;
+    while (Date.now() < deadline) {
+      const pane = await this.tmux.inspect(session.paneId);
+      if (!pane || pane.dead) return fail(await this.startupExitedError(session, pane));
+      await new Promise((resolve) => setTimeout(resolve, 80));
+    }
+    return { ok: true };
+  }
+  findAgentSessionOwner(agent, agentSessionId, excludeSessionId) {
+    const persisted = Object.values(this.state.sessions ?? {}).find((candidate) => candidate.id !== excludeSessionId && candidate.agent === agent && candidate.agentSessionId === agentSessionId);
+    if (persisted) return persisted;
+    const pending = [...this.pendingAgentSessionClaims.values()].find((candidate) => candidate.sessionId !== excludeSessionId && candidate.agent === agent && candidate.agentSessionId === agentSessionId);
+    return pending ? { id: pending.sessionId } : void 0;
+  }
+  async rejectDuplicateAgentSession(candidate, owner) {
+    const duplicate = this.state.sessions?.[candidate.sessionId];
+    if (duplicate) await this.stopSession(duplicate.id).catch((error) => this.log(
+      `failed to stop duplicate agent session ${duplicate.id}: ${errorMessage3(error)}`
+    ));
+    else {
+      const sessionName = `${this.sessionName}-${candidate.sessionId}`;
+      if (await this.tmux.hasSession(sessionName)) await this.tmux.killSession(sessionName).catch(() => void 0);
+    }
+    this.pendingAgentSessionClaims.delete(candidate.sessionId);
+    if (this.state.boundChatId) {
+      await this.gateway?.sendText(
+        this.state.boundChatId,
+        `${candidate.agent} \u539F\u751F session \u5DF2\u7531 LCA session\u300C${owner.id}\u300D\u8FDE\u63A5\uFF1B\u5DF2\u505C\u6B62\u91CD\u590D\u521B\u5EFA\u7684\u300C${candidate.sessionId}\u300D\u3002\u8BF7\u7528 /sessions \u8FDE\u63A5\u300C${owner.id}\u300D\u3002`
+      ).catch((error) => this.log(`agent session conflict notification failed: ${errorMessage3(error)}`));
+    }
+  }
   updateScreen(next) {
     if (this.screen?.fingerprint !== next.fingerprint || this.screen.state !== next.state) {
       this.outputStableSince = Date.now();
@@ -2661,31 +4187,29 @@ ${output}`
   activeSession() {
     return this.state.activeSessionId ? this.state.sessions?.[this.state.activeSessionId] : void 0;
   }
-  async reconcileSessions() {
-    const sessions = Object.values(this.state.sessions ?? {});
-    const inspections = await Promise.all(sessions.map(async (session) => ({
-      session,
-      pane: await this.tmux.inspect(session.paneId)
-    })));
-    const liveSessions = inspections.filter(({ pane }) => pane && !pane.dead).map(({ session }) => session);
-    const liveById = Object.fromEntries(liveSessions.map((session) => [session.id, session]));
-    const activeSessionId = this.state.activeSessionId && liveById[this.state.activeSessionId] ? this.state.activeSessionId : liveSessions[0]?.id;
-    const sessionsChanged = liveSessions.length !== sessions.length;
-    const activeChanged = activeSessionId !== this.state.activeSessionId;
-    if (!sessionsChanged && !activeChanged) return liveSessions;
-    const removedActive = this.state.activeSessionId ? this.state.sessions?.[this.state.activeSessionId] : void 0;
-    if (activeChanged && removedActive && !liveById[removedActive.id] && this.previousScreen?.state !== "exited" && this.state.boundChatId) {
+  async reconcileSessions(discover = false) {
+    const previousActive = this.state.activeSessionId;
+    const result2 = await this.reconciler.reconcile(this.state, discover);
+    if (!result2.changed) return result2.liveSessions;
+    const activeChanged = result2.state.activeSessionId !== previousActive;
+    if (result2.removedActive) {
+      await this.log(
+        `session removed: session=${result2.removedActive.id} agent=${result2.removedActive.agent} pane=${result2.removedActive.paneId} wasActive=true nextActive=${result2.state.activeSessionId ?? "-"}`
+      );
+    }
+    if (activeChanged && result2.removedActive && this.previousScreen?.state !== "exited" && this.state.boundChatId) {
       await this.gateway?.sendText(
         this.state.boundChatId,
-        `${getAgentAdapter(removedActive.agent).displayName}/tmux pane \u5DF2\u9000\u51FA\u3002`
-      ).catch((error) => this.log(`exit notification failed: ${errorMessage2(error)}`));
+        `${getAgentAdapter(result2.removedActive.agent).displayName}/tmux pane \u5DF2\u9000\u51FA\u3002`
+      ).catch((error) => this.log(`exit notification failed: ${errorMessage3(error)}`));
+    }
+    this.state = result2.state;
+    for (const sessionId of this.pendingResumePickers.keys()) {
+      if (!this.state.sessions?.[sessionId]) this.pendingResumePickers.delete(sessionId);
+    }
+    for (const [sessionId, conflict] of this.pendingStartupConflicts) {
+      if (!this.state.sessions?.[conflict.ownerSessionId]) this.pendingStartupConflicts.delete(sessionId);
     }
-    this.state = {
-      ...this.state,
-      sessions: liveById,
-      activeSessionId,
-      updatedAt: Date.now()
-    };
     if (activeChanged) {
       this.screen = void 0;
       this.previousScreen = void 0;
@@ -2697,11 +4221,13 @@ ${output}`
       this.unresolvedNotified.clear();
     }
     await this.store.saveState(this.state);
-    return liveSessions;
+    return result2.liveSessions;
   }
   async useSession(sessionId) {
     const session = this.state.sessions?.[sessionId];
-    if (!session || !await this.tmux.inspect(session.paneId)) return { ok: false, error: `unknown or stopped session: ${sessionId}` };
+    if (!session) return fail(new AppError("SESSION_NOT_FOUND", `unknown session: ${sessionId}`, { sessionId }));
+    const pane = await this.tmux.inspect(session.paneId);
+    if (!pane || pane.dead) return fail(await this.startupExitedError(session, pane));
     this.state = { ...this.state, activeSessionId: sessionId, updatedAt: Date.now() };
     this.screen = void 0;
     this.previousScreen = void 0;
@@ -2713,8 +4239,44 @@ ${output}`
     this.unresolvedNotified.clear();
     await this.store.saveState(this.state);
     await this.poll();
+    await this.log(`session activated: session=${session.id} agent=${session.agent} pane=${session.paneId}`);
     return { ok: true, value: session };
   }
+  async startRemoteSession(request) {
+    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);
+    if (!started.ok) {
+      await this.log(`remote session create failed: session=${request.sessionId} code=${started.errorCode ?? "UNKNOWN"}`);
+      if (started.errorCode === "AGENT_SESSION_IN_USE") {
+        const ownerSessionId = typeof started.errorContext?.ownerSessionId === "string" ? started.errorContext.ownerSessionId : void 0;
+        const owner = ownerSessionId ? this.state.sessions?.[ownerSessionId] : void 0;
+        if (owner) {
+          this.pendingStartupConflicts.set(request.sessionId, { request, ownerSessionId: owner.id });
+          return { ok: true, state: "conflict", request, owner };
+        }
+      }
+      return { ok: false, error: started };
+    }
+    const selected = await this.useSession(request.sessionId);
+    if (!selected.ok) {
+      await this.log(`remote session activation failed: session=${request.sessionId} code=${selected.errorCode ?? "UNKNOWN"}`);
+      return { ok: false, error: selected };
+    }
+    const session = selected.value;
+    if (request.resume?.mode === "picker") {
+      const picker = await this.waitForResumePicker(session);
+      if (picker) {
+        this.pendingResumePickers.set(session.id, request);
+        return { ok: true, state: "picker", session, picker };
+      }
+      await this.tmux.preserveOnExit(session.sessionName, false).catch((error) => this.log(
+        `failed to disable remain-on-exit after resume picker fallback: session=${session.id} error=${errorMessage3(error)}`
+      ));
+    }
+    return { ok: true, state: "ready", session };
+  }
   async log(message) {
     await appendFile(this.paths.logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
 `, { mode: 384 });
@@ -2723,7 +4285,14 @@ ${output}`
 function fail(error) {
   return { ok: false, ...serializeAppError(error) };
 }
-function errorMessage2(error) {
+function agentSessionInUse(sessionId, ownerSessionId) {
+  return new AppError(
+    "AGENT_SESSION_IN_USE",
+    `agent session is already managed by ${ownerSessionId}`,
+    { sessionId, ownerSessionId }
+  );
+}
+function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function isAlreadyExists(error) {
@@ -2737,9 +4306,6 @@ function processIsAlive(pid) {
     return error instanceof Error && "code" in error && error.code === "EPERM";
   }
 }
-function validSessionId(value) {
-  return /^[a-zA-Z0-9_-]{1,40}$/.test(value);
-}
 function remember(values, value, limit) {
   values.add(value);
   while (values.size > limit) {
@@ -2748,6 +4314,76 @@ function remember(values, value, limit) {
     values.delete(oldest);
   }
 }
+function startRequestFromForm(values) {
+  const sessionId = formString(values[SESSION_CREATE_NAME_FIELD]);
+  const agentValue = formString(values[SESSION_CREATE_AGENT_FIELD]);
+  const cwd = formString(values[SESSION_CREATE_CWD_FIELD]);
+  const resumeMode = formString(values[SESSION_CREATE_RESUME_FIELD]) || "new";
+  if (!sessionId) return { ok: false, error: "\u8BF7\u586B\u5199 Session \u540D\u79F0\u3002" };
+  const agent = normalizeAgentId(agentValue);
+  if (!agent) return { ok: false, error: "\u8BF7\u9009\u62E9\u6709\u6548\u7684 Agent\uFF1Acodex\u3001traex \u6216 claude\u3002" };
+  if (!cwd) return { ok: false, error: "\u8BF7\u586B\u5199\u7EDD\u5BF9\u5DE5\u4F5C\u76EE\u5F55\u3002" };
+  let resume;
+  if (resumeMode === "last") {
+    return { ok: false, error: "\u98DE\u4E66\u5DF2\u4E0D\u518D\u652F\u6301\u201C\u6062\u590D\u4E0A\u6B21\u4F1A\u8BDD\u201D\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u8868\u5355\u5E76\u4F7F\u7528 Resume Picker\u3002" };
+  }
+  if (resumeMode === "picker") resume = { mode: "picker" };
+  else if (resumeMode !== "new") {
+    return { ok: false, error: "\u65E0\u6CD5\u8BC6\u522B\u542F\u52A8\u65B9\u5F0F\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u65B0\u5EFA Session \u8868\u5355\u3002" };
+  }
+  return { ok: true, value: { sessionId, agent, cwd, resume } };
+}
+function formString(value) {
+  if (typeof value === "string") return value.trim();
+  if (value && typeof value === "object" && typeof value.value === "string") {
+    return value.value.trim();
+  }
+  return "";
+}
+function remoteStartSuccess(session) {
+  return `\u5DF2\u542F\u52A8\u5E76\u8FDE\u63A5 ${getAgentAdapter(session.agent).displayName} session\u300C${session.id}\u300D\u3002`;
+}
+function larkStartupError(result2, request) {
+  const failure = sessionStartupFailure(result2, request);
+  return failure ? { type: "session-start-failed", content: `${failure.agent} \u542F\u52A8\u5931\u8D25\u3002`, failure } : { type: "error", content: remoteError(result2) };
+}
+function remoteError(result2) {
+  if (result2.ok) return "\u64CD\u4F5C\u5DF2\u5B8C\u6210\u3002";
+  const context = result2.errorContext ?? {};
+  const sessionId = typeof context.sessionId === "string" ? context.sessionId : "\u8BE5\u540D\u79F0";
+  switch (result2.errorCode) {
+    case "SESSION_EXISTS":
+      return `\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 "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`;
+    }
+    case "AGENT_EXITED_DURING_STARTUP": {
+      const agent = typeof context.agent === "string" ? context.agent : "Agent";
+      const exitStatus = typeof context.exitStatus === "number" ? `\uFF08\u9000\u51FA\u7801 ${context.exitStatus}\uFF09` : "";
+      const excerpt = typeof context.terminalExcerpt === "string" ? context.terminalExcerpt : "Agent \u672A\u8F93\u51FA\u53EF\u7528\u9519\u8BEF\u4FE1\u606F\u3002";
+      return `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\uFF1A${agent} \u542F\u52A8\u540E\u7ACB\u5373\u9000\u51FA${exitStatus}\u3002
+
+\u539F\u59CB\u9519\u8BEF\uFF1A
+${excerpt}`;
+    }
+    case "AGENT_IDENTITY_TIMEOUT":
+      return `\u65E0\u6CD5\u6062\u590D session\u300C${sessionId}\u300D\uFF1AAgent \u4ECD\u5728\u8FD0\u884C\uFF0C\u4F46\u672A\u80FD\u786E\u8BA4\u539F\u751F session ID\u3002\u8BF7\u91CD\u8BD5\u6216\u542F\u52A8\u65B0\u4F1A\u8BDD\u3002`;
+    case "INVALID_SESSION_NAME":
+      return "Session \u540D\u79F0\u65E0\u6548\uFF1A\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF\uFF0C\u957F\u5EA6\u4E3A 1\u201340 \u4E2A\u5B57\u7B26\u3002";
+    case "INVALID_CWD":
+      return `\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u53EF\u7528\uFF1A${typeof context.cwd === "string" ? context.cwd : "\u8BF7\u586B\u5199\u672C\u673A\u5B58\u5728\u7684\u7EDD\u5BF9\u8DEF\u5F84"}\u3002`;
+    case "BINARY_NOT_FOUND":
+      return `\u627E\u4E0D\u5230 Agent \u547D\u4EE4\uFF1A${typeof context.binary === "string" ? context.binary : "\u8BF7\u68C0\u67E5\u5B89\u88C5\u4E0E PATH"}\u3002`;
+    case "INVALID_OPTIONS":
+    case "INVALID_RESUME":
+      return typeof context.reason === "string" ? context.reason : "\u542F\u52A8\u53C2\u6570\u65E0\u6548\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u8BD5\u3002";
+    case "START_FAILED":
+      return `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\u3002\u8BF7\u68C0\u67E5\u5DE5\u4F5C\u76EE\u5F55\u3001Agent \u5B89\u88C5\uFF0C\u6216\u5728\u672C\u673A\u8FD0\u884C lca logs \u67E5\u770B\u65E5\u5FD7\u3002`;
+    default:
+      return "\u64CD\u4F5C\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u53EF\u5728\u672C\u673A\u8FD0\u884C lca status \u548C lca logs \u68C0\u67E5\u3002";
+  }
+}
 function escapeFence2(value) {
   return value.replace(/```/g, "``\\`");
 }
@@ -2794,27 +4430,27 @@ function manualTimestamp() {
 
 // src/core/paths.ts
 import { homedir as homedir2 } from "os";
-import { join } from "path";
+import { join as join2 } from "path";
 function resolveAppPaths(root = process.env.LARK_CODING_ASSISTANT_HOME) {
-  const base = root || join(homedir2(), ".lark-coding-assistant");
+  const base = root || join2(homedir2(), ".lark-coding-assistant");
   return {
     root: base,
-    config: join(base, "config.json"),
-    secrets: join(base, "secrets.json"),
-    state: join(base, "state.json"),
-    logsDir: join(base, "logs"),
-    logFile: join(base, "logs", "assistant.log"),
-    runtimeDir: join(base, "runtime"),
-    socket: join(base, "runtime", "daemon.sock"),
-    pid: join(base, "runtime", "daemon.pid")
+    config: join2(base, "config.json"),
+    secrets: join2(base, "secrets.json"),
+    state: join2(base, "state.json"),
+    logsDir: join2(base, "logs"),
+    logFile: join2(base, "logs", "assistant.log"),
+    runtimeDir: join2(base, "runtime"),
+    socket: join2(base, "runtime", "daemon.sock"),
+    pid: join2(base, "runtime", "daemon.pid")
   };
 }
 
 // src/daemon-entry.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 var paths = resolveAppPaths();
 var packageInfo = JSON.parse(
-  await readFile3(new URL("../package.json", import.meta.url), "utf8")
+  await readFile4(new URL("../package.json", import.meta.url), "utf8")
 );
 var daemon = new AssistantDaemon(
   new AppStore(paths),