lark-coding-assistant 0.2.2 → 0.2.4

package/dist/daemon-entry.js

@@ -5,13 +5,14 @@ import { createServer } from "net";
 // src/platform/process.ts
 import { execFile, spawn } from "child_process";
 function runFile(file, args, options = {}) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     execFile(
       file,
       [...args],
       {
         cwd: options.cwd,
         timeout: options.timeoutMs ?? 1e4,
+        signal: options.signal,
         encoding: "utf8",
         maxBuffer: 4 * 1024 * 1024
       },
@@ -20,13 +21,13 @@ function runFile(file, args, options = {}) {
           reject(Object.assign(error, { stdout, stderr }));
           return;
         }
-        resolve({ stdout, stderr });
+        resolve2({ stdout, stderr });
       }
     );
   });
 }
 function runFileWithInput(file, args, input) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const child = spawn(file, [...args], { stdio: ["pipe", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -36,7 +37,7 @@ function runFileWithInput(file, args, input) {
     child.stderr.on("data", (chunk) => stderr += chunk);
     child.once("error", reject);
     child.once("exit", (code, signal) => {
-      if (code === 0) resolve({ stdout, stderr });
+      if (code === 0) resolve2({ stdout, stderr });
       else reject(new Error(`${file} exited with ${code ?? signal}: ${stderr.trim()}`));
     });
     child.stdin.end(input, "utf8");
@@ -100,6 +101,88 @@ function normalizeAgentId(value) {
   return AGENT_IDS.includes(value) ? value : void 0;
 }
 
+// src/workspace/path.ts
+import { constants } from "fs";
+import { access, stat } from "fs/promises";
+import { homedir } from "os";
+import { isAbsolute, normalize, resolve } from "path";
+
+// src/core/errors.ts
+var AppError = class extends Error {
+  code;
+  context;
+  constructor(code, message2, context = {}, options = {}) {
+    super(message2, options);
+    this.name = "AppError";
+    this.code = code;
+    this.context = context;
+  }
+};
+function isAppError(error) {
+  return error instanceof AppError;
+}
+function asAppError(error, code = "UNKNOWN", context = {}) {
+  if (isAppError(error)) {
+    if (Object.keys(context).length === 0) return error;
+    return new AppError(error.code, error.message, { ...context, ...error.context }, { cause: error });
+  }
+  return new AppError(code, errorMessage(error), context, { cause: error });
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function serializeAppError(error) {
+  if (!isAppError(error)) return { error: errorMessage(error) };
+  const errorContext = Object.fromEntries(
+    Object.entries(error.context).filter(([, value]) => value !== void 0)
+  );
+  return {
+    error: error.message,
+    errorCode: error.code,
+    ...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/workspace/path.ts
+function normalizeWorkspacePath(input, home = homedir()) {
+  const value = input.trim();
+  if (!value) throw invalidCwd(input, "\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u80FD\u4E3A\u7A7A");
+  let expanded = value;
+  if (value === "~") expanded = home;
+  else if (value.startsWith("~/")) expanded = resolve(home, value.slice(2));
+  else if (value.startsWith("~")) throw invalidCwd(input, "\u4E0D\u652F\u6301 ~other-user\uFF0C\u8BF7\u4F7F\u7528 ~ \u6216 ~/\u76EE\u5F55");
+  if (!isAbsolute(expanded)) throw invalidCwd(input, "\u5DE5\u4F5C\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u6216\u4F7F\u7528 ~/\u76EE\u5F55");
+  return normalize(expanded);
+}
+async function validateWorkspaceDirectory(input, home = homedir()) {
+  const cwd = normalizeWorkspacePath(input, home);
+  let info;
+  try {
+    info = await stat(cwd);
+  } catch (error) {
+    const reason = systemErrorCode(error) === "EACCES" ? `\u65E0\u6743\u8BBF\u95EE\u5DE5\u4F5C\u76EE\u5F55\uFF1A${cwd}` : `\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u7528\uFF1A${cwd}`;
+    throw invalidCwd(cwd, reason, error);
+  }
+  if (!info.isDirectory()) throw invalidCwd(cwd, `\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u662F\u6587\u4EF6\u5939\uFF1A${cwd}`);
+  try {
+    await access(cwd, constants.R_OK | constants.X_OK);
+  } catch (error) {
+    throw invalidCwd(cwd, `\u65E0\u6743\u8FDB\u5165\u5DE5\u4F5C\u76EE\u5F55\uFF1A${cwd}`, error);
+  }
+  return cwd;
+}
+function normalizeWorkspaceRoots(values, home = homedir()) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const value of values) unique.add(normalizeWorkspacePath(value, home));
+  return [...unique];
+}
+function invalidCwd(cwd, reason, cause) {
+  return new AppError("INVALID_CWD", reason, { cwd, reason }, cause === void 0 ? {} : { cause });
+}
+
 // src/core/store.ts
 var AppStore = class {
   constructor(paths2) {
@@ -129,11 +212,15 @@ var AppStore = class {
         traex: binaries.traex ?? binaries["trae-cli"] ?? "trae-cli",
         claude: binaries.claude ?? binaries["claude-code"] ?? "claude"
       },
-      pollIntervalMs: config.pollIntervalMs
+      pollIntervalMs: config.pollIntervalMs,
+      workspaceRoots: normalizeWorkspaceRoots(config.workspaceRoots ?? [])
     };
   }
   saveConfig(config) {
-    return writeJsonAtomic(this.paths.config, config);
+    return writeJsonAtomic(this.paths.config, {
+      ...config,
+      workspaceRoots: normalizeWorkspaceRoots(config.workspaceRoots)
+    });
   }
   loadSecrets() {
     return readJson(this.paths.secrets);
@@ -148,12 +235,33 @@ var AppStore = class {
       const agent = normalizeAgentId(session.agent);
       return agent ? [[id, { ...session, agent }]] : [];
     }));
-    return { ...state, sessions };
+    const recentWorkspaces = await normalizeRecentWorkspaces(state.recentWorkspaces ?? []);
+    return { ...state, sessions, recentWorkspaces };
   }
   saveState(state) {
     return writeJsonAtomic(this.paths.state, state);
   }
 };
+async function normalizeRecentWorkspaces(values) {
+  const unique = /* @__PURE__ */ new Set();
+  const result2 = [];
+  const ordered = [...values].sort((left, right) => right.lastUsedAt - left.lastUsedAt);
+  for (const value of ordered) {
+    if (result2.length >= 30) break;
+    if (!Number.isFinite(value.lastUsedAt)) continue;
+    let cwd;
+    try {
+      cwd = normalizeWorkspacePath(value.cwd);
+      await validateWorkspaceDirectory(cwd);
+    } catch {
+      continue;
+    }
+    if (unique.has(cwd)) continue;
+    unique.add(cwd);
+    result2.push({ cwd, lastUsedAt: value.lastUsedAt });
+  }
+  return result2;
+}
 function createBindCode() {
   return randomBytes(16).toString("base64url");
 }
@@ -170,41 +278,7 @@ function verifyBindCode(code, encoded) {
   return actual.length === expected.length && timingSafeEqual(actual, expected);
 }
 
-// src/core/errors.ts
-var AppError = class extends Error {
-  code;
-  context;
-  constructor(code, message, context = {}, options = {}) {
-    super(message, options);
-    this.name = "AppError";
-    this.code = code;
-    this.context = context;
-  }
-};
-function isAppError(error) {
-  return error instanceof AppError;
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function serializeAppError(error) {
-  if (!isAppError(error)) return { error: errorMessage(error) };
-  const errorContext = Object.fromEntries(
-    Object.entries(error.context).filter(([, value]) => value !== void 0)
-  );
-  return {
-    error: error.message,
-    errorCode: error.code,
-    ...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(
@@ -213,21 +287,13 @@ async function validateStartSessionRequest(request) {
       { 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 });
-  }
+  const cwd = await validateWorkspaceDirectory(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;
+  return { ...request, cwd };
 }
 function validSessionId(value) {
   return /^[a-zA-Z0-9_-]{1,40}$/.test(value);
@@ -235,16 +301,138 @@ function validSessionId(value) {
 
 // src/session/startup-failure.ts
 function sessionStartupFailure(result2, fallback) {
-  if (result2.ok || result2.errorCode !== "AGENT_EXITED_DURING_STARTUP") return void 0;
+  if (result2.ok || result2.errorCode !== "AGENT_EXITED_DURING_STARTUP" && result2.errorCode !== "SESSION_START_TIMEOUT") return void 0;
   const context = result2.errorContext ?? {};
   return {
     sessionId: typeof context.sessionId === "string" ? context.sessionId : fallback.sessionId,
     agent: fallback.agent,
+    reason: result2.errorCode === "SESSION_START_TIMEOUT" ? "timeout" : "exited",
+    ...typeof context.cwd === "string" ? { cwd: context.cwd } : {},
+    ...typeof context.stage === "string" ? { stage: context.stage } : {},
+    ...typeof context.elapsedMs === "number" ? { elapsedMs: context.elapsedMs } : {},
     ...typeof context.exitStatus === "number" ? { exitStatus: context.exitStatus } : {},
     terminalExcerpt: typeof context.terminalExcerpt === "string" && context.terminalExcerpt.trim() ? context.terminalExcerpt : "Agent \u672A\u8F93\u51FA\u53EF\u7528\u9519\u8BEF\u4FE1\u606F\u3002"
   };
 }
 
+// src/session/start-coordinator.ts
+import { randomUUID } from "crypto";
+var SessionStartCoordinator = class {
+  constructor(timeoutMs = 3e4, log = async () => void 0) {
+    this.timeoutMs = timeoutMs;
+    this.log = log;
+  }
+  timeoutMs;
+  log;
+  active = /* @__PURE__ */ new Map();
+  async run(descriptor, execute, cleanup) {
+    const existing = this.active.get(descriptor.sessionId);
+    if (existing) {
+      return {
+        ok: false,
+        error: new AppError("SESSION_STARTING", `session is already starting: ${descriptor.sessionId}`, {
+          sessionId: descriptor.sessionId,
+          agent: descriptor.agent,
+          cwd: descriptor.cwd,
+          startId: existing.startId,
+          elapsedMs: Date.now() - existing.startedAt
+        })
+      };
+    }
+    const startId = randomUUID();
+    const startedAt = Date.now();
+    const deadline = startedAt + this.timeoutMs;
+    const controller = new AbortController();
+    let currentStage = "initializing";
+    const fields = logFields({ ...descriptor, startId });
+    const context = {
+      ...descriptor,
+      startId,
+      startedAt,
+      deadline,
+      signal: controller.signal,
+      remainingMs: () => Math.max(1, deadline - Date.now()),
+      stage: async (name, operation2) => {
+        if (controller.signal.aborted || Date.now() >= deadline) {
+          throw timeoutError(descriptor, startId, name, startedAt, this.timeoutMs);
+        }
+        currentStage = name;
+        const stageStartedAt = Date.now();
+        await this.record(`session start stage requested: ${fields} stage=${name}`);
+        try {
+          const value = await operation2();
+          await this.record(`session start stage succeeded: ${fields} stage=${name} elapsedMs=${Date.now() - stageStartedAt}`);
+          return value;
+        } catch (error) {
+          const normalized = controller.signal.aborted || Date.now() >= deadline ? timeoutError(descriptor, startId, name, startedAt, this.timeoutMs) : asAppError(error, "START_FAILED", startErrorContext(descriptor, startId, name, startedAt));
+          await this.record(`session start stage failed: ${fields} stage=${name} code=${normalized.code} elapsedMs=${Date.now() - stageStartedAt}`);
+          throw normalized;
+        } finally {
+          if (currentStage === name) currentStage = "finalizing";
+        }
+      }
+    };
+    this.active.set(descriptor.sessionId, { startId, startedAt });
+    await this.record(`session start requested: ${fields}`);
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        const error = timeoutError(descriptor, startId, currentStage, startedAt, this.timeoutMs);
+        controller.abort(error);
+        reject(error);
+      }, this.timeoutMs);
+    });
+    const operation = execute(context);
+    try {
+      const value = await Promise.race([operation, timeout]);
+      await this.record(`session start succeeded: ${fields} elapsedMs=${Date.now() - startedAt}`);
+      return { ok: true, value };
+    } catch (error) {
+      const normalized = controller.signal.aborted || Date.now() >= deadline ? timeoutError(descriptor, startId, errorStage(error), startedAt, this.timeoutMs) : asAppError(error, "START_FAILED", startErrorContext(descriptor, startId, errorStage(error), startedAt));
+      if (!controller.signal.aborted) controller.abort(normalized);
+      await operation.catch(() => void 0);
+      await cleanup(context, normalized).catch(async (cleanupError) => {
+        await this.record(`session start cleanup failed: ${fields} code=${normalized.code} detail=${message(cleanupError)}`);
+      });
+      await this.record(`${normalized.code === "SESSION_START_TIMEOUT" ? "session start timed out" : "session start failed"}: ${fields} code=${normalized.code} stage=${String(normalized.context.stage ?? "unknown")} elapsedMs=${Date.now() - startedAt}`);
+      return { ok: false, error: normalized };
+    } finally {
+      if (timer) clearTimeout(timer);
+      this.active.delete(descriptor.sessionId);
+    }
+  }
+  async record(message2) {
+    await this.log(message2).catch(() => void 0);
+  }
+};
+function timeoutError(descriptor, startId, stage, startedAt, timeoutMs) {
+  return new AppError("SESSION_START_TIMEOUT", `session start exceeded ${timeoutMs} ms: ${descriptor.sessionId}`, {
+    ...startErrorContext(descriptor, startId, stage, startedAt),
+    timeoutMs
+  });
+}
+function startErrorContext(descriptor, startId, stage, startedAt) {
+  return {
+    sessionId: descriptor.sessionId,
+    agent: descriptor.agent,
+    cwd: descriptor.cwd,
+    resume: descriptor.resume?.mode ?? "new",
+    source: descriptor.source,
+    startId,
+    stage,
+    elapsedMs: Date.now() - startedAt
+  };
+}
+function errorStage(error) {
+  return error instanceof AppError && typeof error.context.stage === "string" ? error.context.stage : "unknown";
+}
+function logFields(descriptor) {
+  return `startId=${descriptor.startId} source=${descriptor.source} session=${descriptor.sessionId} agent=${descriptor.agent} cwd=${JSON.stringify(descriptor.cwd)} resume=${descriptor.resume?.mode ?? "new"}`;
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/session/reconciler.ts
 var SessionReconciler = class {
   constructor(tmux, sessionPrefix = "lark-coding-assistant", missingThreshold = 3, log = async () => void 0, resolveAgentVersion = async () => "unknown") {
@@ -260,11 +448,12 @@ var SessionReconciler = class {
   log;
   resolveAgentVersion;
   misses = /* @__PURE__ */ new Map();
-  async reconcile(input, discover = false) {
+  async reconcile(input, discover = false, signal) {
     const sessions = { ...input.sessions };
     let changed = false;
     for (const [id, session] of Object.entries(sessions)) {
-      const result2 = await this.confirm(session);
+      if (signal?.aborted) throw signal.reason;
+      const result2 = await this.confirm(session, signal);
       if (result2.status === "unavailable") {
         await this.log(`tmux inspection unavailable for ${id}: ${errorMessage2(result2.error)}`);
         continue;
@@ -277,6 +466,15 @@ var SessionReconciler = class {
         }
         continue;
       }
+      if (result2.status === "dead") {
+        await this.tmux.killSession(result2.pane.sessionName, signal).catch((error) => this.log(
+          `failed to clean dead tmux session ${result2.pane.sessionName}: ${errorMessage2(error)}`
+        ));
+        delete sessions[id];
+        this.misses.delete(id);
+        changed = true;
+        continue;
+      }
       const misses = (this.misses.get(id) ?? 0) + 1;
       this.misses.set(id, misses);
       if (misses < this.missingThreshold) continue;
@@ -285,7 +483,7 @@ var SessionReconciler = class {
       changed = true;
     }
     if (discover) {
-      changed = await this.discover(sessions) || changed;
+      changed = await this.discover(sessions, signal) || changed;
     }
     const activeSessionId = input.activeSessionId && sessions[input.activeSessionId] ? input.activeSessionId : Object.keys(sessions)[0];
     if (activeSessionId !== input.activeSessionId) changed = true;
@@ -293,45 +491,55 @@ var SessionReconciler = class {
     const state = changed ? { ...input, sessions, activeSessionId, updatedAt: Date.now() } : input;
     return { state, liveSessions: Object.values(sessions), removedActive, changed };
   }
-  async confirm(session) {
-    const direct = await this.tmux.inspectStatus(session.paneId);
+  async confirm(session, signal) {
+    const direct = await this.tmux.inspectStatus(session.paneId, signal);
     if (direct.status === "live" || direct.status === "unavailable") return direct;
-    const byName = await this.tmux.inspectSession(session.sessionName);
+    const byName = await this.tmux.inspectSession(session.sessionName, signal);
     if (byName.status === "live" || byName.status === "unavailable") return byName;
     return byName.status === "dead" ? byName : direct;
   }
-  async discover(sessions) {
+  async discover(sessions, signal) {
     let panes;
     try {
-      panes = await this.tmux.listSessions(`${this.sessionPrefix}-`);
+      panes = await this.tmux.listSessions(`${this.sessionPrefix}-`, signal);
     } catch (error) {
       await this.log(`tmux session discovery unavailable: ${errorMessage2(error)}`);
       return false;
     }
     let changed = false;
     const seen = /* @__PURE__ */ new Set();
+    const liveSessionNames = new Set(panes.filter((pane) => !pane.dead).map((pane) => pane.sessionName));
     for (const pane of panes) {
-      if (seen.has(pane.sessionName) || pane.dead) continue;
+      if (signal?.aborted) throw signal.reason;
+      if (seen.has(pane.sessionName)) continue;
       seen.add(pane.sessionName);
+      if (pane.dead) {
+        if (!liveSessionNames.has(pane.sessionName)) {
+          await this.tmux.killSession(pane.sessionName, signal).catch((error) => this.log(
+            `failed to clean orphaned dead tmux session ${pane.sessionName}: ${errorMessage2(error)}`
+          ));
+        }
+        continue;
+      }
       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(
+        if (!await this.tmux.readMetadata(pane.sessionName, signal)) {
+          await this.writeMetadata(pane, registered, signal).catch((error) => this.log(
             `failed to backfill tmux metadata for ${registered.id}: ${errorMessage2(error)}`
           ));
         }
         continue;
       }
-      const metadata = await this.tmux.readMetadata(pane.sessionName);
-      const recovered = metadata ? this.fromMetadata(pane, metadata) : await this.fromLegacy(pane);
+      const metadata = await this.tmux.readMetadata(pane.sessionName, signal);
+      const recovered = metadata ? this.fromMetadata(pane, metadata) : await this.fromLegacy(pane, signal);
       if (!recovered || sessions[recovered.id]) continue;
       if (!metadata) {
         try {
-          await this.writeMetadata(pane, recovered);
+          await this.writeMetadata(pane, recovered, signal);
         } catch (error) {
           await this.log(`failed to persist recovered tmux metadata for ${recovered.id}: ${errorMessage2(error)}`);
           continue;
@@ -357,11 +565,11 @@ var SessionReconciler = class {
       updatedAt: Date.now()
     };
   }
-  async fromLegacy(pane) {
+  async fromLegacy(pane, signal) {
     const id = pane.sessionName.startsWith(`${this.sessionPrefix}-`) ? pane.sessionName.slice(this.sessionPrefix.length + 1) : "";
     const agent = inferLegacyAgent(pane);
     if (!validSessionId(id) || !agent) return void 0;
-    const agentVersion = await this.resolveAgentVersion(agent).catch(() => "unknown");
+    const agentVersion = await this.resolveAgentVersion(agent, signal).catch(() => "unknown");
     return {
       id,
       agent,
@@ -372,7 +580,7 @@ var SessionReconciler = class {
       updatedAt: Date.now()
     };
   }
-  writeMetadata(pane, session) {
+  writeMetadata(pane, session, signal) {
     return this.tmux.writeMetadata(pane.sessionName, {
       managed: true,
       sessionId: session.id,
@@ -380,7 +588,7 @@ var SessionReconciler = class {
       cwd: session.cwd,
       agentVersion: session.agentVersion,
       agentSessionId: session.agentSessionId
-    });
+    }, signal);
   }
 };
 function inferLegacyAgent(pane) {
@@ -397,20 +605,20 @@ function errorMessage2(error) {
 
 // src/session/native-session.ts
 import { readdir, readFile as readFile2 } from "fs/promises";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 import { join } from "path";
 var UUID = "[0-9a-fA-F-]{32,36}";
-async function resolveNativeAgentSessionId(agent, pid, home = homedir()) {
+async function resolveNativeAgentSessionId(agent, pid, home = homedir2(), signal) {
   if (!Number.isInteger(pid) || pid <= 0) return void 0;
   if (agent === "traex") {
     const peer = await resolveTraexPeer(pid, home);
     if (peer) return peer;
     return matchPath(
-      await processOpenFiles(pid),
+      await processOpenFiles(pid, signal),
       new RegExp(`/\\.trae/cli/sessions/.+/rollout-[^/]+-(${UUID})\\.jsonl(?:\\.lock)?$`)
     );
   }
-  const openFiles = await processOpenFiles(pid);
+  const openFiles = await processOpenFiles(pid, signal);
   if (agent === "codex") return matchPath(openFiles, new RegExp(`/\\.codex/thread-writer-locks/(${UUID})\\.lock$`));
   return matchPath(openFiles, new RegExp(`/\\.claude/projects/[^/]+/(${UUID})\\.jsonl$`));
 }
@@ -426,8 +634,8 @@ async function resolveTraexPeer(pid, home) {
   }
   return void 0;
 }
-async function processOpenFiles(pid) {
-  const result2 = await runFile("lsof", ["-Fn", "-p", String(pid)], { timeoutMs: 3e3 }).catch(() => void 0);
+async function processOpenFiles(pid, signal) {
+  const result2 = await runFile("lsof", ["-Fn", "-p", String(pid)], { timeoutMs: 3e3, signal }).catch(() => void 0);
   if (!result2) return [];
   return result2.stdout.split("\n").filter((line) => line.startsWith("n")).map((line) => line.slice(1));
 }
@@ -482,11 +690,11 @@ var TmuxController = class {
         { sessionId: options.sessionName }
       );
     }
-    if (await this.hasSession(options.sessionName)) {
+    if (await this.hasSession(options.sessionName, options.signal)) {
       throw new AppError(
         "SESSION_EXISTS",
         `tmux session already exists: ${options.sessionName}`,
-        { sessionId: displaySessionId(options.sessionName) }
+        { sessionId: displaySessionId(options.sessionName), source: "tmux" }
       );
     }
     const environment = Object.entries(options.env ?? {}).map(([key, value]) => {
@@ -514,34 +722,34 @@ var TmuxController = class {
     if (options.preserveOnExit) {
       createArgs.push(";", "set-option", "-w", "-t", `=${options.sessionName}:`, "remain-on-exit", "on");
     }
-    await runFile(this.binary, createArgs);
-    const pane = await this.findBySession(options.sessionName);
+    await runFile(this.binary, createArgs, { signal: options.signal });
+    const pane = await this.findBySession(options.sessionName, options.signal);
     if (!pane) throw new Error("tmux created a session without a discoverable pane");
     return pane;
   }
-  async hasSession(sessionName) {
+  async hasSession(sessionName, signal) {
     try {
-      await runFile(this.binary, ["has-session", "-t", `=${sessionName}`]);
+      await runFile(this.binary, ["has-session", "-t", `=${sessionName}`], { signal });
       return true;
     } catch {
       return false;
     }
   }
-  async findBySession(sessionName) {
+  async findBySession(sessionName, signal) {
     const { stdout } = await runFile(this.binary, [
       "list-panes",
       "-t",
       `=${sessionName}`,
       "-F",
       PANE_FORMAT
-    ]);
+    ], { signal });
     return stdout.split("\n").map(parsePane).find(Boolean);
   }
-  async inspect(paneId) {
-    const result2 = await this.inspectStatus(paneId);
+  async inspect(paneId, signal) {
+    const result2 = await this.inspectStatus(paneId, signal);
     return result2.status === "live" || result2.status === "dead" ? result2.pane : void 0;
   }
-  async inspectStatus(paneId) {
+  async inspectStatus(paneId, signal) {
     assertSafeTmuxTarget(paneId);
     try {
       const { stdout } = await runFile(this.binary, [
@@ -550,7 +758,7 @@ var TmuxController = class {
         "-t",
         paneId,
         PANE_FORMAT
-      ]);
+      ], { signal });
       if (!stdout.trim()) return { status: "missing" };
       const pane = parsePane(stdout.trim());
       if (!pane) return { status: "unavailable", error: new Error("invalid tmux pane response") };
@@ -559,20 +767,20 @@ var TmuxController = class {
       return tmuxTargetMissing(error) ? { status: "missing" } : { status: "unavailable", error };
     }
   }
-  async inspectSession(sessionName) {
+  async inspectSession(sessionName, signal) {
     try {
-      const pane = await this.findBySession(sessionName);
+      const pane = await this.findBySession(sessionName, signal);
       if (!pane) return { status: "missing" };
       return pane.dead ? { status: "dead", pane } : { status: "live", pane };
     } catch (error) {
       return tmuxTargetMissing(error) ? { status: "missing" } : { status: "unavailable", error };
     }
   }
-  async listSessions(prefix) {
-    const { stdout } = await runFile(this.binary, ["list-panes", "-a", "-F", PANE_FORMAT]);
+  async listSessions(prefix, signal) {
+    const { stdout } = await runFile(this.binary, ["list-panes", "-a", "-F", PANE_FORMAT], { signal });
     return stdout.split("\n").map(parsePane).filter((pane) => Boolean(pane?.sessionName.startsWith(prefix)));
   }
-  async writeMetadata(sessionName, metadata) {
+  async writeMetadata(sessionName, metadata, signal) {
     const values = {
       managed: "1",
       sessionId: metadata.sessionId,
@@ -584,16 +792,16 @@ var TmuxController = class {
     for (const [key, option2] of Object.entries(METADATA_OPTIONS)) {
       const value = values[key];
       if (value === void 0) {
-        await runFile(this.binary, ["set-option", "-u", "-t", sessionName, option2]).catch(() => void 0);
+        await runFile(this.binary, ["set-option", "-u", "-t", sessionName, option2], { signal }).catch(() => void 0);
       } else {
-        await runFile(this.binary, ["set-option", "-t", sessionName, option2, value]);
+        await runFile(this.binary, ["set-option", "-t", sessionName, option2, value], { signal });
       }
     }
   }
-  async readMetadata(sessionName) {
+  async readMetadata(sessionName, signal) {
     const values = {};
     for (const [key, option2] of Object.entries(METADATA_OPTIONS)) {
-      const result2 = await runFile(this.binary, ["show-options", "-t", sessionName, "-v", option2]).catch(() => void 0);
+      const result2 = await runFile(this.binary, ["show-options", "-t", sessionName, "-v", option2], { signal }).catch(() => void 0);
       if (!result2) {
         if (key === "agentSessionId") continue;
         return void 0;
@@ -610,7 +818,7 @@ var TmuxController = class {
       agentSessionId: values.agentSessionId || void 0
     };
   }
-  async capture(paneId, lines = 200) {
+  async capture(paneId, lines = 200, signal) {
     assertSafeTmuxTarget(paneId);
     const { stdout } = await runFile(this.binary, [
       "capture-pane",
@@ -621,10 +829,10 @@ var TmuxController = class {
       paneId,
       "-S",
       `-${Math.max(1, lines)}`
-    ]);
+    ], { signal });
     return stdout;
   }
-  async preserveOnExit(sessionName, enabled) {
+  async preserveOnExit(sessionName, enabled, signal) {
     await runFile(this.binary, [
       "set-option",
       "-w",
@@ -632,7 +840,7 @@ var TmuxController = class {
       `=${sessionName}:`,
       "remain-on-exit",
       enabled ? "on" : "off"
-    ]);
+    ], { signal });
   }
   sendText(paneId, input, submit = true) {
     assertSafeTmuxTarget(paneId);
@@ -651,16 +859,16 @@ var TmuxController = class {
     this.writes = this.writes.then(operation, operation);
     return this.writes;
   }
-  async sendKey(paneId, key) {
+  async sendKey(paneId, key, signal) {
     assertSafeTmuxTarget(paneId);
     if (!/^(Enter|Escape|Space|Tab|BSpace|Up|Down|Left|Right|PPage|NPage|C-c|C-u|C-k|C-Enter|[yandpcq1-9])$/.test(key)) {
       throw new Error(`unsupported tmux key: ${key}`);
     }
-    await runFile(this.binary, ["send-keys", "-t", paneId, key]);
+    await runFile(this.binary, ["send-keys", "-t", paneId, key], { signal });
   }
-  async killSession(sessionName) {
+  async killSession(sessionName, signal) {
     try {
-      await runFile(this.binary, ["kill-session", "-t", `=${sessionName}`]);
+      await runFile(this.binary, ["kill-session", "-t", `=${sessionName}`], { signal });
     } catch (error) {
       if (!tmuxTargetMissing(error)) throw error;
     }
@@ -690,9 +898,9 @@ function parsePane(line) {
   };
 }
 function tmuxTargetMissing(error) {
-  const message = error instanceof Error ? error.message : String(error);
+  const message2 = error instanceof Error ? error.message : String(error);
   const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr) : "";
-  return /can't find (?:pane|session|window)|no such (?:pane|session|window)|(?:pane|session|window) not found/i.test(`${message}
+  return /can't find (?:pane|session|window)|no such (?:pane|session|window)|(?:pane|session|window) not found|no server running/i.test(`${message2}
 ${stderr}`);
 }
 
@@ -1207,6 +1415,8 @@ var ActionSigner = class {
       value.interactionKind ?? null,
       value.sessionId ?? null,
       value.manualMode ?? null,
+      value.snapshotId ?? null,
+      value.page ?? null,
       value.agent,
       value.action,
       value.paneId,
@@ -1230,7 +1440,12 @@ 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 === "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";
+  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.snapshotId === void 0 || typeof item.snapshotId === "string") && (item.page === void 0 || typeof item.page === "number" && Number.isInteger(item.page) && item.page >= 0) && (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/workspace/session-create.ts
+function emptySessionCreateDraft() {
+  return { agent: "codex", resumeMode: "new" };
 }
 
 // src/lark/cards.ts
@@ -1614,10 +1829,33 @@ 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_PROJECT_FIELD = "session_project";
 var SESSION_CREATE_RESUME_FIELD = "session_resume";
-function sessionCreateCard() {
+var SESSION_CREATE_MANUAL_VALUE = "__manual__";
+function sessionCreateCard(view2 = {
+  mode: "manual",
+  page: 0,
+  pageCount: 1,
+  candidates: [],
+  partial: false,
+  warnings: [],
+  draft: emptySessionCreateDraft()
+}) {
+  const directoryElements = view2.mode === "projects" ? projectDirectoryFields(view2) : [{
+    tag: "input",
+    name: SESSION_CREATE_CWD_FIELD,
+    default_value: view2.draft.manualCwd,
+    placeholder: { tag: "plain_text", content: "~/workspace/project \u6216 /absolute/path" },
+    label: { tag: "plain_text", content: "\u9879\u76EE\u76EE\u5F55" }
+  }];
+  const noticeLines = [
+    ...view2.warnings.map((warning) => `\u26A0\uFE0F ${escapeMarkdown(warning)}`),
+    ...view2.partial ? ["\u26A0\uFE0F \u90E8\u5206\u76EE\u5F55\u672A\u52A0\u8F7D\uFF1B\u53EF\u9009\u62E9\u5DF2\u663E\u793A\u9879\u76EE\u6216\u624B\u52A8\u586B\u5199\u8DEF\u5F84\u3002"] : []
+  ];
+  const notices = noticeLines.length > 0 ? [{ tag: "markdown", content: noticeLines.join("\n") }] : [];
   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" },
+    ...notices,
     {
       tag: "form",
       name: "session_create_form",
@@ -1628,6 +1866,7 @@ function sessionCreateCard() {
           tag: "input",
           name: SESSION_CREATE_NAME_FIELD,
           required: true,
+          default_value: view2.draft.sessionId,
           placeholder: { tag: "plain_text", content: "Session \u540D\u79F0\uFF0C\u4F8B\u5982 helix" },
           label: { tag: "plain_text", content: "Session \u540D\u79F0" }
         },
@@ -1636,24 +1875,18 @@ function sessionCreateCard() {
           name: SESSION_CREATE_AGENT_FIELD,
           required: true,
           placeholder: { tag: "plain_text", content: "\u9009\u62E9 Agent" },
-          initial_option: "codex",
+          initial_option: view2.draft.agent,
           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" }
-        },
+        ...directoryElements,
         {
           tag: "select_static",
           name: SESSION_CREATE_RESUME_FIELD,
           placeholder: { tag: "plain_text", content: "\u9009\u62E9\u542F\u52A8\u65B9\u5F0F" },
-          initial_option: "new",
+          initial_option: view2.draft.resumeMode,
           options: [
             { text: { tag: "plain_text", content: "\u65B0\u4F1A\u8BDD" }, value: "new" },
             { text: { tag: "plain_text", content: "\u6253\u5F00\u539F\u751F Resume Picker" }, value: "picker" }
@@ -1672,6 +1905,26 @@ function sessionCreateCard() {
     }
   ]);
 }
+function projectDirectoryFields(view2) {
+  const options = [...view2.candidates.map((candidate) => ({
+    text: { tag: "plain_text", content: candidate.label },
+    value: candidate.cwd
+  })), { text: { tag: "plain_text", content: "\u624B\u52A8\u586B\u5199\u5176\u4ED6\u8DEF\u5F84\u2026" }, value: SESSION_CREATE_MANUAL_VALUE }];
+  return [{
+    tag: "select_static",
+    name: SESSION_CREATE_PROJECT_FIELD,
+    placeholder: { tag: "plain_text", content: "\u9009\u62E9\u9879\u76EE\u76EE\u5F55" },
+    initial_option: view2.draft.projectCwd,
+    required: true,
+    options
+  }, {
+    tag: "input",
+    name: SESSION_CREATE_CWD_FIELD,
+    default_value: view2.draft.manualCwd,
+    placeholder: { tag: "plain_text", content: "\u9009\u62E9\u201C\u624B\u52A8\u586B\u5199\u5176\u4ED6\u8DEF\u5F84\u2026\u201D\u65F6\u586B\u5199" },
+    label: { tag: "plain_text", content: "\u5176\u4ED6\u8DEF\u5F84\uFF08\u53EF\u9009\uFF09" }
+  }];
+}
 function sessionCreateResultCard(success, content, session) {
   const details = session ? `
 
@@ -1702,6 +1955,25 @@ function sessionCreateFailureCard(chatId, content, signer) {
   ], "red");
 }
 function sessionStartupFailureCard(chatId, failure, signer) {
+  if (failure.reason === "timeout") {
+    const details = [
+      `\u26A0\uFE0F **Session**  \`${escapeInlineCode(failure.sessionId)}\``,
+      `**Agent**  ${escapeMarkdown(getAgentAdapter(failure.agent).displayName)}`,
+      `**\u5DE5\u4F5C\u76EE\u5F55**  \`${escapeInlineCode(failure.cwd ?? "\u672A\u77E5")}\``,
+      `**\u7ED3\u679C**  \u542F\u52A8\u8D85\u8FC7 30 \u79D2\uFF0C\u5DF2\u53D6\u6D88\u5E76\u6E05\u7406`,
+      `**\u8D85\u65F6\u9636\u6BB5**  \`${escapeInlineCode(failure.stage ?? "unknown")}\``
+    ].join("\n");
+    const output = failure.terminalExcerpt.trim() ? [{ tag: "markdown", content: `**\u6700\u8FD1\u7EC8\u7AEF\u8F93\u51FA**
+
+\`\`\`text
+${escapeFence(failure.terminalExcerpt)}
+\`\`\`` }] : [];
+    return cardElements("Session \u542F\u52A8\u5931\u8D25", [
+      { tag: "markdown", content: details },
+      ...output,
+      ...sessionFailureActions(chatId, failure.sessionId, failure.agent, signer)
+    ], "red");
+  }
   const exitStatus = failure.exitStatus === void 0 ? "\u672A\u77E5" : String(failure.exitStatus);
   return cardElements("Session \u542F\u52A8\u5931\u8D25", [
     {
@@ -2012,7 +2284,7 @@ var LarkGateway = class {
       httpTimeoutMs: 3e4,
       respectProxyEnv: true
     });
-    this.channel.on("message", async (message) => this.handler.onMessage(message));
+    this.channel.on("message", async (message2) => this.handler.onMessage(message2));
     this.channel.on("cardAction", async (event) => {
       console.error(`[lca] card action received: tag=${event.action.tag ?? "unknown"} name=${event.action.name ?? "-"} message=${event.messageId}`);
       const mappedFormAction = event.action.formValue && event.action.name ? this.formActions.get(event.messageId)?.get(event.action.name) : void 0;
@@ -2038,10 +2310,10 @@ var LarkGateway = class {
       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);
+        this.rememberSessionCreateFormActions(event.messageId, event.chatId, result2.view);
         return {
           toast: { type: "success", content: result2.content },
-          card: { type: "raw", data: sessionCreateCard() }
+          card: { type: "raw", data: sessionCreateCard(result2.view) }
         };
       }
       if (result2.type === "manual") {
@@ -2179,8 +2451,13 @@ var LarkGateway = class {
         return;
       }
       if (result2.type === "session-create-form") {
-        const sent = await this.sendMessage(event.chatId, { card: sessionCreateCard() });
-        this.rememberSessionCreateFormAction(sent.messageId, event.chatId);
+        if (action.kind === "session-create" && action.action !== "open") {
+          await this.updateCardAfterAction(event.messageId, sessionCreateCard(result2.view));
+          this.rememberSessionCreateFormActions(event.messageId, event.chatId, result2.view);
+          return;
+        }
+        const sent = await this.sendMessage(event.chatId, { card: sessionCreateCard(result2.view) });
+        this.rememberSessionCreateFormActions(sent.messageId, event.chatId, result2.view);
         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);
@@ -2227,7 +2504,7 @@ var LarkGateway = class {
     const retryDelays = [0, 300, 800, 1600];
     let lastError;
     for (const delay of retryDelays) {
-      if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+      if (delay > 0) await new Promise((resolve2) => setTimeout(resolve2, delay));
       try {
         await this.channel.updateCard(messageId, card2);
         return;
@@ -2257,22 +2534,22 @@ var LarkGateway = class {
     await Promise.all([...chats].map((chatId) => this.clearProcessing(chatId)));
     await this.channel.disconnect();
   }
-  async startProcessing(message) {
-    await this.clearProcessing(message.chatId);
-    const generation = this.processingGenerations.get(message.chatId) ?? 0;
+  async startProcessing(message2) {
+    await this.clearProcessing(message2.chatId);
+    const generation = this.processingGenerations.get(message2.chatId) ?? 0;
     try {
-      const reactionId = await this.channel.addReaction(message.messageId, "Typing");
-      if (this.processingGenerations.get(message.chatId) !== generation) {
-        await this.removeProcessingReaction(message.messageId, reactionId);
+      const reactionId = await this.channel.addReaction(message2.messageId, "Typing");
+      if (this.processingGenerations.get(message2.chatId) !== generation) {
+        await this.removeProcessingReaction(message2.messageId, reactionId);
         return;
       }
       const timer = setTimeout(() => {
-        void this.clearProcessing(message.chatId, generation);
+        void this.clearProcessing(message2.chatId, generation);
       }, 10 * 6e4);
       timer.unref?.();
-      this.processingReactions.set(message.chatId, { messageId: message.messageId, reactionId, timer, generation });
+      this.processingReactions.set(message2.chatId, { messageId: message2.messageId, reactionId, timer, generation });
     } catch (error) {
-      console.error(`[lca] failed to add processing reaction: chat=${message.chatId} message=${message.messageId} detail=${cardErrorDetail(error)}`);
+      console.error(`[lca] failed to add processing reaction: chat=${message2.chatId} message=${message2.messageId} detail=${cardErrorDetail(error)}`);
     }
   }
   sendText(chatId, text) {
@@ -2318,18 +2595,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)
-    ]]));
+  rememberSessionCreateFormActions(messageId, chatId, view2) {
+    const actions = /* @__PURE__ */ new Map();
+    actions.set(SESSION_CREATE_SUBMIT_ACTION, this.signer.sign({
+      kind: "session-create",
+      agent: view2.draft.agent,
+      action: "submit",
+      paneId: "",
+      fingerprint: view2.mode,
+      chatId,
+      snapshotId: view2.snapshotId,
+      page: view2.page
+    }, 10 * 6e4));
+    this.formActions.set(messageId, actions);
   }
   rememberFormActions(messageId, chatId, paneId, screen, agent) {
     if (screen.interaction?.semantics?.activation !== "toggle") {
@@ -2365,9 +2643,9 @@ var LarkGateway = class {
   sendStartupConflict(chatId, request, owner) {
     return this.sendMessage(chatId, { card: startupConflictCard(chatId, requestSession(request), owner, this.signer) });
   }
-  async sendSessionCreate(chatId) {
-    const result2 = await this.sendMessage(chatId, { card: sessionCreateCard() });
-    this.rememberSessionCreateFormAction(result2.messageId, chatId);
+  async sendSessionCreate(chatId, view2) {
+    const result2 = await this.sendMessage(chatId, { card: sessionCreateCard(view2) });
+    this.rememberSessionCreateFormActions(result2.messageId, chatId, view2);
     return result2;
   }
   sendSessionStartupFailure(chatId, failure) {
@@ -2434,8 +2712,8 @@ function cardErrorDetail(error) {
   const data = response && typeof response === "object" ? response.data : void 0;
   const record = data && typeof data === "object" ? data : void 0;
   const code = typeof record?.code === "number" || typeof record?.code === "string" ? String(record.code) : void 0;
-  const message = typeof record?.msg === "string" ? record.msg : error instanceof Error ? error.message : String(error);
-  const sanitized = message.replace(/(?:authorization\s*:\s*bearer|bearer)\s+[^\s,'"\]}]+/gi, "Bearer [REDACTED]").replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 1200);
+  const message2 = typeof record?.msg === "string" ? record.msg : error instanceof Error ? error.message : String(error);
+  const sanitized = message2.replace(/(?:authorization\s*:\s*bearer|bearer)\s+[^\s,'"\]}]+/gi, "Bearer [REDACTED]").replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 1200);
   return code ? `code=${code} ${sanitized}` : sanitized;
 }
 
@@ -2640,9 +2918,155 @@ function redactSecrets(value) {
   ).replace(/([?&](?:api[_-]?key|access[_-]?token|token|secret|signature)=)[^&#\s]+/gi, "$1[REDACTED]");
 }
 
+// src/workspace/discovery.ts
+import { lstat, readdir as readdir2, stat as stat2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { basename, dirname as dirname2, join as join2, relative } from "path";
+async function discoverWorkspaces(options) {
+  const maxDepth = options.maxDepth ?? 1;
+  const maxDirectories = options.maxDirectories ?? 500;
+  const timeBudgetMs = options.timeBudgetMs ?? 2e3;
+  const now = options.now ?? Date.now;
+  const home = options.home ?? homedir3();
+  const startedAt = now();
+  const warnings = [];
+  const byPath = /* @__PURE__ */ new Map();
+  let visitedDirectories = 0;
+  let partial = false;
+  const budgetAvailable = () => {
+    const available = visitedDirectories < maxDirectories && now() - startedAt <= timeBudgetMs;
+    if (!available) partial = true;
+    return available;
+  };
+  const add = async (input, source) => {
+    if (!budgetAvailable()) return;
+    let cwd;
+    try {
+      cwd = normalizeWorkspacePath(input, home);
+    } catch {
+      return;
+    }
+    if (byPath.has(cwd)) return;
+    visitedDirectories += 1;
+    try {
+      const info = await lstat(cwd);
+      if (!info.isDirectory() || info.isSymbolicLink()) return;
+      byPath.set(cwd, { cwd, label: workspaceLabel(cwd, home), source, git: await hasGitEntry(cwd) });
+    } catch {
+      if (source === "configured") warnings.push(`\u65E0\u6CD5\u8BFB\u53D6 workspace\uFF1A${cwd}`);
+    }
+  };
+  for (const session of options.activeSessions) await add(session.cwd, "active");
+  for (const recent of [...options.recentWorkspaces].sort((a, b) => b.lastUsedAt - a.lastUsedAt)) {
+    await add(recent.cwd, "recent");
+  }
+  for (const rootInput of options.workspaceRoots) {
+    if (!budgetAvailable()) break;
+    let root;
+    try {
+      root = normalizeWorkspacePath(rootInput, home);
+      const info = await lstat(root);
+      if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("not a directory");
+    } catch {
+      warnings.push(`\u65E0\u6CD5\u8BFB\u53D6 workspace\uFF1A${rootInput}`);
+      continue;
+    }
+    await add(root, "configured");
+    let frontier = [root];
+    for (let depth = 1; depth <= maxDepth && frontier.length > 0 && budgetAvailable(); depth += 1) {
+      const next = [];
+      for (const parent of frontier) {
+        if (!budgetAvailable()) break;
+        let entries;
+        try {
+          entries = await readdir2(parent, { withFileTypes: true });
+        } catch {
+          warnings.push(`\u65E0\u6CD5\u8BFB\u53D6\u76EE\u5F55\uFF1A${parent}`);
+          continue;
+        }
+        for (const entry of entries) {
+          if (!budgetAvailable()) break;
+          if (!entry.isDirectory() || entry.isSymbolicLink() || entry.name.startsWith(".")) continue;
+          const child = join2(parent, entry.name);
+          await add(child, "configured");
+          if (depth < maxDepth) next.push(child);
+        }
+      }
+      frontier = next;
+    }
+  }
+  const priority = { active: 0, recent: 1, configured: 2 };
+  const candidates = [...byPath.values()].sort(
+    (left, right) => priority[left.source] - priority[right.source] || Number(right.git) - Number(left.git) || left.label.localeCompare(right.label, "zh-CN")
+  );
+  return { candidates, partial, warnings: [...new Set(warnings)], visitedDirectories };
+}
+function workspaceLabel(cwd, home = homedir3()) {
+  const parent = dirname2(cwd);
+  const rel = relative(home, parent);
+  const displayParent = rel === "" ? "~" : !rel.startsWith("..") ? `~/${rel}` : parent;
+  return `${basename(cwd) || cwd} \xB7 ${displayParent}`;
+}
+async function hasGitEntry(cwd) {
+  return stat2(join2(cwd, ".git")).then(() => true).catch(() => false);
+}
+
+// src/workspace/recent.ts
+function rememberRecentWorkspace(existing, cwd, now = Date.now(), limit = 30) {
+  const normalized = normalizeWorkspacePath(cwd);
+  return [
+    { cwd: normalized, lastUsedAt: now },
+    ...(existing ?? []).filter((item) => normalizeWorkspacePath(item.cwd) !== normalized)
+  ].slice(0, limit);
+}
+
+// src/workspace/snapshot.ts
+import { randomBytes as randomBytes4 } from "crypto";
+var WorkspaceSnapshotStore = class {
+  constructor(ttlMs = 10 * 6e4, capacity = 64, now = Date.now, createId = () => randomBytes4(12).toString("base64url")) {
+    this.ttlMs = ttlMs;
+    this.capacity = capacity;
+    this.now = now;
+    this.createId = createId;
+  }
+  ttlMs;
+  capacity;
+  now;
+  createId;
+  values = /* @__PURE__ */ new Map();
+  create(input) {
+    const now = this.now();
+    this.prune(now);
+    const snapshot = {
+      ...input,
+      id: this.createId(),
+      createdAt: now,
+      expiresAt: now + this.ttlMs
+    };
+    this.values.set(snapshot.id, snapshot);
+    while (this.values.size > this.capacity) {
+      const oldest = this.values.keys().next().value;
+      if (!oldest) break;
+      this.values.delete(oldest);
+    }
+    return snapshot;
+  }
+  get(id, chatId, ownerOpenId) {
+    const now = this.now();
+    this.prune(now);
+    const value = this.values.get(id);
+    return value?.chatId === chatId && value.ownerOpenId === ownerOpenId ? value : void 0;
+  }
+  prune(now) {
+    for (const [id, value] of this.values) {
+      if (value.expiresAt <= now) this.values.delete(id);
+    }
+  }
+};
+
 // src/daemon/server.ts
 var AssistantDaemon = class {
-  constructor(store, paths2, gatewayFactory = (config, secrets, handler) => new LarkGateway(config, secrets, handler), sessionName = "lark-coding-assistant", stopHookCommand = "lark-coding-assistant-hook", completionQuietMs = 2500, appVersion = "dev") {
+  constructor(store, paths2, gatewayFactory = (config, secrets, handler) => new LarkGateway(config, secrets, handler), sessionName = "lark-coding-assistant", stopHookCommand = "lark-coding-assistant-hook", completionQuietMs = 2500, appVersion = "dev", sessionStartTimeoutMs = 3e4) {
     this.store = store;
     this.paths = paths2;
     this.gatewayFactory = gatewayFactory;
@@ -2650,6 +3074,7 @@ var AssistantDaemon = class {
     this.stopHookCommand = stopHookCommand;
     this.completionQuietMs = completionQuietMs;
     this.appVersion = appVersion;
+    this.sessionStarts = new SessionStartCoordinator(sessionStartTimeoutMs, (message2) => this.log(message2));
   }
   store;
   paths;
@@ -2681,6 +3106,9 @@ var AssistantDaemon = class {
   pendingAgentSessionClaims = /* @__PURE__ */ new Map();
   pendingResumePickers = /* @__PURE__ */ new Map();
   pendingStartupConflicts = /* @__PURE__ */ new Map();
+  workspaceSnapshots = new WorkspaceSnapshotStore();
+  sessionStarts;
+  startStateWrites = Promise.resolve();
   pendingInteractionInput;
   attachAttempts = /* @__PURE__ */ new Map();
   server = createServer((socket) => this.handleSocket(socket));
@@ -2695,10 +3123,10 @@ var AssistantDaemon = class {
       this.tmux,
       this.sessionName,
       3,
-      (message) => this.log(message),
-      async (agent) => {
+      (message2) => this.log(message2),
+      async (agent, signal) => {
         const adapter = getAgentAdapter(agent);
-        return (await runFile(adapter.binary(this.config), [...adapter.versionArgs])).stdout.trim();
+        return (await runFile(adapter.binary(this.config), [...adapter.versionArgs], { signal })).stdout.trim();
       }
     );
     const secrets = await this.store.loadSecrets();
@@ -2707,13 +3135,13 @@ var AssistantDaemon = class {
     try {
       await this.reconcileSessions(true);
       await rm(this.paths.socket, { force: true });
-      await new Promise((resolve, reject) => {
+      await new Promise((resolve2, reject) => {
         this.server.once("error", reject);
-        this.server.listen(this.paths.socket, () => resolve());
+        this.server.listen(this.paths.socket, () => resolve2());
       });
       await chmod3(this.paths.socket, 384);
       this.gateway = this.gatewayFactory(config, secrets, {
-        onMessage: (message) => this.onLarkMessage(message),
+        onMessage: (message2) => this.onLarkMessage(message2),
         onAction: (event, action) => this.onLarkAction(event, action),
         onResumePickerDeliveryFailure: (session) => this.handleResumePickerDeliveryFailure(session)
       });
@@ -2732,7 +3160,7 @@ var AssistantDaemon = class {
     if (this.timer) clearTimeout(this.timer);
     await this.pollInFlight?.catch(() => void 0);
     await this.gateway?.disconnect().catch(() => void 0);
-    await new Promise((resolve) => this.server.close(() => resolve()));
+    await new Promise((resolve2) => this.server.close(() => resolve2()));
     await this.releaseRuntimeFiles();
   }
   async acquireRuntimeFiles() {
@@ -2817,13 +3245,36 @@ var AssistantDaemon = class {
         return this.handleTurnComplete(request.candidate);
     }
   }
-  async startSession(sessionId, cwd, agentId, resume) {
+  async startSession(sessionId, cwd, agentId, resume, source = "cli") {
     try {
-      await validateStartSessionRequest({ sessionId, cwd, agent: agentId, resume });
+      const validated = await validateStartSessionRequest({ sessionId, cwd, agent: agentId, resume });
+      cwd = validated.cwd;
     } catch (error) {
       return fail(error);
     }
-    await this.reconcileSessions(true);
+    let createdSessionName;
+    const outcome = await this.sessionStarts.run(
+      { sessionId, cwd, agent: agentId, resume, source },
+      async (context) => {
+        const result2 = await this.startSessionCore(
+          sessionId,
+          cwd,
+          agentId,
+          resume,
+          context,
+          (sessionName) => {
+            createdSessionName = sessionName;
+          }
+        );
+        if (!result2.ok) throw daemonResultAppError(result2);
+        return result2.value;
+      },
+      async (_context, error) => this.cleanupStartTransaction(sessionId, createdSessionName, error)
+    );
+    return outcome.ok ? { ok: true, value: outcome.value } : fail(outcome.error);
+  }
+  async startSessionCore(sessionId, cwd, agentId, resume, context, created) {
+    await context.stage("reconcile", () => this.reconcileSessions(true, context.signal));
     const existing = this.state.sessions?.[sessionId];
     if (existing) {
       return fail(new AppError(
@@ -2843,14 +3294,17 @@ var AssistantDaemon = class {
     const binary = adapter.binary(this.config);
     let agentVersion;
     try {
-      agentVersion = (await runFile(binary, [...adapter.versionArgs])).stdout.trim();
+      agentVersion = (await context.stage("agent-version", () => runFile(binary, [...adapter.versionArgs], {
+        timeoutMs: context.remainingMs(),
+        signal: context.signal
+      }))).stdout.trim();
     } catch (error) {
-      return fail(systemErrorCode(error) === "ENOENT" ? new AppError("BINARY_NOT_FOUND", `command not found: ${binary}`, { binary }, { cause: error }) : new AppError("START_FAILED", `failed to inspect agent binary: ${binary}`, { sessionId }, { cause: error }));
+      return fail(isAppError(error) ? error : systemErrorCode(error) === "ENOENT" ? new AppError("BINARY_NOT_FOUND", `command not found: ${binary}`, { binary }, { cause: error }) : new AppError("START_FAILED", `failed to inspect agent binary: ${binary}`, { sessionId }, { cause: error }));
     }
     const tmuxSessionName = `${this.sessionName}-${sessionId}`;
     let pane;
     try {
-      pane = await this.tmux.create({
+      pane = await context.stage("tmux-create", () => this.tmux.create({
         sessionName: tmuxSessionName,
         cwd,
         binary,
@@ -2863,8 +3317,10 @@ var AssistantDaemon = class {
           LARK_CODING_ASSISTANT_SESSION_ID: sessionId,
           LARK_CODING_ASSISTANT_AGENT: agentId
         },
-        preserveOnExit: true
-      });
+        preserveOnExit: true,
+        signal: context.signal
+      }));
+      created(pane.sessionName);
     } catch (error) {
       return fail(isAppError(error) ? error : new AppError("START_FAILED", "failed to create tmux session", { sessionId }, { cause: error }));
     }
@@ -2879,80 +3335,128 @@ var AssistantDaemon = class {
       updatedAt: Date.now()
     };
     const pendingClaim = this.pendingAgentSessionClaims.get(sessionId);
-    if (pendingClaim?.agent === agentId) {
-      const owner = this.findAgentSessionOwner(agentId, pendingClaim.agentSessionId, sessionId);
-      if (owner) {
-        this.pendingAgentSessionClaims.delete(sessionId);
-        await this.tmux.killSession(pane.sessionName).catch(() => void 0);
-        return fail(agentSessionInUse(sessionId, owner.id));
-      }
-      session.agentSessionId = pendingClaim.agentSessionId;
-      this.pendingAgentSessionClaims.delete(sessionId);
-    }
-    try {
-      await this.tmux.writeMetadata(pane.sessionName, {
-        managed: true,
-        sessionId,
-        agent: agentId,
-        cwd,
-        agentVersion,
-        agentSessionId: session.agentSessionId
-      });
-    } catch (error) {
-      await this.tmux.killSession(pane.sessionName).catch((cleanupError) => this.log(
-        `failed to clean session ${sessionId} after metadata error: ${errorMessage3(cleanupError)}`
-      ));
-      return fail(new AppError("START_FAILED", "failed to persist tmux session metadata", { sessionId }, { cause: error }));
-    }
-    const nextState = {
-      ...this.state,
-      sessions: { ...this.state.sessions, [sessionId]: session },
-      activeSessionId: this.state.activeSessionId ?? sessionId,
-      boundChatId: binding.mode === "reused" ? this.state.boundChatId : void 0,
-      bindCodeHash: binding.mode === "code" ? hashBindCode(binding.bindCode) : void 0,
-      bindCodeExpiresAt: binding.mode === "code" ? Date.now() + 10 * 6e4 : void 0,
-      updatedAt: Date.now()
-    };
-    try {
-      await this.store.saveState(nextState);
-    } catch (error) {
-      await this.tmux.killSession(pane.sessionName).catch((cleanupError) => this.log(
-        `failed to clean session ${sessionId} after state error: ${errorMessage3(cleanupError)}`
-      ));
-      return fail(new AppError("START_FAILED", "failed to persist session state", { sessionId }, { cause: error }));
-    }
-    this.state = nextState;
-    const lateClaim = this.pendingAgentSessionClaims.get(sessionId);
-    if (lateClaim) {
-      const claimed = await this.handleAgentSessionStarted(lateClaim);
-      if (!claimed.ok) {
-        await this.stopSession(sessionId).catch(() => void 0);
-        return claimed;
-      }
+    if (pendingClaim) {
+      const claimed = this.claimStartingAgentSession(session, pendingClaim);
+      if (!claimed.ok) return claimed;
     }
     if (resume && resume.mode !== "picker") {
-      const initialClaim = await this.waitForInitialAgentSessionClaim(sessionId, pane.pid);
+      const initialClaim = await context.stage(
+        "agent-identity",
+        () => this.waitForInitialAgentSessionClaim(session, pane.pid, context.signal)
+      );
       if (!initialClaim.ok) {
-        await this.stopSession(sessionId).catch(() => void 0);
         return initialClaim;
       }
-    } else if (!resume) {
-      const stable = await this.waitForStartupStability(session, 500);
+    } else {
+      const stable = await context.stage(
+        "startup-stability",
+        () => this.waitForStartupStability(session, 500, context.signal)
+      );
       if (!stable.ok) {
-        await this.stopSession(sessionId).catch(() => void 0);
         return stable;
       }
     }
+    const resumePicker = resume?.mode === "picker" && context.source === "lark" ? await context.stage("resume-picker", async () => {
+      const picker = await this.waitForResumePicker(
+        session,
+        void 0,
+        context.remainingMs(),
+        context.signal
+      );
+      if (!picker) {
+        throw new AppError("START_FAILED", "agent resume picker did not become available", {
+          sessionId,
+          agent: agentId
+        });
+      }
+      return picker;
+    }) : void 0;
     if (resume?.mode !== "picker") {
-      await this.tmux.preserveOnExit(session.sessionName, false).catch((error) => this.log(
+      await this.tmux.preserveOnExit(session.sessionName, false, context.signal).catch((error) => this.log(
         `failed to disable startup preservation for ${sessionId}: ${errorMessage3(error)}`
       ));
+      await this.rememberSessionWorkspace(session.cwd);
+    }
+    const lateClaim = this.pendingAgentSessionClaims.get(sessionId);
+    if (lateClaim) {
+      const claimed = this.claimStartingAgentSession(session, lateClaim);
+      if (!claimed.ok) return claimed;
+    }
+    try {
+      await context.stage("metadata", () => this.tmux.writeMetadata(pane.sessionName, {
+        managed: true,
+        sessionId,
+        agent: agentId,
+        cwd,
+        agentVersion,
+        agentSessionId: session.agentSessionId
+      }, context.signal));
+      await context.stage("state", () => this.commitStartedSession(session, binding));
+    } catch (error) {
+      return fail(isAppError(error) ? error : new AppError("START_FAILED", "failed to persist completed session", { sessionId }, { cause: error }));
+    }
+    const postCommitClaim = this.pendingAgentSessionClaims.get(sessionId);
+    if (postCommitClaim) {
+      const claimed = await this.handleAgentSessionStarted(postCommitClaim);
+      if (!claimed.ok) return claimed;
     }
     await this.log(
       `session created: session=${session.id} agent=${session.agent} pane=${session.paneId} active=${this.state.activeSessionId === session.id}`
     );
-    await this.poll().catch((error) => this.log(`initial poll failed for ${sessionId}: ${errorMessage3(error)}`));
-    return { ok: true, value: { pane, session, binding, active: this.state.activeSessionId === sessionId } };
+    return {
+      ok: true,
+      value: { pane, session, binding, active: this.state.activeSessionId === sessionId, resumePicker }
+    };
+  }
+  async cleanupStartTransaction(sessionId, createdSessionName, error) {
+    const session = this.state.sessions?.[sessionId];
+    const ownsSession = Boolean(createdSessionName && session?.sessionName === createdSessionName);
+    const createdPane = createdSessionName ? await this.tmux.findBySession(createdSessionName, AbortSignal.timeout(750)).catch(() => void 0) : void 0;
+    const paneId = ownsSession ? session?.paneId : createdPane?.paneId;
+    if (paneId && !error.context.terminalExcerpt) {
+      const terminalExcerpt = await this.tmux.capture(paneId, 40, AbortSignal.timeout(1e3)).then((output) => startupTerminalExcerpt(tailScreen(output, 40).slice(-3e3))).catch(() => "");
+      if (terminalExcerpt) error.context.terminalExcerpt = terminalExcerpt;
+    }
+    if (session && ownsSession) {
+      await this.stopSession(sessionId, AbortSignal.timeout(2e3)).catch((cleanupError) => this.log(
+        `session start state cleanup failed: session=${sessionId} detail=${errorMessage3(cleanupError)}`
+      ));
+      if (this.state.sessions?.[sessionId]?.sessionName === createdSessionName) {
+        await this.forgetSessionState(sessionId).catch((cleanupError) => this.log(
+          `session start forced state cleanup failed: session=${sessionId} detail=${errorMessage3(cleanupError)}`
+        ));
+      }
+    } else if (createdSessionName) {
+      await this.tmux.killSession(createdSessionName, AbortSignal.timeout(2e3)).catch((cleanupError) => this.log(
+        `session start tmux cleanup failed: session=${sessionId} detail=${errorMessage3(cleanupError)}`
+      ));
+    }
+    this.pendingAgentSessionClaims.delete(sessionId);
+    this.pendingResumePickers.delete(sessionId);
+    this.pendingStartupConflicts.delete(sessionId);
+  }
+  commitStartedSession(session, binding) {
+    const commit = async () => {
+      if (this.state.sessions?.[session.id]) {
+        throw new AppError("SESSION_EXISTS", `managed coding-agent session is already running: ${session.id}`, {
+          sessionId: session.id
+        });
+      }
+      const nextState = {
+        ...this.state,
+        sessions: { ...this.state.sessions, [session.id]: session },
+        activeSessionId: this.state.activeSessionId ?? session.id,
+        boundChatId: binding.mode === "reused" ? this.state.boundChatId : void 0,
+        bindCodeHash: binding.mode === "code" ? hashBindCode(binding.bindCode) : void 0,
+        bindCodeExpiresAt: binding.mode === "code" ? Date.now() + 10 * 6e4 : void 0,
+        updatedAt: Date.now()
+      };
+      await this.store.saveState(nextState);
+      this.state = nextState;
+    };
+    const pending = this.startStateWrites.then(commit, commit);
+    this.startStateWrites = pending.catch(() => void 0);
+    return pending;
   }
   createSessionBinding() {
     if (this.state.ownerOpenId && this.state.boundChatId && !this.state.autoBindDisabled) {
@@ -3015,26 +3519,26 @@ var AssistantDaemon = class {
     await this.tmux.sendText(session.paneId, text);
     return { ok: true };
   }
-  async onLarkMessage(message) {
-    if (message.chatType !== "p2p" || message.senderIsBot || message.senderType === "bot") return;
-    const text = message.content.trim();
+  async onLarkMessage(message2) {
+    if (message2.chatType !== "p2p" || message2.senderIsBot || message2.senderType === "bot") return;
+    const text = message2.content.trim();
     const attachCode = text.match(/^\/attach\s+([^\s]+)\s*$/)?.[1];
     if (!this.state.boundChatId) {
-      if (this.canAutoBind(message)) {
-        await this.bindChat(message, true);
+      if (this.canAutoBind(message2)) {
+        await this.bindChat(message2, true);
       } else {
         if (!attachCode) return;
-        await this.handleAttach(message, attachCode);
+        await this.handleAttach(message2, attachCode);
         return;
       }
     }
-    if (message.senderId !== this.state.ownerOpenId || message.chatId !== this.state.boundChatId) return;
+    if (message2.senderId !== this.state.ownerOpenId || message2.chatId !== this.state.boundChatId) return;
     if (text === "/start") {
       try {
-        await this.gateway?.sendSessionCreate(message.chatId);
+        await this.gateway?.sendSessionCreate(message2.chatId, await this.createSessionWorkspaceView(message2.chatId));
       } catch (error) {
         await this.log(`session create card failed: ${errorMessage3(error)}`);
-        await this.gateway?.sendText(message.chatId, "\u65B0\u5EFA Session \u8868\u5355\u53D1\u9001\u5931\u8D25\u3002\u8BF7\u4F7F\u7528 /start <name> --agent <agent> --cwd <\u7EDD\u5BF9\u8DEF\u5F84>\u3002");
+        await this.gateway?.sendText(message2.chatId, "\u65B0\u5EFA Session \u8868\u5355\u53D1\u9001\u5931\u8D25\u3002\u8BF7\u4F7F\u7528 /start <name> --agent <agent> --cwd <\u7EDD\u5BF9\u8DEF\u5F84>\u3002");
       }
       return;
     }
@@ -3043,37 +3547,37 @@ var AssistantDaemon = class {
       try {
         request = parseStartCommand(text);
       } catch (error) {
-        await this.gateway?.sendText(message.chatId, remoteError(fail(error)));
+        await this.gateway?.sendText(message2.chatId, remoteError(fail(error)));
         return;
       }
       const result3 = await this.startRemoteSession(request);
       if (!result3.ok) {
         const failure = sessionStartupFailure(result3.error, request);
-        if (failure) await this.gateway?.sendSessionStartupFailure(message.chatId, failure);
-        else await this.gateway?.sendText(message.chatId, remoteError(result3.error));
+        if (failure) await this.gateway?.sendSessionStartupFailure(message2.chatId, failure);
+        else await this.gateway?.sendText(message2.chatId, remoteError(result3.error));
       } else if (result3.state === "picker") {
         try {
-          await this.gateway?.sendResumePicker(message.chatId, result3.session, result3.picker);
+          await this.gateway?.sendResumePicker(message2.chatId, result3.session, result3.picker);
         } catch (error) {
           await this.handleResumePickerDeliveryFailure(result3.session);
           await this.log(`resume picker notification failed: session=${result3.session.id} error=${errorMessage3(error)}`);
-          await this.gateway?.sendText(message.chatId, "Resume Picker \u5361\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u4E34\u65F6 Session \u5DF2\u6E05\u7406\uFF0C\u8BF7\u91CD\u8BD5\u3002");
+          await this.gateway?.sendText(message2.chatId, "Resume Picker \u5361\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u4E34\u65F6 Session \u5DF2\u6E05\u7406\uFF0C\u8BF7\u91CD\u8BD5\u3002");
         }
-      } else if (result3.state === "conflict") await this.gateway?.sendStartupConflict(message.chatId, result3.request, result3.owner);
-      else await this.gateway?.sendText(message.chatId, remoteStartSuccess(result3.session));
+      } else if (result3.state === "conflict") await this.gateway?.sendStartupConflict(message2.chatId, result3.request, result3.owner);
+      else await this.gateway?.sendText(message2.chatId, remoteStartSuccess(result3.session));
       return;
     }
     const tailMatch = text.match(/^\/tail(?:\s+(\d+))?$/);
     if (tailMatch) {
       const lines = tailMatch[1] ? Number(tailMatch[1]) : 80;
       if (!Number.isInteger(lines) || lines < 20 || lines > 300) {
-        await this.gateway?.sendText(message.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
+        await this.gateway?.sendText(message2.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
         return;
       }
       const output = await this.tail(lines).catch((error) => `\u8BFB\u53D6\u5931\u8D25\uFF1A${errorMessage3(error)}`);
       const session = this.activeSession();
       const metadata = session ? `**${session.id} \xB7 ${getAgentAdapter(session.agent).displayName}**  \xB7  \u72B6\u6001 \`${this.screen?.state ?? "unknown"}\`  \xB7  ${manualTimestamp()}` : "**\u5F53\u524D\u6CA1\u6709 active session**";
-      await this.gateway?.sendMarkdown(message.chatId, `${metadata}
+      await this.gateway?.sendMarkdown(message2.chatId, `${metadata}
 
 \`\`\`text
 ${escapeFence2(output).slice(-6800)}
@@ -3081,20 +3585,20 @@ ${escapeFence2(output).slice(-6800)}
       return;
     }
     if (text.startsWith("/tail")) {
-      await this.gateway?.sendText(message.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
+      await this.gateway?.sendText(message2.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
       return;
     }
     if (text === "/manual") {
       await this.poll();
       const view2 = this.currentManualView();
-      if (!view2) await this.gateway?.sendText(message.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u9065\u63A7\u7684 active tmux session\u3002");
+      if (!view2) await this.gateway?.sendText(message2.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u9065\u63A7\u7684 active tmux session\u3002");
       else {
         try {
-          await this.gateway?.sendManual(message.chatId, view2);
+          await this.gateway?.sendManual(message2.chatId, view2);
         } catch (error) {
           await this.log(`manual card failed: ${errorMessage3(error)}`);
           await this.gateway?.sendText(
-            message.chatId,
+            message2.chatId,
             "\u624B\u52A8\u9065\u63A7\u5361\u53D1\u9001\u5931\u8D25\u3002\u53EF\u4F7F\u7528 /tail 120 \u67E5\u770B\u7EC8\u7AEF\uFF0C\u6216\u4F7F\u7528 /key\u3001/type\u3001/submit \u64CD\u4F5C\u3002"
           );
         }
@@ -3103,44 +3607,44 @@ ${escapeFence2(output).slice(-6800)}
     }
     const manualKey = text.match(/^\/key\s+(up|down|left|right|enter|esc|tab|space|backspace|ctrl-c)$/i)?.[1];
     if (manualKey) {
-      await this.executeManualCommand(message.chatId, `\u6309\u952E ${manualKey}`, async (session) => {
+      await this.executeManualCommand(message2.chatId, `\u6309\u952E ${manualKey}`, async (session) => {
         await this.tmux.sendKey(session.paneId, manualTmuxKey(manualKey));
       });
       return;
     }
     if (text.startsWith("/key")) {
-      await this.gateway?.sendText(message.chatId, "\u7528\u6CD5\uFF1A/key up|down|left|right|enter|esc|tab|space|backspace|ctrl-c");
+      await this.gateway?.sendText(message2.chatId, "\u7528\u6CD5\uFF1A/key up|down|left|right|enter|esc|tab|space|backspace|ctrl-c");
       return;
     }
     const typeMatch = text.match(/^\/(type|submit)\s+([\s\S]+)$/);
     if (typeMatch?.[1] && typeMatch[2]?.trim()) {
       const submit = typeMatch[1] === "submit";
-      await this.executeManualCommand(message.chatId, submit ? "\u8F93\u5165\u5E76\u63D0\u4EA4" : "\u4EC5\u8F93\u5165", async (session) => {
+      await this.executeManualCommand(message2.chatId, submit ? "\u8F93\u5165\u5E76\u63D0\u4EA4" : "\u4EC5\u8F93\u5165", async (session) => {
         await this.tmux.sendText(session.paneId, typeMatch[2], submit);
       });
       return;
     }
     if (text === "/type" || text === "/submit") {
-      await this.gateway?.sendText(message.chatId, `\u7528\u6CD5\uFF1A${text} <\u6587\u672C>`);
+      await this.gateway?.sendText(message2.chatId, `\u7528\u6CD5\uFF1A${text} <\u6587\u672C>`);
       return;
     }
     if (text === "/status") {
       const status = await this.runtimeStatus();
-      await this.gateway?.sendStatus(message.chatId, status);
+      await this.gateway?.sendStatus(message2.chatId, status);
       return;
     }
     if (text === "/sessions") {
       const sessions = await this.reconcileSessions(true);
       try {
         await this.gateway?.sendSessionPicker(
-          message.chatId,
+          message2.chatId,
           sessions,
           this.state.activeSessionId
         );
       } catch (error) {
         await this.log(`session picker notification failed: ${errorMessage3(error)}`);
         await this.gateway?.sendText(
-          message.chatId,
+          message2.chatId,
           "Session \u9009\u62E9\u5361\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u4E5F\u53EF\u4EE5\u53D1\u9001 /use <session \u540D\u79F0> \u8FDB\u884C\u5207\u6362\u3002"
         );
       }
@@ -3152,7 +3656,7 @@ ${escapeFence2(output).slice(-6800)}
       const target = this.state.sessions?.[useSessionId];
       const reply = result3.ok ? `\u5DF2\u8FDE\u63A5\u5230 ${target ? getAgentAdapter(target.agent).displayName : "coding agent"} session\uFF1A${useSessionId}` : `\u5207\u6362\u5931\u8D25\uFF1A${result3.error}`;
       await this.gateway?.sendText(
-        message.chatId,
+        message2.chatId,
         reply
       );
       return;
@@ -3169,16 +3673,16 @@ ${escapeFence2(output).slice(-6800)}
         updatedAt: Date.now()
       };
       await this.store.saveState(this.state);
-      await this.gateway?.sendText(message.chatId, "\u5DF2\u89E3\u9664\u672C\u6B21\u98DE\u4E66\u7ED1\u5B9A\uFF1Bcoding agent \u548C tmux \u4ECD\u5728\u8FD0\u884C\u3002");
+      await this.gateway?.sendText(message2.chatId, "\u5DF2\u89E3\u9664\u672C\u6B21\u98DE\u4E66\u7ED1\u5B9A\uFF1Bcoding agent \u548C tmux \u4ECD\u5728\u8FD0\u884C\u3002");
       return;
     }
     if (text === "/stop") {
       await this.poll();
       const session = this.activeSession();
       if (!session || !this.screen) {
-        await this.gateway?.sendText(message.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u505C\u6B62\u7684 coding agent \u4F1A\u8BDD\u3002");
+        await this.gateway?.sendText(message2.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u505C\u6B62\u7684 coding agent \u4F1A\u8BDD\u3002");
       } else {
-        await this.gateway?.sendStopConfirmation(message.chatId, session.paneId, this.screen.fingerprint, session.agent);
+        await this.gateway?.sendStopConfirmation(message2.chatId, session.paneId, this.screen.fingerprint, session.agent);
       }
       return;
     }
@@ -3187,15 +3691,15 @@ ${escapeFence2(output).slice(-6800)}
       const session = this.activeSession();
       if (!session || session.id !== pendingInput.sessionId) {
         this.pendingInteractionInput = void 0;
-        await this.gateway?.sendText(message.chatId, "\u4EA4\u4E92\u4F1A\u8BDD\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u64CD\u4F5C\u3002");
+        await this.gateway?.sendText(message2.chatId, "\u4EA4\u4E92\u4F1A\u8BDD\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u64CD\u4F5C\u3002");
         return;
       }
-      await this.tmux.sendText(session.paneId, message.content, pendingInput.submitOnInput);
+      await this.tmux.sendText(session.paneId, message2.content, pendingInput.submitOnInput);
       this.pendingInteractionInput = void 0;
       if (pendingInput.submitOnInput) {
         await this.waitForInteractionChange(pendingInput.interactionId);
         if (this.screen?.interaction?.interactionId === pendingInput.interactionId) {
-          await this.gateway?.sendText(message.chatId, "\u8865\u5145\u5185\u5BB9\u5DF2\u8F93\u5165\uFF0C\u4F46\u7EC8\u7AEF\u4ECD\u505C\u7559\u5728\u539F\u95EE\u9898\uFF0C\u8BF7\u7528 /tail \u68C0\u67E5\u3002");
+          await this.gateway?.sendText(message2.chatId, "\u8865\u5145\u5185\u5BB9\u5DF2\u8F93\u5165\uFF0C\u4F46\u7EC8\u7AEF\u4ECD\u505C\u7559\u5728\u539F\u95EE\u9898\uFF0C\u8BF7\u7528 /tail \u68C0\u67E5\u3002");
           return;
         }
         const content = `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u8865\u5145\u5185\u5BB9\u3002`;
@@ -3205,12 +3709,12 @@ ${escapeFence2(output).slice(-6800)}
       }
       if (pendingInput.role === "custom-input") {
         const refreshed = await this.withInteractionNotificationsSuppressed(async () => {
-          await this.waitForCustomInputValue(pendingInput.interactionId, pendingInput.controlId, message.content);
+          await this.waitForCustomInputValue(pendingInput.interactionId, pendingInput.controlId, message2.content);
           const current = this.screen;
           if (current?.interaction?.semantics && (current.interaction.actionConfidence ?? 0) >= 0.85) {
             await this.gateway?.updateChoice(
               pendingInput.cardMessageId,
-              message.chatId,
+              message2.chatId,
               session.paneId,
               current,
               session.agent
@@ -3221,43 +3725,43 @@ ${escapeFence2(output).slice(-6800)}
         });
         if (refreshed) return;
       }
-      await this.gateway?.sendText(message.chatId, `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u8865\u5145\u5185\u5BB9\u3002`);
+      await this.gateway?.sendText(message2.chatId, `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u8865\u5145\u5185\u5BB9\u3002`);
       return;
     }
-    await this.gateway?.startProcessing(message);
+    await this.gateway?.startProcessing(message2);
     await this.poll();
     if (this.shouldQueueMessage()) {
       if (this.pendingMessages.length >= 100) {
-        await this.gateway?.sendText(message.chatId, "\u5F85\u53D1\u9001\u961F\u5217\u5DF2\u6EE1\uFF0C\u8BF7\u5148\u5904\u7406\u5F53\u524D\u7EC8\u7AEF\u72B6\u6001\u3002");
+        await this.gateway?.sendText(message2.chatId, "\u5F85\u53D1\u9001\u961F\u5217\u5DF2\u6EE1\uFF0C\u8BF7\u5148\u5904\u7406\u5F53\u524D\u7EC8\u7AEF\u72B6\u6001\u3002");
         return;
       }
-      this.pendingMessages.push(message.content);
-      await this.gateway?.sendText(message.chatId, `\u5F53\u524D\u7EC8\u7AEF\u6682\u4E0D\u53EF\u5B89\u5168\u5199\u5165\uFF0C\u6D88\u606F\u5DF2\u6392\u961F\uFF08${this.pendingMessages.length} \u6761\uFF09\u3002`);
+      this.pendingMessages.push(message2.content);
+      await this.gateway?.sendText(message2.chatId, `\u5F53\u524D\u7EC8\u7AEF\u6682\u4E0D\u53EF\u5B89\u5168\u5199\u5165\uFF0C\u6D88\u606F\u5DF2\u6392\u961F\uFF08${this.pendingMessages.length} \u6761\uFF09\u3002`);
       return;
     }
-    const result2 = await this.send(message.content);
-    if (!result2.ok) await this.gateway?.sendText(message.chatId, `\u672A\u53D1\u9001\uFF1A${result2.error}`);
+    const result2 = await this.send(message2.content);
+    if (!result2.ok) await this.gateway?.sendText(message2.chatId, `\u672A\u53D1\u9001\uFF1A${result2.error}`);
   }
-  async handleAttach(message, code) {
-    if (this.state.ownerOpenId && message.senderId !== this.state.ownerOpenId) return;
-    if (!this.allowAttachAttempt(message.senderId)) return;
+  async handleAttach(message2, code) {
+    if (this.state.ownerOpenId && message2.senderId !== this.state.ownerOpenId) return;
+    if (!this.allowAttachAttempt(message2.senderId)) return;
     const valid = Boolean(
       this.state.bindCodeHash && this.state.bindCodeExpiresAt && this.state.bindCodeExpiresAt >= Date.now() && verifyBindCode(code, this.state.bindCodeHash)
     );
     if (!valid) {
-      await this.gateway?.sendText(message.chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u7ED1\u5B9A\u7801\u65E0\u6548\u6216\u5DF2\u8FC7\u671F\u3002");
+      await this.gateway?.sendText(message2.chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u7ED1\u5B9A\u7801\u65E0\u6548\u6216\u5DF2\u8FC7\u671F\u3002");
       return;
     }
-    await this.bindChat(message, false);
+    await this.bindChat(message2, false);
   }
-  canAutoBind(message) {
-    return !this.state.autoBindDisabled && Boolean(this.state.ownerOpenId) && message.senderId === this.state.ownerOpenId;
+  canAutoBind(message2) {
+    return !this.state.autoBindDisabled && Boolean(this.state.ownerOpenId) && message2.senderId === this.state.ownerOpenId;
   }
-  async bindChat(message, automatic) {
+  async bindChat(message2, automatic) {
     this.state = {
       ...this.state,
-      ownerOpenId: this.state.ownerOpenId ?? message.senderId,
-      boundChatId: message.chatId,
+      ownerOpenId: this.state.ownerOpenId ?? message2.senderId,
+      boundChatId: message2.chatId,
       autoBindDisabled: false,
       bindCodeHash: void 0,
       bindCodeExpiresAt: void 0,
@@ -3265,7 +3769,7 @@ ${escapeFence2(output).slice(-6800)}
     };
     await this.store.saveState(this.state);
     await this.gateway?.sendText(
-      message.chatId,
+      message2.chatId,
       automatic ? "\u5DF2\u81EA\u52A8\u8FDE\u63A5\u5F53\u524D coding agent \u4F1A\u8BDD\u3002\u4E4B\u540E\u76F4\u63A5\u53D1\u9001\u666E\u901A\u6D88\u606F\u5373\u53EF\u3002" : "\u7ED1\u5B9A\u6210\u529F\u3002\u4E4B\u540E\u7684\u666E\u901A\u6D88\u606F\u4F1A\u53D1\u9001\u5230\u5F53\u524D tmux \u4E2D\u7684 coding agent\uFF1B\u53EF\u7528 /tail\u3001/status\u3001/sessions\u3001/detach\u3001/stop\u3002"
     );
     this.previousScreen = void 0;
@@ -3296,7 +3800,11 @@ ${escapeFence2(output).slice(-6800)}
     }
     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 === "create") return {
+        type: "session-create-form",
+        content: "\u8BF7\u586B\u5199\u542F\u52A8\u4FE1\u606F\u3002",
+        view: await this.createSessionWorkspaceView(event.chatId)
+      };
       if (action.action === "sessions") {
         await this.reconcileSessions(true);
         return this.sessionPickerActionResult("\u5DF2\u53D1\u9001\u6700\u65B0 Sessions\u3002");
@@ -3310,15 +3818,53 @@ ${escapeFence2(output).slice(-6800)}
         return {
           type: "session-create-form",
           content: "\u8BF7\u586B\u5199\u542F\u52A8\u4FE1\u606F\u3002",
+          view: await this.createSessionWorkspaceView(event.chatId),
           sessions: Object.values(this.state.sessions ?? {}),
           activeSessionId: this.state.activeSessionId
         };
       }
-      if (action.action !== "submit" || !event.action.formValue) {
+      const snapshot = action.snapshotId ? this.workspaceSnapshots.get(action.snapshotId, event.chatId, event.operator.openId) : void 0;
+      if (!snapshot && action.snapshotId) {
+        return {
+          type: "session-create-form",
+          content: "\u9879\u76EE\u76EE\u5F55\u5217\u8868\u5DF2\u8FC7\u671F\uFF0C\u5DF2\u91CD\u65B0\u52A0\u8F7D\u3002",
+          view: await this.createSessionWorkspaceView(event.chatId)
+        };
+      }
+      if (action.action !== "submit") return { type: "error", content: "\u65E0\u6CD5\u8BC6\u522B\u65B0\u5EFA Session \u64CD\u4F5C\u3002" };
+      if (!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 submittedResumeMode = formString(event.action.formValue[SESSION_CREATE_RESUME_FIELD]) || "new";
+      if (submittedResumeMode === "last") {
+        return { type: "error", content: "\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 (submittedResumeMode !== "new" && submittedResumeMode !== "picker") {
+        return { type: "error", content: "\u65E0\u6CD5\u8BC6\u522B\u542F\u52A8\u65B9\u5F0F\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u65B0\u5EFA Session \u8868\u5355\u3002" };
+      }
+      const submittedAgent = formString(event.action.formValue[SESSION_CREATE_AGENT_FIELD]);
+      if (!normalizeAgentId(submittedAgent)) {
+        return { type: "error", content: "\u8BF7\u9009\u62E9\u6709\u6548\u7684 Agent\uFF1Acodex\u3001traex \u6216 claude\u3002" };
+      }
+      const draft = sessionCreateDraftFromForm(event.action.formValue);
+      const submittedProject = formString(event.action.formValue[SESSION_CREATE_PROJECT_FIELD]);
+      const manualForm = action.fingerprint === "manual";
+      const selectedProject = submittedProject !== SESSION_CREATE_MANUAL_VALUE ? submittedProject : "";
+      if (selectedProject && !manualForm && (!snapshot || !snapshot.candidates.some((candidate) => candidate.cwd === selectedProject))) {
+        return {
+          type: "session-create-form",
+          content: "\u9879\u76EE\u76EE\u5F55\u5217\u8868\u5DF2\u53D8\u5316\uFF0C\u5DF2\u91CD\u65B0\u52A0\u8F7D\u3002",
+          view: await this.createSessionWorkspaceView(event.chatId)
+        };
+      }
+      const request = startRequestFromDraft(draft);
+      if (!request.ok) {
+        return {
+          type: "session-create-form",
+          content: request.error,
+          view: this.sessionCreateRetryView(snapshot, draft)
+        };
+      }
       const result3 = await this.startRemoteSession(request.value);
       if (!result3.ok) return larkStartupError(result3.error, request.value);
       if (result3.state === "picker") {
@@ -3492,21 +4038,42 @@ ${escapeFence2(output).slice(-6800)}
     const optionId = action.action.startsWith("select:") ? action.action.slice("select:".length) : "";
     const option2 = picker.options.find((candidate) => candidate.id === optionId);
     if (!option2) return { type: "resume-picker", content: "\u6240\u9009\u9879\u5DF2\u53D8\u5316\uFF0C\u5DF2\u5237\u65B0\u3002", session, picker };
-    const delta = option2.visibleIndex - picker.selectedIndex;
-    const key = delta < 0 ? "Up" : "Down";
-    for (let step = 0; step < Math.abs(delta); step += 1) await this.tmux.sendKey(session.paneId, key);
-    const pane = await this.tmux.inspect(session.paneId);
-    if (!pane || pane.dead) {
-      this.pendingResumePickers.delete(sessionId);
-      return larkStartupError(fail(await this.startupExitedError(session, pane)), request);
-    }
-    await this.tmux.sendKey(session.paneId, "Enter");
-    this.pendingResumePickers.delete(sessionId);
-    const claimed = await this.waitForInitialAgentSessionClaim(sessionId, pane.pid);
-    if (!claimed.ok) {
-      await this.stopSession(sessionId).catch(() => void 0);
-      if (claimed.errorCode === "AGENT_SESSION_IN_USE") {
-        const ownerSessionId = typeof claimed.errorContext?.ownerSessionId === "string" ? claimed.errorContext.ownerSessionId : void 0;
+    const restored = await this.sessionStarts.run(
+      { sessionId, agent: session.agent, cwd: session.cwd, resume: request.resume, source: "resume-picker" },
+      async (context) => {
+        const restoringSession = { ...session };
+        const delta = option2.visibleIndex - picker.selectedIndex;
+        const key = delta < 0 ? "Up" : "Down";
+        await context.stage("resume-selection", async () => {
+          for (let step = 0; step < Math.abs(delta); step += 1) {
+            await this.tmux.sendKey(session.paneId, key, context.signal);
+          }
+          const pane = await this.tmux.inspect(session.paneId, context.signal);
+          if (!pane || pane.dead) throw await this.startupExitedError(session, pane);
+          await this.tmux.sendKey(session.paneId, "Enter", context.signal);
+          this.pendingResumePickers.delete(sessionId);
+          const claimed = await this.waitForInitialAgentSessionClaim(restoringSession, pane.pid, context.signal);
+          if (!claimed.ok) throw daemonResultAppError(claimed);
+          if (restoringSession.agentSessionId) {
+            const persisted = await this.handleAgentSessionStarted({
+              sessionId,
+              agent: session.agent,
+              agentSessionId: restoringSession.agentSessionId,
+              cwd: session.cwd,
+              source: "resume-picker"
+            });
+            if (!persisted.ok) throw daemonResultAppError(persisted);
+          }
+          await this.tmux.preserveOnExit(session.sessionName, false, context.signal);
+        });
+        return session;
+      },
+      async (_context, error) => this.cleanupStartTransaction(sessionId, session.sessionName, error)
+    );
+    if (!restored.ok) {
+      const failed = fail(restored.error);
+      if (restored.error.code === "AGENT_SESSION_IN_USE") {
+        const ownerSessionId = typeof restored.error.context.ownerSessionId === "string" ? restored.error.context.ownerSessionId : void 0;
         const owner = ownerSessionId ? this.state.sessions?.[ownerSessionId] : void 0;
         if (owner) {
           this.pendingStartupConflicts.set(sessionId, { request, ownerSessionId: owner.id });
@@ -3518,17 +4085,17 @@ ${escapeFence2(output).slice(-6800)}
           };
         }
       }
-      return larkStartupError(claimed, request);
+      return larkStartupError(failed, request);
     }
-    await this.tmux.preserveOnExit(session.sessionName, false).catch(() => void 0);
     const selected = await this.useSession(sessionId);
     if (!selected.ok) return { type: "error", content: remoteError(selected) };
+    await this.rememberSessionWorkspace(session.cwd);
     return { type: "session-created", content: remoteStartSuccess(session), session };
   }
-  async readResumePicker(session) {
-    const pane = await this.tmux.inspect(session.paneId);
+  async readResumePicker(session, signal) {
+    const pane = await this.tmux.inspect(session.paneId, signal);
     if (!pane || pane.dead) return void 0;
-    const raw = await this.tmux.capture(session.paneId, 120).catch(() => "");
+    const raw = await this.tmux.capture(session.paneId, 120, signal).catch(() => "");
     return parseResumePicker(raw, session.agent);
   }
   async handleResumePickerDeliveryFailure(candidate) {
@@ -3537,13 +4104,14 @@ ${escapeFence2(output).slice(-6800)}
     await this.log(`resume picker delivery failed; rolling back provisional session: session=${candidate.id} pane=${candidate.paneId}`);
     await this.stopSession(candidate.id);
   }
-  async waitForResumePicker(session, previousFingerprint, timeoutMs = 2500) {
+  async waitForResumePicker(session, previousFingerprint, timeoutMs = 2500, signal) {
     const deadline = Date.now() + timeoutMs;
     let latest;
     while (Date.now() < deadline) {
-      latest = await this.readResumePicker(session);
+      if (signal?.aborted) throw signal.reason;
+      latest = await this.readResumePicker(session, signal);
       if (latest && (!previousFingerprint || latest.fingerprint !== previousFingerprint)) return latest;
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await abortableDelay(100, signal);
     }
     return latest;
   }
@@ -3556,7 +4124,7 @@ ${escapeFence2(output).slice(-6800)}
     let previousFingerprint;
     const deadline = Date.now() + 900;
     do {
-      await new Promise((resolve) => setTimeout(resolve, 120));
+      await new Promise((resolve2) => setTimeout(resolve2, 120));
       await this.poll();
       const fingerprint = this.screen?.fingerprint;
       if (fingerprint && fingerprint === previousFingerprint) return;
@@ -3584,7 +4152,7 @@ ${escapeFence2(output).slice(-6800)}
     }
     try {
       await execute(session);
-      await new Promise((resolve) => setTimeout(resolve, 120));
+      await new Promise((resolve2) => setTimeout(resolve2, 120));
       await this.poll();
       const output = this.screen ? tailScreen(this.screen.normalized, 60) : "\u65E0\u6CD5\u8BFB\u53D6\u6700\u65B0\u7EC8\u7AEF\u753B\u9762\u3002";
       await this.gateway?.sendMarkdown(chatId, `**\u624B\u52A8\u64CD\u4F5C\uFF1A${operation}**
@@ -3635,7 +4203,7 @@ ${escapeFence2(output).slice(-6500)}
       };
     }
     if (target?.role === "custom-input" || target?.role === "chat") {
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
       await this.poll();
       if (!before?.interactionId) return { type: "error", content: "\u65E0\u6CD5\u786E\u8BA4\u5F53\u524D\u4EA4\u4E92\uFF0C\u8BF7\u7528 /tail \u68C0\u67E5\u3002" };
       this.pendingInteractionInput = {
@@ -3768,7 +4336,7 @@ ${escapeFence2(output).slice(-6500)}
       if (focusedIndex === targetIndex) return { ok: true };
       const direction = targetIndex > focusedIndex ? "Down" : "Up";
       await this.tmux.sendKey(paneId, direction);
-      await new Promise((resolve) => setTimeout(resolve, 40));
+      await new Promise((resolve2) => setTimeout(resolve2, 40));
       await this.poll();
       const nextFocused = this.screen?.actions.findIndex(({ focused }) => focused) ?? -1;
       if (nextFocused === focusedIndex) return { ok: false, error: "terminal focus did not move as expected" };
@@ -3778,7 +4346,7 @@ ${escapeFence2(output).slice(-6500)}
   async waitForInteractionChange(interactionId) {
     const deadline = Date.now() + 1500;
     while (Date.now() < deadline) {
-      await new Promise((resolve) => setTimeout(resolve, 75));
+      await new Promise((resolve2) => setTimeout(resolve2, 75));
       await this.poll();
       const current = this.screen?.interaction;
       if (!current || current.interactionId !== interactionId) return;
@@ -3787,7 +4355,7 @@ ${escapeFence2(output).slice(-6500)}
   async waitForControlMarker(interactionId, controlId, marker) {
     const deadline = Date.now() + 1500;
     while (Date.now() < deadline) {
-      await new Promise((resolve) => setTimeout(resolve, 75));
+      await new Promise((resolve2) => setTimeout(resolve2, 75));
       await this.poll();
       const current = this.screen?.interaction;
       const control = this.screen?.actions.find(({ id }) => id === controlId);
@@ -3798,7 +4366,7 @@ ${escapeFence2(output).slice(-6500)}
     const expected = input.trim();
     const deadline = Date.now() + 1500;
     while (Date.now() < deadline) {
-      await new Promise((resolve) => setTimeout(resolve, 75));
+      await new Promise((resolve2) => setTimeout(resolve2, 75));
       await this.poll();
       const control = this.screen?.actions.find(({ id }) => id === controlId);
       if (this.screen?.interaction?.interactionId === interactionId && control?.inputValue && (control.inputValue === expected || expected.startsWith(control.inputValue))) return;
@@ -3843,7 +4411,7 @@ ${escapeFence2(output).slice(-6500)}
       if (!navigation.ok) return navigation;
       if (desired.editor) {
         if (desired.editor.openKey) await this.tmux.sendKey(paneId, desired.editor.openKey);
-        await new Promise((resolve) => setTimeout(resolve, 100));
+        await new Promise((resolve2) => setTimeout(resolve2, 100));
         await this.tmux.sendKey(paneId, "C-u");
         await this.tmux.sendKey(paneId, "C-k");
         await this.tmux.sendText(paneId, desired.input, false);
@@ -3861,7 +4429,7 @@ ${escapeFence2(output).slice(-6500)}
     }
     return { ok: true, committed: false };
   }
-  async stopSession(sessionId = this.state.activeSessionId) {
+  async stopSession(sessionId = this.state.activeSessionId, signal) {
     if (!sessionId) {
       return fail(new AppError("SESSION_NOT_FOUND", "no active managed session", { sessionId: "default" }));
     }
@@ -3869,9 +4437,11 @@ ${escapeFence2(output).slice(-6500)}
     if (!session) {
       return fail(new AppError("SESSION_NOT_FOUND", `unknown session: ${sessionId}`, { sessionId }));
     }
-    if (await this.tmux.hasSession(session.sessionName)) {
-      await this.tmux.killSession(session.sessionName);
-    }
+    await this.tmux.killSession(session.sessionName, signal);
+    await this.forgetSessionState(sessionId);
+    return { ok: true };
+  }
+  async forgetSessionState(sessionId) {
     const sessions = { ...this.state.sessions };
     delete sessions[sessionId];
     this.pendingResumePickers.delete(sessionId);
@@ -3898,7 +4468,6 @@ ${escapeFence2(output).slice(-6500)}
       this.unresolvedNotified.clear();
     }
     await this.store.saveState(this.state);
-    return { ok: true };
   }
   async resetOwner() {
     this.pendingMessages.length = 0;
@@ -4107,37 +4676,75 @@ ${escapeFence2(output).slice(-6500)}
       });
     }
   }
-  async waitForInitialAgentSessionClaim(sessionId, panePid) {
+  async waitForInitialAgentSessionClaim(session, panePid, signal) {
     const deadline = Date.now() + 3500;
     while (Date.now() < deadline) {
-      const session2 = this.state.sessions?.[sessionId];
-      if (!session2) return { ok: false, error: `session disappeared during startup: ${sessionId}` };
-      if (session2.agentSessionId) return { ok: true };
-      const pane2 = await this.tmux.inspect(session2.paneId);
-      if (!pane2 || pane2.dead) return fail(await this.startupExitedError(session2, pane2));
-      const agentSessionId = await resolveNativeAgentSessionId(session2.agent, panePid).catch(() => void 0);
+      if (session.agentSessionId) return { ok: true };
+      const committedClaim2 = this.state.sessions?.[session.id]?.agentSessionId;
+      if (committedClaim2) {
+        session.agentSessionId = committedClaim2;
+        return { ok: true };
+      }
+      const pending2 = this.pendingAgentSessionClaims.get(session.id);
+      if (pending2) {
+        const claimed = this.claimStartingAgentSession(session, pending2);
+        if (!claimed.ok || session.agentSessionId) return claimed;
+      }
+      if (signal?.aborted) throw signal.reason;
+      const pane2 = await this.tmux.inspect(session.paneId, signal);
+      if (signal?.aborted) throw signal.reason;
+      if (!pane2 || pane2.dead) return fail(await this.startupExitedError(session, pane2));
+      const agentSessionId = await resolveNativeAgentSessionId(
+        session.agent,
+        panePid,
+        void 0,
+        signal
+      ).catch(() => void 0);
       if (agentSessionId) {
-        return this.handleAgentSessionStarted({
-          sessionId,
-          agent: session2.agent,
+        return this.claimStartingAgentSession(session, {
+          sessionId: session.id,
+          agent: session.agent,
           agentSessionId,
-          cwd: session2.cwd,
+          cwd: session.cwd,
           source: "startup-discovery"
         });
       }
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await abortableDelay(100, signal);
     }
-    const session = this.state.sessions?.[sessionId];
-    if (!session) return fail(new AppError("SESSION_NOT_FOUND", `session disappeared during startup: ${sessionId}`, { sessionId }));
-    const pane = await this.tmux.inspect(session.paneId);
+    const pane = await this.tmux.inspect(session.paneId, signal);
+    if (signal?.aborted) throw signal.reason;
     if (!pane || pane.dead) return fail(await this.startupExitedError(session, pane));
-    if (session.agentSessionId || this.pendingAgentSessionClaims.has(sessionId)) return { ok: true };
+    const pending = this.pendingAgentSessionClaims.get(session.id);
+    if (pending) return this.claimStartingAgentSession(session, pending);
+    const committedClaim = this.state.sessions?.[session.id]?.agentSessionId;
+    if (committedClaim) {
+      session.agentSessionId = committedClaim;
+      return { ok: true };
+    }
+    if (session.agentSessionId) return { ok: true };
     return fail(new AppError(
       "AGENT_IDENTITY_TIMEOUT",
-      `unable to identify resumed native session: ${sessionId}`,
-      { sessionId, agent: session.agent }
+      `unable to identify resumed native session: ${session.id}`,
+      { sessionId: session.id, agent: session.agent }
     ));
   }
+  claimStartingAgentSession(session, candidate) {
+    if (candidate.agent !== session.agent) {
+      return fail(new AppError("START_FAILED", "agent-session candidate does not match starting session", {
+        sessionId: session.id,
+        agent: session.agent
+      }));
+    }
+    const owner = this.findAgentSessionOwner(candidate.agent, candidate.agentSessionId, session.id);
+    if (owner) {
+      this.pendingAgentSessionClaims.delete(session.id);
+      return fail(agentSessionInUse(session.id, owner.id));
+    }
+    session.agentSessionId = candidate.agentSessionId;
+    session.updatedAt = Date.now();
+    this.pendingAgentSessionClaims.delete(session.id);
+    return { ok: true };
+  }
   async startupExitedError(session, pane) {
     const terminalTail = await this.tmux.capture(session.paneId, 40).then((output) => tailScreen(output, 40).slice(-3e3)).catch(() => "");
     return new AppError(
@@ -4151,12 +4758,14 @@ ${escapeFence2(output).slice(-6500)}
       }
     );
   }
-  async waitForStartupStability(session, durationMs) {
+  async waitForStartupStability(session, durationMs, signal) {
     const deadline = Date.now() + durationMs;
     while (Date.now() < deadline) {
-      const pane = await this.tmux.inspect(session.paneId);
+      if (signal?.aborted) throw signal.reason;
+      const pane = await this.tmux.inspect(session.paneId, signal);
+      if (signal?.aborted) throw signal.reason;
       if (!pane || pane.dead) return fail(await this.startupExitedError(session, pane));
-      await new Promise((resolve) => setTimeout(resolve, 80));
+      await abortableDelay(80, signal);
     }
     return { ok: true };
   }
@@ -4219,13 +4828,13 @@ ${output}`
     const session = this.activeSession();
     if (!session || this.shouldQueueMessage()) return;
     while (this.pendingMessages.length > 0 && !this.shouldQueueMessage()) {
-      const message = this.pendingMessages[0];
-      if (!message) {
+      const message2 = this.pendingMessages[0];
+      if (!message2) {
         this.pendingMessages.shift();
         continue;
       }
       this.clearPendingCompletion();
-      await this.tmux.sendText(session.paneId, message);
+      await this.tmux.sendText(session.paneId, message2);
       this.pendingMessages.shift();
     }
     if (this.pendingMessages.length === 0 && this.state.boundChatId) {
@@ -4234,9 +4843,9 @@ ${output}`
   activeSession() {
     return this.state.activeSessionId ? this.state.sessions?.[this.state.activeSessionId] : void 0;
   }
-  async reconcileSessions(discover = false) {
+  async reconcileSessions(discover = false, signal) {
     const previousActive = this.state.activeSessionId;
-    const result2 = await this.reconciler.reconcile(this.state, discover);
+    const result2 = await this.reconciler.reconcile(this.state, discover, signal);
     if (!result2.changed) return result2.liveSessions;
     const activeChanged = result2.state.activeSessionId !== previousActive;
     if (result2.removedActive) {
@@ -4293,7 +4902,7 @@ ${output}`
     await this.log(
       `remote session create requested: session=${request.sessionId} agent=${request.agent} resume=${request.resume?.mode ?? "new"}`
     );
-    const started = await this.startSession(request.sessionId, request.cwd, request.agent, request.resume);
+    const started = await this.startSession(request.sessionId, request.cwd, request.agent, request.resume, "lark");
     if (!started.ok) {
       await this.log(`remote session create failed: session=${request.sessionId} code=${started.errorCode ?? "UNKNOWN"}`);
       if (started.errorCode === "AGENT_SESSION_IN_USE") {
@@ -4313,7 +4922,7 @@ ${output}`
     }
     const session = selected.value;
     if (request.resume?.mode === "picker") {
-      const picker = await this.waitForResumePicker(session);
+      const picker = started.value.resumePicker;
       if (picker) {
         this.pendingResumePickers.set(session.id, request);
         return { ok: true, state: "picker", session, picker };
@@ -4324,14 +4933,97 @@ ${output}`
     }
     return { ok: true, state: "ready", session };
   }
-  async log(message) {
-    await appendFile(this.paths.logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
+  async createSessionWorkspaceView(chatId, draft = emptySessionCreateDraft()) {
+    await this.reconcileSessions(true);
+    const latestConfig = await this.store.loadConfig();
+    const discovered = await discoverWorkspaces({
+      workspaceRoots: latestConfig?.workspaceRoots ?? this.config.workspaceRoots,
+      activeSessions: Object.values(this.state.sessions ?? {}),
+      recentWorkspaces: this.state.recentWorkspaces ?? []
+    });
+    for (const warning of discovered.warnings) await this.log(`workspace discovery warning: ${warning}`);
+    const snapshot = this.workspaceSnapshots.create({
+      chatId,
+      ownerOpenId: this.state.ownerOpenId ?? "",
+      candidates: discovered.candidates,
+      warnings: discovered.warnings,
+      partial: discovered.partial
+    });
+    return discovered.candidates.length > 0 ? this.sessionWorkspaceView(snapshot, draft) : this.manualSessionCreateView(snapshot, draft);
+  }
+  sessionWorkspaceView(snapshot, draft) {
+    const visibleCandidates = snapshot.candidates.slice(0, 99);
+    return {
+      mode: "projects",
+      snapshotId: snapshot.id,
+      page: 0,
+      pageCount: 1,
+      hasProjectCandidates: snapshot.candidates.length > 0,
+      candidates: visibleCandidates,
+      warnings: snapshot.warnings,
+      partial: snapshot.partial || visibleCandidates.length < snapshot.candidates.length,
+      draft
+    };
+  }
+  sessionCreateRetryView(snapshot, draft) {
+    return snapshot && snapshot.candidates.length > 0 ? this.sessionWorkspaceView(snapshot, draft) : this.manualSessionCreateView(snapshot, draft);
+  }
+  manualSessionCreateView(snapshot, draft, requestedPage = 0) {
+    const pageCount = Math.max(1, Math.ceil((snapshot?.candidates.length ?? 0) / 20));
+    const page = Math.max(0, Math.min(pageCount - 1, requestedPage));
+    const noCandidates = snapshot && snapshot.candidates.length === 0 ? ["\u5C1A\u672A\u53D1\u73B0\u53EF\u9009\u9879\u76EE\uFF1B\u8BF7\u624B\u52A8\u586B\u5199\u8DEF\u5F84\uFF0C\u6216\u5728\u672C\u673A\u8FD0\u884C lca workspace add ~/workspace\u3002"] : [];
+    return {
+      mode: "manual",
+      snapshotId: snapshot?.id,
+      page,
+      hasProjectCandidates: (snapshot?.candidates.length ?? 0) > 0,
+      pageCount,
+      candidates: [],
+      warnings: [...snapshot?.warnings ?? [], ...noCandidates],
+      partial: snapshot?.partial ?? false,
+      draft: { ...draft, manualCwd: draft.manualCwd ?? (draft.cwd !== SESSION_CREATE_MANUAL_VALUE ? draft.cwd : void 0) }
+    };
+  }
+  async rememberSessionWorkspace(cwd) {
+    this.state = {
+      ...this.state,
+      recentWorkspaces: rememberRecentWorkspace(this.state.recentWorkspaces, cwd),
+      updatedAt: Date.now()
+    };
+    await this.store.saveState(this.state).catch((error) => this.log(
+      `failed to persist recent workspace: cwd=${cwd} error=${errorMessage3(error)}`
+    ));
+  }
+  async log(message2) {
+    await appendFile(this.paths.logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${message2}
 `, { mode: 384 });
   }
 };
 function fail(error) {
   return { ok: false, ...serializeAppError(error) };
 }
+function daemonResultAppError(result2) {
+  return new AppError(
+    result2.errorCode ?? "START_FAILED",
+    result2.error,
+    result2.errorContext ?? {}
+  );
+}
+function abortableDelay(ms, signal) {
+  if (!signal) return new Promise((resolve2) => setTimeout(resolve2, ms));
+  if (signal.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", aborted);
+      resolve2();
+    }, ms);
+    const aborted = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", aborted, { once: true });
+  });
+}
 function agentSessionInUse(sessionId, ownerSessionId) {
   return new AppError(
     "AGENT_SESSION_IN_USE",
@@ -4361,24 +5053,29 @@ function remember(values, value, limit) {
     values.delete(oldest);
   }
 }
-function startRequestFromForm(values) {
+function sessionCreateDraftFromForm(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 projectCwd = formString(values[SESSION_CREATE_PROJECT_FIELD]);
+  const manualCwd = formString(values[SESSION_CREATE_CWD_FIELD]);
   const resumeMode = formString(values[SESSION_CREATE_RESUME_FIELD]) || "new";
+  const cwd = projectCwd === SESSION_CREATE_MANUAL_VALUE ? manualCwd : projectCwd || manualCwd;
+  return {
+    sessionId: sessionId || void 0,
+    agent: normalizeAgentId(agentValue) ?? "codex",
+    resumeMode: resumeMode === "picker" ? "picker" : "new",
+    cwd: cwd || void 0,
+    projectCwd: projectCwd || void 0,
+    manualCwd: manualCwd || void 0
+  };
+}
+function startRequestFromDraft(draft) {
+  const sessionId = draft.sessionId?.trim() ?? "";
   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" };
+  if (!draft.cwd || draft.cwd === SESSION_CREATE_MANUAL_VALUE) return { ok: false, error: "\u8BF7\u9009\u62E9\u6216\u586B\u5199\u9879\u76EE\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 } };
+  if (draft.resumeMode === "picker") resume = { mode: "picker" };
+  return { ok: true, value: { sessionId, agent: draft.agent, cwd: draft.cwd, resume } };
 }
 function formString(value) {
   if (typeof value === "string") return value.trim();
@@ -4400,7 +5097,22 @@ function remoteError(result2) {
   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`;
+      return context.source === "tmux" ? `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\uFF1A\u68C0\u6D4B\u5230\u540C\u540D tmux \u4F1A\u8BDD\uFF0C\u4F46\u5B83\u672A\u767B\u8BB0\u4E3A\u53EF\u8FDE\u63A5\u7684 LCA session\u3002\u8BF7\u6362\u4E00\u4E2A\u540D\u79F0\uFF0C\u6216\u5728\u672C\u673A\u68C0\u67E5 tmux \u4F1A\u8BDD\u3002` : `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\uFF1A\u8BE5 session \u5DF2\u5728\u8FD0\u884C\u3002\u8BF7\u6362\u4E00\u4E2A\u540D\u79F0\uFF0C\u6216\u7528 /sessions \u8FDE\u63A5\u73B0\u6709 session\u3002`;
+    case "SESSION_STARTING":
+      return `session\u300C${sessionId}\u300D\u6B63\u5728\u542F\u52A8\uFF0C\u8BF7\u7B49\u5F85\u5F53\u524D\u64CD\u4F5C\u5B8C\u6210\u540E\u518D\u8BD5\u3002`;
+    case "SESSION_START_TIMEOUT": {
+      const agent = typeof context.agent === "string" ? context.agent : "Agent";
+      const cwd = typeof context.cwd === "string" ? context.cwd : "\u672A\u77E5\u76EE\u5F55";
+      const stage = typeof context.stage === "string" ? context.stage : "unknown";
+      const excerpt = typeof context.terminalExcerpt === "string" && context.terminalExcerpt.trim() ? `
+
+\u6700\u8FD1\u7EC8\u7AEF\u8F93\u51FA\uFF1A
+${context.terminalExcerpt}` : "";
+      return `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\uFF1A${agent} \u542F\u52A8\u8D85\u8FC7 30 \u79D2\uFF0C\u5DF2\u53D6\u6D88\u5E76\u6E05\u7406\u3002
+
+\u5DE5\u4F5C\u76EE\u5F55\uFF1A${cwd}
+\u8D85\u65F6\u9636\u6BB5\uFF1A${stage}${excerpt}`;
+    }
     case "AGENT_SESSION_IN_USE": {
       const ownerSessionId = typeof context.ownerSessionId === "string" ? context.ownerSessionId : "\u73B0\u6709 session";
       return `\u65E0\u6CD5\u542F\u52A8 session\u300C${sessionId}\u300D\uFF1A\u8BE5 Agent \u539F\u751F session \u5DF2\u7531 LCA session\u300C${ownerSessionId}\u300D\u8FDE\u63A5\u3002\u8BF7\u7528 /sessions \u8FDE\u63A5\u73B0\u6709 session\u3002`;
@@ -4476,20 +5188,20 @@ function manualTimestamp() {
 }
 
 // src/core/paths.ts
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join3 } from "path";
 function resolveAppPaths(root = process.env.LARK_CODING_ASSISTANT_HOME) {
-  const base = root || join2(homedir2(), ".lark-coding-assistant");
+  const base = root || join3(homedir4(), ".lark-coding-assistant");
   return {
     root: base,
-    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")
+    config: join3(base, "config.json"),
+    secrets: join3(base, "secrets.json"),
+    state: join3(base, "state.json"),
+    logsDir: join3(base, "logs"),
+    logFile: join3(base, "logs", "assistant.log"),
+    runtimeDir: join3(base, "runtime"),
+    socket: join3(base, "runtime", "daemon.sock"),
+    pid: join3(base, "runtime", "daemon.pid")
   };
 }