lark-coding-assistant 0.1.1

package/dist/daemon-entry.js

@@ -0,0 +1,2794 @@
+// src/daemon/server.ts
+import { appendFile, chmod as chmod3, open as open2, readFile as readFile2, rm } from "fs/promises";
+import { createServer } from "net";
+
+// src/platform/process.ts
+import { execFile, spawn } from "child_process";
+function runFile(file, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      file,
+      [...args],
+      {
+        cwd: options.cwd,
+        timeout: options.timeoutMs ?? 1e4,
+        encoding: "utf8",
+        maxBuffer: 4 * 1024 * 1024
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(Object.assign(error, { stdout, stderr }));
+          return;
+        }
+        resolve({ stdout, stderr });
+      }
+    );
+  });
+}
+function runFileWithInput(file, args, input) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, [...args], { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => stdout += chunk);
+    child.stderr.on("data", (chunk) => stderr += chunk);
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (code === 0) resolve({ stdout, stderr });
+      else reject(new Error(`${file} exited with ${code ?? signal}: ${stderr.trim()}`));
+    });
+    child.stdin.end(input, "utf8");
+  });
+}
+
+// src/screen/normalize.ts
+var ANSI = /\u001b(?:\][^\u0007]*(?:\u0007|\u001b\\)|\[[0-?]*[ -/]*[@-~]|[@-_])/g;
+function stripAnsi(raw) {
+  return raw.replace(ANSI, "");
+}
+function normalizeScreen(raw) {
+  return stripAnsi(raw).replace(/\r/g, "").split("\n").map((line) => line.replace(/\u00a0|\u3000/g, " ").replace(/\t/g, "  ").replace(/ +$/g, "")).filter((line, index, all) => line !== "" || all[index - 1] !== "").join("\n").trim();
+}
+function tailScreen(raw, lines = 60) {
+  return normalizeScreen(raw).split("\n").slice(-lines).join("\n");
+}
+
+// src/core/store.ts
+import { randomBytes, scryptSync, timingSafeEqual } from "crypto";
+import { chmod as chmod2, mkdir as mkdir2 } from "fs/promises";
+
+// src/core/model.ts
+function emptyState(now = Date.now()) {
+  return { schemaVersion: 2, sessions: {}, updatedAt: now };
+}
+
+// src/core/atomic-json.ts
+import { chmod, mkdir, open, readFile, rename } from "fs/promises";
+import { dirname } from "path";
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function writeJsonAtomic(path, value, mode = 384) {
+  const parent = dirname(path);
+  await mkdir(parent, { recursive: true, mode: 448 });
+  await chmod(parent, 448).catch(() => void 0);
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  const file = await open(temporary, "w", mode);
+  try {
+    await file.writeFile(`${JSON.stringify(value, null, 2)}
+`, "utf8");
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  await rename(temporary, path);
+  await chmod(path, mode);
+}
+
+// src/core/store.ts
+var AppStore = class {
+  constructor(paths2) {
+    this.paths = paths2;
+  }
+  paths;
+  async ensure() {
+    await mkdir2(this.paths.root, { recursive: true, mode: 448 });
+    await mkdir2(this.paths.runtimeDir, { recursive: true, mode: 448 });
+    await mkdir2(this.paths.logsDir, { recursive: true, mode: 448 });
+    await Promise.all([
+      chmod2(this.paths.root, 448),
+      chmod2(this.paths.runtimeDir, 448),
+      chmod2(this.paths.logsDir, 448)
+    ]);
+  }
+  loadConfig() {
+    return readJson(this.paths.config);
+  }
+  saveConfig(config) {
+    return writeJsonAtomic(this.paths.config, config);
+  }
+  loadSecrets() {
+    return readJson(this.paths.secrets);
+  }
+  saveSecrets(secrets) {
+    return writeJsonAtomic(this.paths.secrets, secrets);
+  }
+  async loadState() {
+    return await readJson(this.paths.state) ?? emptyState();
+  }
+  saveState(state) {
+    return writeJsonAtomic(this.paths.state, state);
+  }
+};
+function createBindCode() {
+  return randomBytes(16).toString("base64url");
+}
+function hashBindCode(code) {
+  const salt = randomBytes(16);
+  const digest = scryptSync(code, salt, 32);
+  return `${salt.toString("base64url")}.${digest.toString("base64url")}`;
+}
+function verifyBindCode(code, encoded) {
+  const [saltText, digestText] = encoded.split(".");
+  if (!saltText || !digestText) return false;
+  const expected = Buffer.from(digestText, "base64url");
+  const actual = scryptSync(code, Buffer.from(saltText, "base64url"), expected.length);
+  return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+
+// src/tmux/controller.ts
+import { randomBytes as randomBytes2 } from "crypto";
+
+// src/tmux/input.ts
+var ANSI2 = /\u001b(?:\][^\u0007]*(?:\u0007|\u001b\\)|\[[0-?]*[ -/]*[@-~]|[@-_])/g;
+var FORBIDDEN_CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g;
+function sanitizeRemoteInput(input) {
+  return input.replace(ANSI2, "").replace(/\r\n?/g, "\n").replace(FORBIDDEN_CONTROL, "");
+}
+function assertSafeTmuxTarget(target) {
+  if (!/^%\d+$/.test(target)) throw new Error(`unsafe tmux pane target: ${target}`);
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/tmux/controller.ts
+var PANE_FORMAT = "#{session_name}	#{pane_id}	#{pane_pid}	#{pane_current_command}	#{pane_current_path}	#{pane_dead}	#{cursor_x}	#{cursor_y}";
+var TmuxController = class {
+  constructor(binary = "tmux") {
+    this.binary = binary;
+  }
+  binary;
+  writes = Promise.resolve();
+  async version() {
+    return (await runFile(this.binary, ["-V"])).stdout.trim();
+  }
+  async create(options) {
+    if (!/^[a-zA-Z0-9_-]{1,64}$/.test(options.sessionName)) {
+      throw new Error("tmux session name must contain only letters, digits, underscore, or dash");
+    }
+    if (await this.hasSession(options.sessionName)) {
+      throw new Error(`tmux session already exists: ${options.sessionName}`);
+    }
+    const environment = Object.entries(options.env ?? {}).map(([key, value]) => {
+      if (!/^[A-Z][A-Z0-9_]*$/.test(key)) throw new Error(`unsafe tmux environment key: ${key}`);
+      return `${key}=${value}`;
+    });
+    const command = [
+      ...environment.length > 0 ? ["/usr/bin/env", ...environment] : [],
+      options.binary,
+      ...options.args ?? []
+    ].map(shellQuote).join(" ");
+    await runFile(this.binary, [
+      "new-session",
+      "-d",
+      "-s",
+      options.sessionName,
+      "-c",
+      options.cwd,
+      "-x",
+      "120",
+      "-y",
+      "40",
+      command
+    ]);
+    const pane = await this.findBySession(options.sessionName);
+    if (!pane) throw new Error("tmux created a session without a discoverable pane");
+    return pane;
+  }
+  async hasSession(sessionName) {
+    try {
+      await runFile(this.binary, ["has-session", "-t", `=${sessionName}`]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async findBySession(sessionName) {
+    const { stdout } = await runFile(this.binary, [
+      "list-panes",
+      "-t",
+      `=${sessionName}`,
+      "-F",
+      PANE_FORMAT
+    ]);
+    return stdout.split("\n").map(parsePane).find(Boolean);
+  }
+  async inspect(paneId) {
+    assertSafeTmuxTarget(paneId);
+    try {
+      const { stdout } = await runFile(this.binary, [
+        "display-message",
+        "-p",
+        "-t",
+        paneId,
+        PANE_FORMAT
+      ]);
+      return parsePane(stdout.trim());
+    } catch {
+      return void 0;
+    }
+  }
+  async capture(paneId, lines = 200) {
+    assertSafeTmuxTarget(paneId);
+    const { stdout } = await runFile(this.binary, [
+      "capture-pane",
+      "-p",
+      "-J",
+      "-e",
+      "-t",
+      paneId,
+      "-S",
+      `-${Math.max(1, lines)}`
+    ]);
+    return stdout;
+  }
+  sendText(paneId, input, submit = true) {
+    assertSafeTmuxTarget(paneId);
+    const text = sanitizeRemoteInput(input);
+    if (!text.trim()) return Promise.reject(new Error("message is empty after sanitization"));
+    const operation = async () => {
+      const bufferName = `lca-${process.pid}-${randomBytes2(6).toString("hex")}`;
+      await runFileWithInput(this.binary, ["load-buffer", "-b", bufferName, "-"], text);
+      try {
+        await runFile(this.binary, ["paste-buffer", "-b", bufferName, "-d", "-t", paneId]);
+      } finally {
+        await runFile(this.binary, ["delete-buffer", "-b", bufferName]).catch(() => void 0);
+      }
+      if (submit) await runFile(this.binary, ["send-keys", "-t", paneId, "Enter"]);
+    };
+    this.writes = this.writes.then(operation, operation);
+    return this.writes;
+  }
+  async sendKey(paneId, key) {
+    assertSafeTmuxTarget(paneId);
+    if (!/^(Enter|Escape|Space|Tab|BSpace|Up|Down|Left|Right|C-c|C-u|C-k|C-Enter|[yandpcq1-9])$/.test(key)) {
+      throw new Error(`unsupported tmux key: ${key}`);
+    }
+    await runFile(this.binary, ["send-keys", "-t", paneId, key]);
+  }
+  async killSession(sessionName) {
+    await runFile(this.binary, ["kill-session", "-t", `=${sessionName}`]);
+  }
+};
+function parsePane(line) {
+  const [sessionName, paneId, pidText, currentCommand, cwd, deadText, cursorXText, cursorYText] = line.trim().split("	");
+  const pid = Number(pidText);
+  const cursorX = Number(cursorXText);
+  const cursorY = Number(cursorYText);
+  if (!sessionName || !paneId || !Number.isInteger(pid) || !currentCommand || !cwd || !Number.isInteger(cursorX) || !Number.isInteger(cursorY)) return void 0;
+  return { sessionName, paneId, pid, currentCommand, cwd, dead: deadText === "1", cursorX, cursorY };
+}
+
+// src/screen/detector.ts
+import { createHash } from "crypto";
+
+// src/screen/dialects.ts
+var commonHeaders = [
+  /^\s*(?:Would you like to|Do you want to|Approval required|Allow command|.*requires approval)/i
+];
+var commonFooters = [
+  /(?:press\s+)?enter\s+to\s+(?:confirm|submit(?:\s+answer)?|select|choose|continue)/i,
+  /esc\s+to\s+cancel.*(?:tab\s+to\s+amend|ctrl\+e\s+to\s+explain)/i
+];
+var CODEX_DIALECT = {
+  id: "codex",
+  headerPatterns: [...commonHeaders, /^\s*Question\s+\d+\/\d+/i],
+  footerPatterns: commonFooters,
+  submitControls: [/^(?:submit|confirm)$/i],
+  customInputControls: [/^(?:type something|none of the above|add notes)$/i],
+  chatControls: [/^chat about this$/i]
+};
+var TRAE_DIALECT = {
+  ...CODEX_DIALECT,
+  id: "trae-cli",
+  headerPatterns: [...commonHeaders, /^\s*Question\s+\d+\/\d+/i],
+  customInputControls: [/^(?:other|none of the above|add notes)$/i]
+};
+var CLAUDE_DIALECT = {
+  id: "claude-code",
+  headerPatterns: [
+    ...commonHeaders,
+    /^\s*(?:←\s*)?[☐☑☒]\s+.+?(?:\s+✔\s+Submit\s*→)?\s*$/i,
+    /^\s*[☐☑☒]\s+\S/
+  ],
+  footerPatterns: commonFooters,
+  footerlessChoiceHeaders: [/^ready to submit your answers\?$/i],
+  submitControls: [/^(?:submit|confirm)$/i],
+  customInputControls: [/^(?:type(?:\s+.+)?|add notes)\.?$/i, /^notes:\s*press\s+n\s+to\s+add\b/i],
+  directInputControls: [/^type(?:\s+.+)?\.?$/i],
+  customInputValuePattern: /^type\s+(.+?)\.?$/i,
+  chatControls: [/^chat about this$/i]
+};
+
+// src/screen/detector.ts
+function detectCodexScreen(raw, paneAlive = true, cursor) {
+  return detectAgentScreen(raw, paneAlive, {
+    brandPattern: /OpenAI Codex|codex/i,
+    brandEvidence: "codex",
+    failurePattern: /fatal error|panicked at|segmentation fault|codex exited/i,
+    dialect: CODEX_DIALECT
+  }, cursor);
+}
+function detectTraeScreen(raw, paneAlive = true, cursor) {
+  return detectAgentScreen(raw, paneAlive, {
+    brandPattern: /TraeCode CLI|traecli/i,
+    brandEvidence: "trae-cli",
+    failurePattern: /fatal error|panicked at|segmentation fault|traecli exited/i,
+    dialect: TRAE_DIALECT
+  }, cursor);
+}
+function detectClaudeScreen(raw, paneAlive = true, cursor) {
+  return detectAgentScreen(raw, paneAlive, {
+    brandPattern: /Claude Code/i,
+    brandEvidence: "claude-code",
+    failurePattern: /fatal error|segmentation fault|Claude Code exited/i,
+    dialect: CLAUDE_DIALECT
+  }, cursor);
+}
+function detectAgentScreen(raw, paneAlive, options, cursor) {
+  const normalized = normalizeScreen(raw);
+  const lines = normalized.split("\n").slice(-80);
+  const tail = lines.join("\n");
+  const bottom = lines.slice(-16);
+  const bottomTail = bottom.join("\n");
+  const fingerprint = createHash("sha256").update(tail).digest("hex");
+  if (!paneAlive) return result("exited", 1, normalized, fingerprint, ["pane exited"]);
+  if (options.failurePattern.test(bottomTail)) {
+    return result("failed", 0.95, normalized, fingerprint, matching(bottom, /fatal|panic|exited/i));
+  }
+  const choice = parseChoiceInteraction(lines.slice(-60), options.dialect);
+  if (choice) {
+    const choiceFingerprint = choice.interaction?.interactionId ?? createHash("sha256").update(choice.evidence.join("\n")).digest("hex");
+    return { ...choice, normalized, fingerprint: choiceFingerprint, hasDraftInput: false };
+  }
+  const inputEvidence = matching(bottom, /(?:select an option|choose one|enter your answer|provide .*input|request_user_input|do you trust|trust the contents)/i);
+  if (inputEvidence.length > 0) return result("input", 0.72, normalized, fingerprint, inputEvidence);
+  const activeRunningPattern = /(?:model:\s+loading|esc to interrupt|running\s+.+?hooks?|^\s*[•◦◆◇◈✦✻▍]?\s*(?:working|thinking|executing)(?:…|\s*\(|$))/i;
+  const activeRunningEvidence = matching(bottom, activeRunningPattern);
+  if (activeRunningEvidence.length > 0) return result("running", 0.85, normalized, fingerprint, activeRunningEvidence);
+  const runningPattern = /(?:waiting for)/i;
+  const runningEvidence = matching(bottom, runningPattern);
+  const lastRunningIndex = lastMatchingIndex(bottom, runningPattern);
+  const lastPromptIndex = lastMatchingIndex(bottom, /^\s*[›>❯]\s?/);
+  if (lastRunningIndex > lastPromptIndex) return result("running", 0.75, normalized, fingerprint, runningEvidence);
+  const promptLines = bottom.slice(-4).filter((line) => /^\s*[›>❯]\s?/.test(line));
+  if (promptLines.length > 0) {
+    const last = promptLines.at(-1) ?? "";
+    const content = last.replace(/^\s*[›>❯]\s?/, "").trim();
+    const rawPrompt = raw.split("\n").filter((line) => /^\s*[›>❯]\s?/.test(stripAnsi(line))).at(-1) ?? "";
+    const draft = content.length > 0 && !promptContentIsDim(rawPrompt) && !cursorIsAtPromptStart(rawPrompt, cursor?.x);
+    return { ...result("idle", 0.8, normalized, fingerprint, [last]), hasDraftInput: draft };
+  }
+  if (runningEvidence.length > 0) return result("running", 0.75, normalized, fingerprint, runningEvidence);
+  if (options.brandPattern.test(tail)) {
+    return result("starting", 0.55, normalized, fingerprint, [options.brandEvidence]);
+  }
+  return result("unknown", 0.2, normalized, fingerprint, []);
+}
+function cursorIsAtPromptStart(rawLine, cursorX) {
+  if (cursorX === void 0) return false;
+  const visible = stripAnsi(rawLine);
+  const marker = visible.search(/[›>❯]/);
+  if (marker === -1) return false;
+  let contentStart = marker + 1;
+  while (/\s/.test(visible[contentStart] ?? "")) contentStart += 1;
+  return cursorX === contentStart;
+}
+function promptContentIsDim(rawLine) {
+  let dim = false;
+  let visible = "";
+  const dimAt = [];
+  const sgr = /\u001b\[([0-9;]*)m/g;
+  let cursor = 0;
+  for (const match of rawLine.matchAll(sgr)) {
+    const index = match.index ?? cursor;
+    const text = rawLine.slice(cursor, index);
+    visible += text;
+    dimAt.push(...Array.from(text, () => dim));
+    const params = (match[1] || "0").split(";").map(Number);
+    if (params.includes(0)) dim = false;
+    if (params.includes(2)) dim = true;
+    if (params.includes(22)) dim = false;
+    cursor = index + match[0].length;
+  }
+  const rest = rawLine.slice(cursor);
+  visible += rest;
+  dimAt.push(...Array.from(rest, () => dim));
+  const marker = visible.search(/[›>❯]/);
+  if (marker === -1) return false;
+  let contentStart = marker + 1;
+  while (/\s/.test(visible[contentStart] ?? "")) contentStart += 1;
+  const contentEnd = visible.trimEnd().length;
+  return contentEnd > contentStart && dimAt.slice(contentStart, contentEnd).every(Boolean);
+}
+function parseChoiceInteraction(lines, dialect) {
+  const explicitFooterIndex = lastMatchingIndex(lines, new RegExp(dialect.footerPatterns.map(({ source }) => `(?:${source})`).join("|"), "i"));
+  const footerlessHeaderIndex = dialect.footerlessChoiceHeaders ? lastMatchingIndex(lines, new RegExp(dialect.footerlessChoiceHeaders.map(({ source }) => `(?:${source})`).join("|"), "i")) : -1;
+  if (explicitFooterIndex === -1 && footerlessHeaderIndex === -1) return void 0;
+  const footerIndex = explicitFooterIndex >= 0 ? explicitFooterIndex : lines.length;
+  if (explicitFooterIndex >= 0 && lines.slice(footerIndex + 1).some((line) => /^\s*[›>❯]\s?/.test(line))) return void 0;
+  const allStarts = lines.slice(0, footerIndex).map((line, index) => choiceOptionStart(line) ? index : -1).filter((index) => index >= 0);
+  if (allStarts.length < 2) return void 0;
+  const optionStarts = latestOptionGroup(allStarts);
+  if (optionStarts.length < 2) return void 0;
+  if (explicitFooterIndex === -1 && (optionStarts[0] ?? -1) <= footerlessHeaderIndex) return void 0;
+  const firstOption = optionStarts[0] ?? 0;
+  const beforeOptions = lines.slice(0, firstOption);
+  const knownHeader = lastMatchingIndex(beforeOptions, new RegExp(dialect.headerPatterns.map(({ source }) => `(?:${source})`).join("|"), "i"));
+  const hardBoundary = lastMatchingIndex(beforeOptions, /^(?:\s*[-─━═]{8,}\s*|\s*[›>❯]\s+.+|\s*[✻◆◦•]\s+.+)$/);
+  const contextStart = knownHeader > hardBoundary ? knownHeader : hardBoundary >= 0 ? hardBoundary + 1 : Math.max(0, firstOption - 12);
+  const context = lines.slice(contextStart, firstOption).filter((line) => Boolean(line) && !/^\s*[-─━═]{8,}\s*$/.test(line));
+  const footer = lines[footerIndex] ?? "";
+  const indexedActions = optionStarts.flatMap((start, optionIndex) => {
+    const firstLine = lines[start] ?? "";
+    const parsed = parseChoiceOptionLine(firstLine);
+    if (!parsed) return [];
+    const end = optionStarts[optionIndex + 1] ?? footerIndex;
+    const rawLabel = parsed.label;
+    const marker = selectionMarker(parsed.marker);
+    const segments = [
+      rawLabel,
+      ...lines.slice(start + 1, end).map((line) => line.trim()).filter((line) => Boolean(line) && !/^[-─━═]{3,}$/.test(line) && !matchesAny(withoutFocusMarker(line), dialect.submitControls) && !isSidePanelLine(line) && !matchesAny(withoutFocusMarker(line), dialect.customInputControls) && !matchesAny(withoutFocusMarker(line), dialect.chatControls) && !/^notes$/i.test(line) && !/^\[[^\]]+\]$/.test(line))
+    ];
+    const shortcutMatch = segments.join(" ").match(/\(([^()\s]{1,16})\)\s*$/);
+    if (shortcutMatch) {
+      const last = segments.length - 1;
+      segments[last] = (segments[last] ?? "").replace(/\s*\([^()\s]{1,16}\)\s*$/, "").trim();
+    }
+    const parts = (segments.shift() ?? "").split(/\s{2,}/).map((part) => part.trim()).filter(Boolean);
+    const label = parts.shift();
+    if (!label) return [];
+    const continuation = segments.join(" ").replace(/\bnotes:\s*press\s+n\s+to\s+add\s+notes\b/gi, "").trim();
+    let description = parts.filter((part) => !isSidePanelLine(part)).join(" ").trim();
+    let fullLabel = label;
+    if (continuation && marker) {
+      description = [description, continuation].filter(Boolean).join(" ");
+    } else if (continuation) {
+      if (description) description = `${description} ${continuation}`;
+      else fullLabel = `${fullLabel} ${continuation}`;
+    }
+    const role = controlRole(fullLabel, dialect);
+    const customValue = role === "custom-input" ? dialect.customInputValuePattern?.exec(fullLabel)?.[1]?.trim() : void 0;
+    const inputValue = customValue && !/^something\.?$/i.test(customValue) ? customValue : void 0;
+    if (role === "custom-input" && /^type\b/i.test(fullLabel)) fullLabel = "Type something";
+    const risk = choiceRisk(`${fullLabel} ${description}`);
+    const editor = role === "custom-input" ? /(?:notes?\s*\(tab\)|tab\s+to\s+(?:add|edit)\s+notes?)/i.test(`${description} ${footer}`) ? { openKey: "Tab", submitKey: "Enter", commitsInteraction: true } : dialect.directInputControls && matchesAny(fullLabel, dialect.directInputControls) ? { submitKey: "Enter", commitsInteraction: true } : void 0 : void 0;
+    return [{ index: start, action: {
+      id: `option-${parsed.key}`,
+      label: fullLabel,
+      key: parsed.key,
+      description: description || void 0,
+      inputValue,
+      shortcut: shortcutMatch?.[1]?.toLowerCase(),
+      editor,
+      focused: parsed.focused,
+      marker,
+      role,
+      risk,
+      danger: risk === "persistent" || risk === "privileged"
+    } }];
+  });
+  const standaloneControls = lines.slice(firstOption, footerIndex).flatMap((line, relativeIndex) => {
+    const visible = line.replace(/^\s*[›>❯]\s*/, "").trim();
+    const role = matchesAny(visible, dialect.submitControls) ? "submit" : matchesAny(visible, dialect.customInputControls) ? "custom-input" : matchesAny(visible, dialect.chatControls) ? "chat" : void 0;
+    if (!role) return [];
+    const id = role === "submit" ? "submit" : role === "chat" ? "chat" : "custom-input";
+    const label = /^notes:/i.test(visible) ? "Add notes" : visible;
+    return [{ index: firstOption + relativeIndex, action: {
+      id,
+      key: id,
+      label,
+      role,
+      shortcut: /^notes:/i.test(visible) ? "n" : void 0,
+      focused: /^\s*[›>❯]/.test(line),
+      risk: "normal",
+      danger: false
+    } }];
+  });
+  const actions = [...indexedActions, ...standaloneControls].sort((left, right) => left.index - right.index).map(({ action }) => action);
+  const submitIndex = actions.findIndex(({ role }) => role === "submit");
+  const inlineCustomIndex = submitIndex - 1;
+  const inlineCustom = actions[inlineCustomIndex];
+  if (inlineCustom?.role === "answer" && (inlineCustom.marker === "checked" || inlineCustom.marker === "unchecked") && !inlineCustom.description && actions.slice(0, inlineCustomIndex).some(({ description, marker }) => Boolean(description && marker))) {
+    const value = inlineCustom.label.trim();
+    inlineCustom.role = "custom-input";
+    inlineCustom.inputValue = /^(?:type something|其他|其它|other)$/i.test(value) ? void 0 : value;
+    inlineCustom.label = "Type something";
+  }
+  if (actions.length < 2 || actions.filter(({ focused }) => focused).length !== 1) return void 0;
+  const kind = classifyChoice(context, actions, footer);
+  const semantics = selectionSemantics(actions, footer);
+  const canonical = actions.map(({ key, label, description, role, editor }) => ({ key, label, description, role, editor }));
+  const identityContext = context.map((line) => line.replace(/([←\s]*)[☐☑☒]/, "$1\u2610"));
+  const interactionId = createHash("sha256").update(JSON.stringify([kind, identityContext, canonical])).digest("hex");
+  const revision = createHash("sha256").update(JSON.stringify([
+    interactionId,
+    actions.map(({ key, marker, inputValue }) => ({ key, marker, inputValue }))
+  ])).digest("hex");
+  const questionContext = context.filter((line) => !matchesAny(line, dialect.headerPatterns));
+  const questionTitle = [...questionContext].reverse().find((line) => /[?？]/.test(line)) ?? questionContext.at(-1);
+  return {
+    state: kind === "approval" ? "approval" : "input",
+    confidence: kind === "question" ? 0.92 : kind === "approval" ? 0.9 : 0.85,
+    evidence: lines.slice(contextStart, footerIndex + 1).filter(Boolean),
+    actions,
+    interaction: {
+      kind,
+      title: questionTitle?.trim() || context[0]?.trim() || "\u8BF7\u9009\u62E9\u4E00\u4E2A\u9009\u9879",
+      context,
+      interactionId,
+      revision,
+      semantics,
+      contentConfidence: knownHeader >= 0 || hardBoundary >= 0 ? 0.95 : 0.65,
+      actionConfidence: semantics ? semantics.confidence : 0.55
+    }
+  };
+}
+function selectionMarker(value) {
+  if (!value) return void 0;
+  if (value === "[ ]" || value === "\u2610") return "unchecked";
+  if (/^\[[xX✓✔]\]$/.test(value) || value === "\u2611") return "checked";
+  if (value === "\u25CB") return "unselected";
+  if (value === "\u25CF") return "selected";
+  return void 0;
+}
+function matchesAny(value, patterns) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+function withoutFocusMarker(value) {
+  return value.replace(/^\s*[›>❯]\s*/, "").trim();
+}
+function isSidePanelLine(value) {
+  return /[│┌┐└┘├┤┬┴┼╔╗╚╝╠╣╦╩╬║═]/.test(value);
+}
+function controlRole(label, dialect) {
+  if (matchesAny(label, dialect.customInputControls)) return "custom-input";
+  if (matchesAny(label, dialect.chatControls)) return "chat";
+  return "answer";
+}
+function selectionSemantics(actions, footer) {
+  const answers = actions.filter(({ role }) => role === "answer");
+  const submit = actions.find(({ role }) => role === "submit");
+  const hasCheckbox = answers.length > 0 && answers.every(({ marker }) => marker === "checked" || marker === "unchecked");
+  const hasRadio = answers.length > 0 && answers.every(({ marker }) => marker === "selected" || marker === "unselected");
+  if (hasCheckbox || hasRadio) {
+    const commit = submit ? { mode: "explicit", controlId: submit.id } : /ctrl\+enter\s+to\s+(?:submit|confirm)/i.test(footer) ? { mode: "key", key: "C-Enter" } : /enter\s+to\s+(?:submit|confirm)(?:\s+answer)?/i.test(footer) ? { mode: "key", key: "Enter" } : void 0;
+    if (!commit) return void 0;
+    const toggleKey = /space\s+to\s+toggle/i.test(footer) ? "Space" : "Enter";
+    return {
+      cardinality: hasCheckbox ? "many" : "one",
+      activation: "toggle",
+      toggleKey,
+      commit,
+      confidence: 0.97,
+      evidence: [hasCheckbox ? "answer controls use checkbox markers" : "answer controls use radio markers", "an explicit commit mechanism exists"]
+    };
+  }
+  if (answers.some(({ marker }) => marker)) return void 0;
+  return {
+    cardinality: "one",
+    activation: "submit",
+    commit: { mode: "immediate" },
+    confidence: 0.9,
+    evidence: ["numbered controls use a single focus marker and no persistent selection markers"]
+  };
+}
+function latestOptionGroup(starts) {
+  const group = [starts.at(-1)];
+  for (let index = starts.length - 2; index >= 0; index -= 1) {
+    const start = starts[index];
+    if (group[0] - start > 8) break;
+    group.unshift(start);
+  }
+  return group;
+}
+function classifyChoice(context, actions, footer) {
+  const contextText = context.join(" ");
+  if (/(?:^|\s)[☐☑☒]\s+\S|Question\s+\d+\/\d+/i.test(contextText) || /submit answer|add notes/i.test(footer)) return "question";
+  const optionText = actions.map(({ label, description }) => `${label} ${description ?? ""}`).join(" ");
+  if (/(?:Would you like to|Do you want to).*(?:run|edit|grant|access)|approval required|allow command|requires approval/i.test(contextText) || /full access|don't ask again|do not ask again|always allow|auto mode|permissions?\b/i.test(optionText)) return "approval";
+  return "choice";
+}
+function choiceOptionStart(line) {
+  return Boolean(parseChoiceOptionLine(line));
+}
+function parseChoiceOptionLine(line) {
+  const match = line.match(/^\s*([›>❯])?\s*(?:(\[[ xX✓✔]\]|[☐☑○●])\s*)?(\d+)[.)]\s+(?:(\[[ xX✓✔]\]|[☐☑○●])\s*)?(.+?)\s*$/);
+  if (!match?.[3] || !match[5]) return void 0;
+  return { focused: Boolean(match[1]), marker: match[2] ?? match[4], key: match[3], label: match[5] };
+}
+function choiceRisk(text) {
+  if (/full access|bypass|without sandbox|dangerously/i.test(text)) return "privileged";
+  if (/always|don't ask again|do not ask again|auto mode|persist/i.test(text)) return "persistent";
+  if (/^\s*no\b|reject|deny|cancel|do differently/i.test(text)) return "reject";
+  return "normal";
+}
+function result(state, confidence, normalized, fingerprint, evidence) {
+  return { state, confidence, normalized, fingerprint, evidence, actions: [], hasDraftInput: false };
+}
+function matching(lines, pattern) {
+  return lines.filter((line) => pattern.test(line)).slice(-4);
+}
+function lastMatchingIndex(lines, pattern) {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (pattern.test(lines[index] ?? "")) return index;
+  }
+  return -1;
+}
+
+// src/agents/resume.ts
+function resumeArgs(resume) {
+  if (!resume) return [];
+  if (resume.mode === "last") return ["resume", "--last"];
+  if (resume.mode === "session") return ["resume", resume.sessionId];
+  return resume.all ? ["resume", "--all"] : ["resume"];
+}
+function claudeResumeArgs(resume) {
+  if (!resume) return [];
+  if (resume.mode === "last") return ["--continue"];
+  if (resume.mode === "session") return ["--resume", resume.sessionId];
+  return ["--resume"];
+}
+
+// src/agents/stop-hook.ts
+function codexStyleStopHookArgs(command) {
+  const hook = `{hooks=[{type="command",command=${JSON.stringify(command)},timeout=5}]}`;
+  return ["--dangerously-bypass-hook-trust", "-c", `hooks.Stop=[${hook}]`];
+}
+function claudeStopHookArgs(command) {
+  return ["--settings", JSON.stringify({
+    hooks: {
+      Stop: [{ hooks: [{ type: "command", command, timeout: 5 }] }]
+    }
+  })];
+}
+
+// src/agents/codex.ts
+var codexAdapter = {
+  id: "codex",
+  displayName: "Codex",
+  groupOrder: 10,
+  binary: (config) => config.agentBinaries.codex,
+  versionArgs: ["--version"],
+  buildLaunchArgs: ({ resume, stopHookCommand }) => [
+    ...codexStyleStopHookArgs(stopHookCommand),
+    ...resumeArgs(resume)
+  ],
+  detectScreen: detectCodexScreen
+};
+
+// src/agents/trae-cli.ts
+var traeCliAdapter = {
+  id: "trae-cli",
+  displayName: "Trae CLI",
+  groupOrder: 20,
+  binary: (config) => config.agentBinaries["trae-cli"],
+  versionArgs: ["--version"],
+  buildLaunchArgs: ({ resume, stopHookCommand }) => [
+    ...codexStyleStopHookArgs(stopHookCommand),
+    ...resumeArgs(resume)
+  ],
+  detectScreen: detectTraeScreen
+};
+
+// src/agents/claude-code.ts
+var claudeCodeAdapter = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  groupOrder: 30,
+  binary: (config) => config.agentBinaries["claude-code"],
+  versionArgs: ["--version"],
+  buildLaunchArgs: ({ resume, stopHookCommand }) => [
+    ...claudeStopHookArgs(stopHookCommand),
+    ...claudeResumeArgs(resume)
+  ],
+  detectScreen: detectClaudeScreen
+};
+
+// src/agents/types.ts
+var AGENT_IDS = ["codex", "trae-cli", "claude-code"];
+
+// src/agents/registry.ts
+var adapters = /* @__PURE__ */ new Map([
+  [codexAdapter.id, codexAdapter],
+  [traeCliAdapter.id, traeCliAdapter],
+  [claudeCodeAdapter.id, claudeCodeAdapter]
+]);
+function getAgentAdapter(id) {
+  const adapter = adapters.get(id);
+  if (!adapter) throw new Error(`unsupported coding agent: ${id}`);
+  return adapter;
+}
+function listAgentAdapters() {
+  return [...adapters.values()].sort((left, right) => left.groupOrder - right.groupOrder);
+}
+function isAgentId(value) {
+  return AGENT_IDS.includes(value);
+}
+
+// src/agents/stop-event.ts
+function validTurnCompleteCandidate(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return ["sessionId", "eventId", "agentSessionId", "cwd", "lastAssistantMessage"].every((key) => typeof candidate[key] === "string" && candidate[key].length > 0);
+}
+
+// src/lark/gateway.ts
+import {
+  createLarkChannel
+} from "@larksuite/channel";
+
+// src/lark/action-signing.ts
+import { createHmac, randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual2 } from "crypto";
+var APPROVAL_NONCE_RETENTION_MS = 7 * 24 * 60 * 6e4;
+function remainsValidWhilePending(kind) {
+  return kind === "choice";
+}
+var ActionSigner = class {
+  constructor(secret, now = Date.now) {
+    this.secret = secret;
+    this.now = now;
+  }
+  secret;
+  now;
+  usedNonces = /* @__PURE__ */ new Map();
+  sign(action, ttlMs = 5 * 6e4) {
+    const value = {
+      v: 1,
+      ...action,
+      nonce: randomBytes3(18).toString("base64url"),
+      expiresAt: this.now() + ttlMs
+    };
+    return { ...value, sig: this.mac(value) };
+  }
+  verify(value, expectedChatId) {
+    const now = this.now();
+    this.prune(now);
+    if (!isSignedAction(value) || expectedChatId && value.chatId !== expectedChatId || !remainsValidWhilePending(value.kind) && value.expiresAt < now || this.usedNonces.has(value.nonce)) return void 0;
+    const expected = Buffer.from(this.mac(withoutSignature(value)), "base64url");
+    const actual = Buffer.from(value.sig, "base64url");
+    if (actual.length !== expected.length || !timingSafeEqual2(actual, expected)) return void 0;
+    this.usedNonces.set(
+      value.nonce,
+      remainsValidWhilePending(value.kind) ? Math.max(value.expiresAt, now + APPROVAL_NONCE_RETENTION_MS) : value.expiresAt
+    );
+    return value;
+  }
+  mac(value) {
+    const canonical = JSON.stringify([
+      value.v,
+      value.kind,
+      value.interactionKind ?? null,
+      value.sessionId ?? null,
+      value.manualMode ?? null,
+      value.agent,
+      value.action,
+      value.paneId,
+      value.fingerprint,
+      value.chatId,
+      value.nonce,
+      value.expiresAt
+    ]);
+    return createHmac("sha256", this.secret).update(canonical).digest("base64url");
+  }
+  prune(now) {
+    for (const [nonce, expiresAt] of this.usedNonces) {
+      if (expiresAt < now) this.usedNonces.delete(nonce);
+    }
+  }
+};
+function withoutSignature(value) {
+  const { sig: _sig, ...unsigned } = value;
+  return unsigned;
+}
+function isSignedAction(value) {
+  if (!value || typeof value !== "object") return false;
+  const item = value;
+  return item.v === 1 && (item.kind === "choice" || item.kind === "stop" || item.kind === "session" || item.kind === "manual") && (item.kind !== "choice" || item.interactionKind === "approval" || item.interactionKind === "question" || item.interactionKind === "choice") && (item.kind !== "manual" || typeof item.sessionId === "string" && (item.manualMode === "explicit" || item.manualMode === "fallback")) && typeof item.agent === "string" && isAgentId(item.agent) && typeof item.action === "string" && typeof item.paneId === "string" && typeof item.fingerprint === "string" && typeof item.chatId === "string" && typeof item.nonce === "string" && typeof item.expiresAt === "number" && typeof item.sig === "string";
+}
+
+// src/lark/cards.ts
+import { homedir } from "os";
+function choiceCard(chatId, paneId, screen, signer, agent = "codex") {
+  if (!screen.interaction) throw new Error("choice card requires a structured interaction");
+  const interaction = screen.interaction;
+  const buttons = screen.actions.map((action) => ({
+    tag: "button",
+    text: { tag: "plain_text", content: choiceActionLabel(action.key, action.label, action.description) },
+    type: choiceButtonType(action.risk, action.focused),
+    width: "fill",
+    size: "medium",
+    behaviors: [{
+      type: "callback",
+      value: signer.sign({
+        kind: "choice",
+        interactionKind: interaction.kind,
+        agent,
+        action: action.key,
+        paneId,
+        fingerprint: interaction.revision ?? screen.fingerprint,
+        chatId
+      })
+    }]
+  }));
+  const context = interaction.context.join("\n").slice(0, 1800);
+  if (interaction.semantics?.activation === "toggle") {
+    const formElements = screen.actions.flatMap((action, index) => {
+      if (action.role === "custom-input") {
+        const selected2 = action.marker === "checked" || action.marker === "selected";
+        return [
+          {
+            tag: "checker",
+            name: choiceFormFieldName(index),
+            checked: selected2,
+            text: { tag: "plain_text", content: `${action.key}. ${action.label}` }
+          },
+          {
+            tag: "input",
+            name: inlineInputName(index),
+            placeholder: { tag: "plain_text", content: "\u8BF7\u8F93\u5165\u81EA\u5B9A\u4E49\u5185\u5BB9" },
+            input_type: "multiline_text",
+            rows: 2,
+            auto_resize: true,
+            max_rows: 4,
+            max_length: 1e3,
+            width: "fill",
+            default_value: action.inputValue ?? ""
+          }
+        ];
+      }
+      if (action.role === "submit") {
+        return [{ tag: "hr" }, {
+          tag: "button",
+          name: choiceFormSubmitName(),
+          text: { tag: "plain_text", content: "\u63D0\u4EA4\u7B54\u6848" },
+          type: "primary",
+          width: "fill",
+          size: "medium",
+          form_action_type: "submit"
+        }];
+      }
+      if (action.role !== "answer") return [];
+      const selected = action.marker === "checked" || action.marker === "selected";
+      const details = action.description ? `
+${action.description}` : "";
+      return [{
+        tag: "checker",
+        name: choiceFormFieldName(index),
+        checked: selected,
+        text: { tag: "plain_text", content: `${action.key}. ${action.label}${details}` }
+      }];
+    });
+    if (!screen.actions.some(({ role }) => role === "submit")) {
+      formElements.push({ tag: "hr" }, {
+        tag: "button",
+        name: choiceFormSubmitName(),
+        text: { tag: "plain_text", content: "\u63D0\u4EA4\u7B54\u6848" },
+        type: "primary",
+        width: "fill",
+        size: "medium",
+        form_action_type: "submit"
+      });
+    }
+    const immediateButtons = screen.actions.filter(({ role }) => role !== "answer" && role !== "custom-input" && role !== "submit").map((action) => ({
+      tag: "button",
+      text: { tag: "plain_text", content: choiceActionLabel(action.key, action.label, action.description) },
+      type: choiceButtonType(action.risk, action.focused),
+      width: "fill",
+      size: "medium",
+      behaviors: [{
+        type: "callback",
+        value: signer.sign({
+          kind: "choice",
+          interactionKind: interaction.kind,
+          agent,
+          action: action.key,
+          paneId,
+          fingerprint: interaction.revision ?? screen.fingerprint,
+          chatId
+        })
+      }]
+    }));
+    return cardElements(
+      `${getAgentAdapter(agent).displayName} ${interactionTitle(interaction.kind)}`,
+      [{ tag: "markdown", content: `\`\`\`text
+${escapeFence(context || interaction.title)}
+\`\`\`` }, {
+        tag: "form",
+        name: "choice_form",
+        direction: "vertical",
+        vertical_spacing: "8px",
+        elements: formElements
+      }, ...immediateButtons]
+    );
+  }
+  return card(
+    `${getAgentAdapter(agent).displayName} ${interactionTitle(interaction.kind)}`,
+    `\`\`\`text
+${escapeFence(context || "\u8BF7\u9009\u62E9\u4E00\u4E2A\u9009\u9879")}
+\`\`\``,
+    buttons
+  );
+}
+var CHOICE_FORM_SUBMIT_ACTION = "__choice_form_submit__";
+function choiceFormSubmitName() {
+  return "choice_form_submit";
+}
+function choiceFormFieldName(index) {
+  return `choice_selected_${index}`;
+}
+function inlineInputName(index) {
+  return `custom_input_${index}`;
+}
+function stopCard(chatId, paneId, fingerprint, signer, agent = "codex") {
+  const agentName = getAgentAdapter(agent).displayName;
+  return card(`\u786E\u8BA4\u505C\u6B62 ${agentName}\uFF1F`, `\u8FD9\u4F1A\u7EC8\u6B62\u5F53\u524D ${agentName} \u8FDB\u7A0B\u548C\u53D7\u7BA1 tmux \u4F1A\u8BDD\u3002`, [{
+    tag: "button",
+    text: { tag: "plain_text", content: "\u505C\u6B62\u4F1A\u8BDD" },
+    type: "danger",
+    behaviors: [{
+      type: "callback",
+      value: signer.sign({ kind: "stop", agent, action: "confirm", paneId, fingerprint, chatId }, 2 * 6e4)
+    }]
+  }]);
+}
+function interactionInputCard(agent, label) {
+  return card(
+    `${getAgentAdapter(agent).displayName} \u7B49\u5F85\u8865\u5145\u5185\u5BB9`,
+    `\u5DF2\u8FDB\u5165 **${escapeMarkdown(label)}**\u3002\u8BF7\u76F4\u63A5\u53D1\u9001\u8865\u5145\u8BF4\u660E\u3002`,
+    [],
+    "orange"
+  );
+}
+var MANUAL_TEXT_FIELD = "manual_text";
+var MANUAL_TYPE_ACTION = "type";
+var MANUAL_SUBMIT_ACTION = "submit";
+function manualControlCard(chatId, view, signer) {
+  const state = view.state ?? "active";
+  const mode = view.mode ?? "fallback";
+  const agentName = getAgentAdapter(view.session.agent).displayName;
+  const fingerprint = view.screen.fingerprint;
+  const sign = (action) => signer.sign({
+    kind: "manual",
+    sessionId: view.session.id,
+    manualMode: mode,
+    agent: view.session.agent,
+    action,
+    paneId: view.session.paneId,
+    fingerprint,
+    chatId
+  }, 10 * 6e4);
+  const status = state === "recovered" ? "\u2705 \u5DF2\u6062\u590D\u7ED3\u6784\u5316\u8BC6\u522B\uFF0C\u8BF7\u4F7F\u7528\u65B0\u53D1\u9001\u7684\u8BED\u4E49\u5316\u64CD\u4F5C\u5361\u3002" : state === "exited" ? "\u2705 \u5DF2\u9000\u51FA\u624B\u52A8\u9065\u63A7\u6A21\u5F0F\uFF0C\u672C\u5730 Agent \u548C tmux \u4ECD\u5728\u8FD0\u884C\u3002" : state === "stale" ? "\u26A0\uFE0F \u7EC8\u7AEF\u753B\u9762\u5DF2\u53D8\u5316\uFF0C\u65E7\u64CD\u4F5C\u672A\u6267\u884C\uFF1B\u8BF7\u786E\u8BA4\u6700\u65B0\u753B\u9762\u540E\u91CD\u8BD5\u3002" : state === "error" ? `\u26A0\uFE0F ${escapeMarkdown(view.notice ?? "\u624B\u52A8\u64CD\u4F5C\u5931\u8D25\uFF0C\u8BF7\u786E\u8BA4\u6700\u65B0\u753B\u9762\u3002")}` : mode === "explicit" ? "\u26A0\uFE0F \u5DF2\u9501\u5B9A\u624B\u52A8\u9065\u63A7\uFF1B\u5373\u4F7F\u6062\u590D\u7ED3\u6784\u5316\u8BC6\u522B\uFF0C\u4E5F\u4F1A\u7EE7\u7EED\u7531\u4F60\u76F4\u63A5\u64CD\u4F5C\u7EC8\u7AEF\u3002" : "\u26A0\uFE0F \u5F53\u524D\u4E3A\u624B\u52A8\u9065\u63A7\u6A21\u5F0F\uFF0C\u6240\u6709\u64CD\u4F5C\u90FD\u4E0D\u4F1A\u8FDB\u884C\u8BED\u4E49\u5B89\u5168\u5224\u65AD\u3002";
+  const metadata = [
+    `**Session**  \`${escapeInlineCode(view.session.id)}\`  \xB7  **Agent**  ${escapeMarkdown(agentName)}`,
+    `**\u72B6\u6001**  \`${view.screen.state}\`  \xB7  **\u91C7\u96C6\u65F6\u95F4**  ${formatHandledAt(view.capturedAt)}`,
+    view.lastOperation ? `**\u6700\u8FD1\u64CD\u4F5C**  ${escapeMarkdown(view.lastOperation)}` : void 0,
+    view.notice && state !== "error" ? escapeMarkdown(view.notice) : void 0
+  ].filter(Boolean).join("\n");
+  const elements = [
+    { tag: "markdown", content: status },
+    { tag: "markdown", content: metadata },
+    { tag: "markdown", content: `\`\`\`text
+${escapeFence(view.output).slice(-5e3)}
+\`\`\`` }
+  ];
+  if (state === "recovered" || state === "exited") {
+    return cardElements(`${view.session.id} \xB7 ${agentName} \u624B\u52A8\u9065\u63A7`, elements, state === "recovered" ? "green" : "grey");
+  }
+  elements.push(
+    manualButtonRow([
+      manualButton("\u2196 \u5237\u65B0", sign("refresh")),
+      manualButton("\u2191", sign("up")),
+      manualButton("Esc", sign("esc"))
+    ]),
+    manualButtonRow([
+      manualButton("\u2190", sign("left")),
+      manualButton("Enter", sign("enter"), "primary"),
+      manualButton("\u2192", sign("right"))
+    ]),
+    manualButtonRow([
+      manualButton("Tab", sign("tab")),
+      manualButton("\u2193", sign("down")),
+      manualButton("Space", sign("space"))
+    ]),
+    {
+      tag: "form",
+      name: "manual_text_form",
+      direction: "vertical",
+      vertical_spacing: "8px",
+      elements: [
+        {
+          tag: "input",
+          name: MANUAL_TEXT_FIELD,
+          input_type: "multiline_text",
+          rows: 2,
+          auto_resize: true,
+          max_rows: 4,
+          max_length: 1e3,
+          width: "fill",
+          placeholder: { tag: "plain_text", content: "\u8F93\u5165\u8981\u53D1\u9001\u5230\u5F53\u524D\u7EC8\u7AEF\u7684\u6587\u672C" }
+        },
+        manualFormButton("\u4EC5\u8F93\u5165", MANUAL_TYPE_ACTION),
+        manualFormButton("\u8F93\u5165\u5E76\u63D0\u4EA4", MANUAL_SUBMIT_ACTION, "primary")
+      ]
+    },
+    manualButtonRow([
+      manualButton("\u232B \u9000\u683C", sign("backspace")),
+      manualButton("Ctrl+C", sign("ctrl-c"), "danger"),
+      manualButton("\u7ED3\u675F\u9065\u63A7", sign("exit"))
+    ])
+  );
+  return cardElements(`${view.session.id} \xB7 ${agentName} \u624B\u52A8\u9065\u63A7`, elements, "orange");
+}
+function manualButton(label, value, type = "default") {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: label },
+    type,
+    width: "fill",
+    size: "medium",
+    behaviors: [{ type: "callback", value }]
+  };
+}
+function manualFormButton(label, name, type = "default") {
+  return {
+    tag: "button",
+    name,
+    text: { tag: "plain_text", content: label },
+    type,
+    width: "fill",
+    size: "medium",
+    form_action_type: "submit"
+  };
+}
+function manualButtonRow(buttons) {
+  return {
+    tag: "column_set",
+    flex_mode: "none",
+    horizontal_spacing: "6px",
+    columns: buttons.map((button) => ({
+      tag: "column",
+      width: "weighted",
+      weight: 1,
+      elements: [button]
+    }))
+  };
+}
+function statusCard(status) {
+  const session = status.session;
+  if (!session) {
+    return {
+      schema: "2.0",
+      config: { update_multi: true },
+      header: { title: { tag: "plain_text", content: "Coding Assistant \u72B6\u6001" }, template: "grey" },
+      body: {
+        padding: "12px",
+        elements: [{
+          tag: "markdown",
+          content: `\u26AA **\u6682\u65E0 active session**
+
+\u5F53\u524D\u5171\u6709 ${Object.keys(status.state.sessions ?? {}).length} \u4E2A\u53EF\u7528 session\uFF0C\u53EF\u53D1\u9001 /sessions \u8FDB\u884C\u9009\u62E9\u3002`
+        }]
+      }
+    };
+  }
+  const adapter = getAgentAdapter(session.agent);
+  const visual = statusVisual(status);
+  const path = formatDisplayPath(session.cwd);
+  return {
+    schema: "2.0",
+    config: { update_multi: true },
+    header: { title: { tag: "plain_text", content: `${session.id} \xB7 ${adapter.displayName}` }, template: visual.template },
+    body: {
+      vertical_spacing: "10px",
+      padding: "12px",
+      elements: [
+        { tag: "markdown", content: `<text_tag color='${visual.color}'>\u25CF ${visual.label}</text_tag>  **\u5F53\u524D\u8FDE\u63A5**` },
+        {
+          tag: "column_set",
+          flex_mode: "none",
+          horizontal_spacing: "8px",
+          columns: [
+            statusColumn("Agent", `${agentMarker(session.agent)} ${adapter.displayName}`),
+            statusColumn("tmux", status.paneAlive ? "\u2705 \u8FD0\u884C\u4E2D" : "\u26D4 \u5DF2\u505C\u6B62")
+          ]
+        },
+        {
+          tag: "column_set",
+          flex_mode: "none",
+          horizontal_spacing: "0px",
+          columns: [{
+            tag: "column",
+            width: "weighted",
+            weight: 1,
+            background_style: "grey",
+            padding: "9px 10px",
+            elements: [{ tag: "markdown", content: `**\u5DE5\u4F5C\u76EE\u5F55**
+\`${escapeInlineCode(path)}\`` }]
+          }]
+        },
+        { tag: "markdown", content: `**\u7248\u672C**  \`${escapeInlineCode(session.agentVersion)}\`
+**\u98DE\u4E66\u8FDE\u63A5**  ${status.state.boundChatId ? "\u5DF2\u7ED1\u5B9A" : "\u672A\u7ED1\u5B9A"}` }
+      ]
+    }
+  };
+}
+function sessionPickerCard(chatId, sessions, activeSessionId, signer) {
+  const groups = listAgentAdapters().map((adapter) => ({ adapter, sessions: sessions.filter((session) => session.agent === adapter.id) })).filter(({ sessions: group }) => group.length > 0);
+  const elements = groups.flatMap(({ adapter, sessions: group }, groupIndex) => [
+    ...groupIndex > 0 ? [{ tag: "hr", margin: "6px 0px" }] : [],
+    {
+      tag: "markdown",
+      content: `${agentMarker(adapter.id)} **${adapter.displayName}** \xB7 ${group.length} \u4E2A session`,
+      text_size: "heading",
+      margin: "2px 0px 0px 0px"
+    },
+    ...group.map((session) => sessionCard(chatId, session, session.id === activeSessionId, signer))
+  ]);
+  return {
+    schema: "2.0",
+    config: { update_multi: true },
+    header: { title: { tag: "plain_text", content: "\u9009\u62E9 Coding Session" }, template: "blue" },
+    body: {
+      vertical_spacing: "10px",
+      padding: "12px",
+      elements: elements.length > 0 ? elements : [{ tag: "markdown", content: "\u6682\u65E0\u53EF\u8FDE\u63A5\u7684 Coding Session\u3002" }]
+    }
+  };
+}
+function sessionCard(chatId, session, active, signer) {
+  const content = [
+    active ? `**${escapeMarkdown(session.id)}**  <text_tag color='green'>\u25CF \u5F53\u524D\u8FDE\u63A5</text_tag>` : `**${escapeMarkdown(session.id)}**`,
+    `\u{1F4C1} \`${escapeInlineCode(formatDisplayPath(session.cwd))}\``
+  ].join("\n\n");
+  const elements = [{ tag: "markdown", content }];
+  if (!active) {
+    elements.push({
+      tag: "button",
+      text: { tag: "plain_text", content: `\u8FDE\u63A5 ${session.id}` },
+      type: "primary",
+      width: "fill",
+      size: "medium",
+      margin: "2px 0px 0px 0px",
+      behaviors: [{
+        type: "callback",
+        value: signer.sign({
+          kind: "session",
+          agent: session.agent,
+          action: session.id,
+          paneId: session.paneId,
+          fingerprint: String(session.updatedAt),
+          chatId
+        })
+      }]
+    });
+  }
+  const contentColumn = {
+    tag: "column",
+    width: "weighted",
+    weight: 1,
+    vertical_spacing: "8px",
+    background_style: "grey",
+    padding: "10px 12px",
+    elements
+  };
+  return {
+    tag: "column_set",
+    flex_mode: "none",
+    horizontal_spacing: "0px",
+    margin: "0px",
+    columns: active ? [{
+      tag: "column",
+      width: "auto",
+      background_style: "green",
+      padding: "0px 3px",
+      elements: []
+    }, contentColumn] : [contentColumn]
+  };
+}
+function formatDisplayPath(path, home = homedir(), maxLength = 44) {
+  const display = path === home ? "~" : path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+  if (display.length <= maxLength) return display;
+  const segments = display.split("/").filter(Boolean);
+  return segments.length <= 2 ? display : `\u2026/${segments.slice(-2).join("/")}`;
+}
+function agentMarker(agent) {
+  if (agent === "codex") return "\u{1F535}";
+  if (agent === "trae-cli") return "\u{1F7E3}";
+  return "\u{1F7E0}";
+}
+function statusColumn(title, value) {
+  return {
+    tag: "column",
+    width: "weighted",
+    weight: 1,
+    background_style: "grey",
+    padding: "9px 10px",
+    elements: [{ tag: "markdown", content: `**${title}**
+${value}` }]
+  };
+}
+function statusVisual(status) {
+  if (!status.paneAlive || status.screen?.state === "exited") return { label: "\u5DF2\u505C\u6B62", color: "red", template: "red" };
+  if (status.screen?.state === "failed") return { label: "\u6267\u884C\u5931\u8D25", color: "red", template: "red" };
+  if (status.screen?.interaction?.kind === "approval") return { label: "\u7B49\u5F85\u5BA1\u6279", color: "orange", template: "orange" };
+  if (status.screen?.interaction?.kind === "question") return { label: "\u7B49\u5F85\u56DE\u7B54", color: "orange", template: "orange" };
+  if (status.screen?.interaction?.kind === "choice") return { label: "\u7B49\u5F85\u9009\u62E9", color: "orange", template: "orange" };
+  if (status.screen?.state === "input") return { label: "\u7B49\u5F85\u8F93\u5165", color: "orange", template: "orange" };
+  if (status.screen?.state === "running") return { label: "\u6267\u884C\u4E2D", color: "blue", template: "blue" };
+  if (status.screen?.state === "starting") return { label: "\u542F\u52A8\u4E2D", color: "blue", template: "blue" };
+  if (status.screen?.state === "idle") return { label: "\u7B49\u5F85\u7528\u6237\u8F93\u5165", color: "green", template: "green" };
+  return { label: "\u72B6\u6001\u672A\u77E5", color: "grey", template: "grey" };
+}
+function handledActionCard(action, result2, handledAt = /* @__PURE__ */ new Date()) {
+  const agentName = getAgentAdapter(action.agent).displayName;
+  const title = action.kind === "choice" ? `${agentName} ${handledInteractionTitle(action.interactionKind)}` : action.kind === "session" ? `${agentName} session \u5DF2\u5207\u6362` : `${agentName} \u4F1A\u8BDD\u5DF2\u505C\u6B62`;
+  const actionLabel = action.kind === "choice" ? `\u9009\u62E9\u7B2C ${action.action} \u9879` : action.kind === "session" ? `\u8FDE\u63A5 ${action.action}` : "\u505C\u6B62\u4F1A\u8BDD";
+  const content = [
+    `\u2705 ${escapeMarkdown(result2)}`,
+    "",
+    `**\u64CD\u4F5C**\uFF1A${escapeMarkdown(actionLabel)}`,
+    `**\u5904\u7406\u65F6\u95F4**\uFF1A${formatHandledAt(handledAt)}`
+  ].join("\n");
+  return card(title, content, [], "green");
+}
+function card(title, content, buttons, template = "blue") {
+  return cardElements(title, [{ tag: "markdown", content }, ...buttons], template);
+}
+function cardElements(title, elements, template = "blue") {
+  return {
+    schema: "2.0",
+    config: { update_multi: true },
+    header: { title: { tag: "plain_text", content: title }, template },
+    body: { vertical_spacing: "8px", padding: "12px", elements }
+  };
+}
+function interactionTitle(kind) {
+  if (kind === "approval") return "\u7B49\u5F85\u5BA1\u6279";
+  if (kind === "question") return "\u7B49\u5F85\u56DE\u7B54";
+  return "\u7B49\u5F85\u9009\u62E9";
+}
+function handledInteractionTitle(kind) {
+  if (kind === "approval") return "\u5BA1\u6279\u5DF2\u5904\u7406";
+  if (kind === "question") return "\u56DE\u7B54\u5DF2\u63D0\u4EA4";
+  return "\u9009\u62E9\u5DF2\u63D0\u4EA4";
+}
+function choiceButtonType(risk, focused) {
+  if (risk === "persistent" || risk === "privileged") return "danger";
+  if (risk === "reject") return "default";
+  return focused ? "primary" : "default";
+}
+function choiceActionLabel(key, label, description) {
+  const suffix = description ? ` \xB7 ${description}` : "";
+  return `${key}. ${label}${suffix}`.slice(0, 80);
+}
+function escapeFence(value) {
+  return value.replace(/```/g, "``\\`");
+}
+function escapeInlineCode(value) {
+  return value.replace(/`/g, "\\`");
+}
+function formatHandledAt(value) {
+  const parts = new Intl.DateTimeFormat("zh-CN", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  }).formatToParts(value);
+  const part = (type) => parts.find((item) => item.type === type)?.value ?? "";
+  return `${part("year")}-${part("month")}-${part("day")} ${part("hour")}:${part("minute")}:${part("second")}`;
+}
+function escapeMarkdown(value) {
+  return value.replace(/([\\`*_{}[\]()#+.!|>-])/g, "\\$1");
+}
+
+// src/lark/gateway.ts
+var LarkGateway = class {
+  constructor(config, secrets, handler) {
+    this.handler = handler;
+    this.signer = new ActionSigner(secrets.callbackSecret);
+    this.channel = createLarkChannel({
+      appId: config.appId,
+      appSecret: secrets.appSecret,
+      domain: config.tenant === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn",
+      source: "lark-coding-assistant",
+      policy: { dmMode: "open", requireMention: false, respondToMentionAll: false },
+      safety: { chatQueue: { enabled: true, mergeWhileBusy: false } },
+      handshakeTimeoutMs: 8e3,
+      httpTimeoutMs: 3e4,
+      respectProxyEnv: true
+    });
+    this.channel.on("message", async (message) => this.handler.onMessage(message));
+    this.channel.on("cardAction", async (event) => {
+      const mappedFormAction = event.action.formValue && event.action.name ? this.formActions.get(event.messageId)?.get(event.action.name) : void 0;
+      const action = this.signer.verify(event.action.value, event.chatId) ?? (mappedFormAction ? this.signer.verify(mappedFormAction, event.chatId) : void 0);
+      if (!action) return { toast: { type: "error", content: "\u64CD\u4F5C\u5DF2\u5931\u6548\uFF0C\u8BF7\u7B49\u5F85\u65B0\u5361\u7247\u3002" } };
+      if (event.action.formValue || action.kind === "manual") {
+        if (this.formActionsInFlight.has(event.messageId)) {
+          return { toast: { type: "warning", content: action.kind === "manual" ? "\u7EC8\u7AEF\u64CD\u4F5C\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7A0D\u5019\u3002" : "\u7B54\u6848\u6B63\u5728\u63D0\u4EA4\uFF0C\u8BF7\u7A0D\u5019\u3002" } };
+        }
+        this.formActionsInFlight.add(event.messageId);
+        void this.handleDeferredCardAction(event, action).finally(() => {
+          this.formActionsInFlight.delete(event.messageId);
+        });
+        return { toast: { type: "success", content: action.kind === "manual" ? "\u6B63\u5728\u64CD\u4F5C\u672C\u5730\u7EC8\u7AEF\u2026" : "\u6B63\u5728\u63D0\u4EA4\u5230\u672C\u5730\u7EC8\u7AEF\u2026" } };
+      }
+      const result2 = await this.handler.onAction(event, action);
+      if (result2.type === "error") return { toast: result2 };
+      if (result2.type === "manual") {
+        this.rememberManualFormActions(event.messageId, event.chatId, result2.view);
+        return {
+          toast: { type: "success", content: result2.content },
+          card: { type: "raw", data: manualControlCard(event.chatId, result2.view, this.signer) }
+        };
+      }
+      if (result2.type === "refresh") {
+        this.rememberFormActions(event.messageId, event.chatId, result2.paneId, result2.screen, result2.agent);
+        return {
+          toast: { type: "success", content: result2.content },
+          card: { type: "raw", data: choiceCard(event.chatId, result2.paneId, result2.screen, this.signer, result2.agent) }
+        };
+      }
+      if (result2.type === "awaiting-input") {
+        return {
+          toast: { type: "success", content: result2.content },
+          card: { type: "raw", data: interactionInputCard(result2.agent, result2.label) }
+        };
+      }
+      return {
+        toast: result2,
+        card: { type: "raw", data: handledActionCard(action, result2.content) }
+      };
+    });
+  }
+  handler;
+  channel;
+  signer;
+  formActions = /* @__PURE__ */ new Map();
+  formActionsInFlight = /* @__PURE__ */ new Set();
+  async handleDeferredCardAction(event, action) {
+    try {
+      const result2 = await this.handler.onAction(event, action);
+      if (result2.type === "error") {
+        await this.channel.send(event.chatId, { text: `\u5361\u7247\u64CD\u4F5C\u672A\u5B8C\u6210\uFF1A${result2.content}` });
+        return;
+      }
+      if (result2.type === "refresh") {
+        await this.updateCardAfterAction(
+          event.messageId,
+          choiceCard(event.chatId, result2.paneId, result2.screen, this.signer, result2.agent)
+        );
+        this.rememberFormActions(event.messageId, event.chatId, result2.paneId, result2.screen, result2.agent);
+        return;
+      }
+      if (result2.type === "manual") {
+        await this.updateCardAfterAction(event.messageId, manualControlCard(event.chatId, result2.view, this.signer));
+        this.rememberManualFormActions(event.messageId, event.chatId, result2.view);
+        return;
+      }
+      if (result2.type === "awaiting-input") {
+        await this.updateCardAfterAction(event.messageId, interactionInputCard(result2.agent, result2.label));
+        return;
+      }
+      await this.updateCardAfterAction(event.messageId, handledActionCard(action, result2.content));
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      await this.channel.send(event.chatId, { text: `\u5361\u7247\u64CD\u4F5C\u540C\u6B65\u5931\u8D25\uFF1A${detail}` }).catch(() => void 0);
+    }
+  }
+  async updateCardAfterAction(messageId, card2) {
+    const retryDelays = [0, 300, 800, 1600];
+    let lastError;
+    for (const delay of retryDelays) {
+      if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+      try {
+        await this.channel.updateCard(messageId, card2);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (!cardActionLocked(error)) throw error;
+      }
+    }
+    throw lastError;
+  }
+  connect() {
+    return this.channel.connect();
+  }
+  disconnect() {
+    return this.channel.disconnect();
+  }
+  sendText(chatId, text) {
+    return this.channel.send(chatId, { text });
+  }
+  sendMarkdown(chatId, markdown) {
+    return this.channel.send(chatId, { markdown });
+  }
+  async sendChoice(chatId, paneId, screen, agent) {
+    const result2 = await this.channel.send(chatId, { card: choiceCard(chatId, paneId, screen, this.signer, agent) });
+    this.rememberFormActions(result2.messageId, chatId, paneId, screen, agent);
+    return result2;
+  }
+  async updateChoice(messageId, chatId, paneId, screen, agent) {
+    await this.channel.updateCard(messageId, choiceCard(chatId, paneId, screen, this.signer, agent));
+    this.rememberFormActions(messageId, chatId, paneId, screen, agent);
+  }
+  async completeChoiceInput(messageId, action, content) {
+    await this.channel.updateCard(messageId, handledActionCard(action, content));
+    this.formActions.delete(messageId);
+  }
+  async sendManual(chatId, view) {
+    const result2 = await this.channel.send(chatId, { card: manualControlCard(chatId, view, this.signer) });
+    this.rememberManualFormActions(result2.messageId, chatId, view);
+    return result2;
+  }
+  rememberManualFormActions(messageId, chatId, view) {
+    if (view.state === "recovered" || view.state === "exited") {
+      this.formActions.delete(messageId);
+      return;
+    }
+    const common = {
+      kind: "manual",
+      sessionId: view.session.id,
+      manualMode: view.mode ?? "fallback",
+      agent: view.session.agent,
+      paneId: view.session.paneId,
+      fingerprint: view.screen.fingerprint,
+      chatId
+    };
+    this.formActions.set(messageId, /* @__PURE__ */ new Map([
+      [MANUAL_TYPE_ACTION, this.signer.sign({ ...common, action: MANUAL_TYPE_ACTION }, 10 * 6e4)],
+      [MANUAL_SUBMIT_ACTION, this.signer.sign({ ...common, action: MANUAL_SUBMIT_ACTION }, 10 * 6e4)]
+    ]));
+  }
+  rememberFormActions(messageId, chatId, paneId, screen, agent) {
+    if (screen.interaction?.semantics?.activation !== "toggle") {
+      this.formActions.delete(messageId);
+      return;
+    }
+    const actions = /* @__PURE__ */ new Map();
+    actions.set(choiceFormSubmitName(), this.signer.sign({
+      kind: "choice",
+      interactionKind: screen.interaction?.kind,
+      agent,
+      action: CHOICE_FORM_SUBMIT_ACTION,
+      paneId,
+      fingerprint: screen.interaction?.revision ?? screen.fingerprint,
+      chatId
+    }));
+    this.formActions.set(messageId, actions);
+    while (this.formActions.size > 256) {
+      const oldest = this.formActions.keys().next().value;
+      if (!oldest) break;
+      this.formActions.delete(oldest);
+    }
+  }
+  sendStatus(chatId, status) {
+    return this.channel.send(chatId, { card: statusCard(status) });
+  }
+  sendSessionPicker(chatId, sessions, activeSessionId) {
+    return this.channel.send(chatId, { card: sessionPickerCard(chatId, sessions, activeSessionId, this.signer) });
+  }
+  sendStopConfirmation(chatId, paneId, fingerprint, agent) {
+    return this.channel.send(chatId, { card: stopCard(chatId, paneId, fingerprint, this.signer, agent) });
+  }
+};
+function cardActionLocked(error) {
+  if (typeof error === "string") return /card action is lock/i.test(error);
+  if (error instanceof Error && /card action is lock/i.test(error.message)) return true;
+  if (!error || typeof error !== "object") return false;
+  const record = error;
+  return ["message", "msg", "cause"].some((key) => cardActionLocked(record[key]));
+}
+
+// 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") {
+    this.store = store;
+    this.paths = paths2;
+    this.gatewayFactory = gatewayFactory;
+    this.sessionName = sessionName;
+    this.stopHookCommand = stopHookCommand;
+    this.completionQuietMs = completionQuietMs;
+    this.appVersion = appVersion;
+  }
+  store;
+  paths;
+  gatewayFactory;
+  sessionName;
+  stopHookCommand;
+  completionQuietMs;
+  appVersion;
+  config;
+  state;
+  tmux;
+  screen;
+  previousScreen;
+  completedEvents = /* @__PURE__ */ new Set();
+  pendingCompletion;
+  pendingCompletionAt = 0;
+  outputStableSince = Date.now();
+  timer;
+  pollInFlight;
+  ownsRuntimeFiles = false;
+  closing = false;
+  gateway;
+  pendingMessages = [];
+  interactionNotificationsSuppressed = 0;
+  unresolvedCandidate;
+  unresolvedNotified = /* @__PURE__ */ new Set();
+  closedManualCards = /* @__PURE__ */ new Set();
+  pendingInteractionInput;
+  attachAttempts = /* @__PURE__ */ new Map();
+  server = createServer((socket) => this.handleSocket(socket));
+  async start() {
+    await this.store.ensure();
+    const config = await this.store.loadConfig();
+    if (!config) throw new Error("not initialized; run lark-coding-assistant init first");
+    this.config = config;
+    this.state = await this.store.loadState();
+    this.tmux = new TmuxController(config.tmuxBinary);
+    const secrets = await this.store.loadSecrets();
+    if (!secrets) throw new Error("missing secrets; run lark-coding-assistant init again");
+    await this.acquireRuntimeFiles();
+    try {
+      await this.reconcileSessions();
+      await rm(this.paths.socket, { force: true });
+      await new Promise((resolve, reject) => {
+        this.server.once("error", reject);
+        this.server.listen(this.paths.socket, () => resolve());
+      });
+      await chmod3(this.paths.socket, 384);
+      this.gateway = this.gatewayFactory(config, secrets, {
+        onMessage: (message) => this.onLarkMessage(message),
+        onAction: (event, action) => this.onLarkAction(event, action)
+      });
+      await this.gateway.connect();
+      this.schedulePoll();
+      await this.log("daemon started");
+    } catch (error) {
+      await this.releaseRuntimeFiles();
+      throw error;
+    }
+  }
+  async close() {
+    this.closing = true;
+    await this.log("daemon stopping").catch(() => void 0);
+    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 this.releaseRuntimeFiles();
+  }
+  async acquireRuntimeFiles() {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        const pidFile = await open2(this.paths.pid, "wx", 384);
+        try {
+          await pidFile.writeFile(`${process.pid}
+`);
+        } finally {
+          await pidFile.close();
+        }
+        this.ownsRuntimeFiles = true;
+        return;
+      } catch (error) {
+        if (!isAlreadyExists(error)) throw error;
+        const existingPid = Number.parseInt(await readFile2(this.paths.pid, "utf8").catch(() => ""), 10);
+        if (Number.isInteger(existingPid) && processIsAlive(existingPid)) {
+          throw new Error(`daemon is already running with PID ${existingPid}`);
+        }
+        await rm(this.paths.pid, { force: true });
+      }
+    }
+    throw new Error("failed to acquire daemon PID file");
+  }
+  async releaseRuntimeFiles() {
+    if (!this.ownsRuntimeFiles) return;
+    const ownerPid = Number.parseInt(await readFile2(this.paths.pid, "utf8").catch(() => ""), 10);
+    if (ownerPid === process.pid) {
+      await Promise.all([rm(this.paths.socket, { force: true }), rm(this.paths.pid, { force: true })]);
+    }
+    this.ownsRuntimeFiles = false;
+  }
+  handleSocket(socket) {
+    socket.setEncoding("utf8");
+    let buffer = "";
+    let dispatched = false;
+    socket.on("data", (chunk) => {
+      if (dispatched) return;
+      buffer += chunk;
+      const newline = buffer.indexOf("\n");
+      if (newline === -1) return;
+      dispatched = true;
+      const line = buffer.slice(0, newline);
+      void Promise.resolve().then(() => JSON.parse(line)).then((request) => this.dispatch(request)).then((response) => socket.end(`${JSON.stringify(response)}
+`)).catch((error) => socket.end(`${JSON.stringify(fail(error))}
+`));
+    });
+    socket.on("end", () => {
+      if (!dispatched) socket.end();
+    });
+  }
+  async dispatch(request) {
+    switch (request.method) {
+      case "ping":
+        return { ok: true, value: { version: this.appVersion, pid: process.pid } };
+      case "shutdown": {
+        setTimeout(() => void this.close(), 25);
+        return { ok: true };
+      }
+      case "start":
+        return this.startSession(request.sessionId, request.cwd, request.agent, request.resume);
+      case "status":
+        return { ok: true, value: await this.runtimeStatus(request.sessionId) };
+      case "tail":
+        return { ok: true, value: await this.tail(request.lines ?? 80) };
+      case "send":
+        return this.send(request.text);
+      case "key":
+        return this.key(request.key, request.fingerprint);
+      case "stop":
+        return this.stopSession(request.sessionId);
+      case "useSession":
+        return this.useSession(request.sessionId);
+      case "bindCode":
+        return this.rotateBindCode();
+      case "resetOwner":
+        return this.resetOwner();
+      case "turnComplete":
+        return this.handleTurnComplete(request.candidate);
+    }
+  }
+  async startSession(sessionId, cwd, agentId, resume) {
+    if (!validSessionId(sessionId)) return { ok: false, error: "session name must use letters, digits, underscore, or dash" };
+    const existing = this.state.sessions?.[sessionId];
+    if (existing && await this.tmux.inspect(existing.paneId)) {
+      return { ok: false, error: `managed coding-agent session is already running: ${sessionId}` };
+    }
+    const becomesActive = !this.state.activeSessionId;
+    if (becomesActive) {
+      this.pendingMessages.length = 0;
+      this.previousScreen = void 0;
+      this.completedEvents.clear();
+      this.clearPendingCompletion();
+    }
+    const adapter = getAgentAdapter(agentId);
+    const binary = adapter.binary(this.config);
+    const agentVersion = (await runFile(binary, [...adapter.versionArgs])).stdout.trim();
+    const tmuxSessionName = existing?.sessionName ?? `${this.sessionName}-${sessionId}`;
+    const pane = await this.tmux.create({
+      sessionName: tmuxSessionName,
+      cwd,
+      binary,
+      args: adapter.buildLaunchArgs({
+        resume,
+        stopHookCommand: this.stopHookCommand
+      }),
+      env: {
+        LARK_CODING_ASSISTANT_SOCKET: this.paths.socket,
+        LARK_CODING_ASSISTANT_SESSION_ID: sessionId
+      }
+    });
+    const binding = this.createSessionBinding();
+    const session = {
+      id: sessionId,
+      agent: agentId,
+      sessionName: pane.sessionName,
+      paneId: pane.paneId,
+      cwd,
+      agentVersion,
+      updatedAt: Date.now()
+    };
+    this.state = {
+      ...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()
+    };
+    await this.store.saveState(this.state);
+    await this.poll();
+    return { ok: true, value: { pane, session, binding, active: this.state.activeSessionId === sessionId } };
+  }
+  createSessionBinding() {
+    if (this.state.ownerOpenId && this.state.boundChatId && !this.state.autoBindDisabled) {
+      return { mode: "reused" };
+    }
+    if (this.state.ownerOpenId && !this.state.autoBindDisabled) {
+      return { mode: "awaiting-owner-message" };
+    }
+    return { mode: "code", bindCode: createBindCode(), expiresInSeconds: 600 };
+  }
+  async runtimeStatus(sessionId = this.state.activeSessionId) {
+    const session = sessionId ? this.state.sessions?.[sessionId] : void 0;
+    const pane = session ? await this.tmux.inspect(session.paneId) : void 0;
+    return { state: this.state, session, screen: sessionId === this.state.activeSessionId ? this.screen : void 0, paneAlive: Boolean(pane && !pane.dead) };
+  }
+  async tail(lines) {
+    const session = this.activeSession();
+    if (!session) throw new Error("no active managed session");
+    return tailScreen(await this.tmux.capture(session.paneId, lines), lines);
+  }
+  async send(text) {
+    const session = this.activeSession();
+    if (!session) return { ok: false, error: "no active managed session" };
+    await this.poll();
+    if (this.screen?.state === "approval") return { ok: false, error: "approval is pending" };
+    if (this.screen?.hasDraftInput) return { ok: false, error: "local draft input detected" };
+    if (!this.screen || this.screen.state === "unknown") return { ok: false, error: "screen state is unknown" };
+    this.clearPendingCompletion();
+    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();
+    const attachCode = text.match(/^\/attach\s+([^\s]+)\s*$/)?.[1];
+    if (!this.state.boundChatId) {
+      if (this.canAutoBind(message)) {
+        await this.bindChat(message, true);
+      } else {
+        if (!attachCode) return;
+        await this.handleAttach(message, attachCode);
+        return;
+      }
+    }
+    if (message.senderId !== this.state.ownerOpenId || message.chatId !== this.state.boundChatId) 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]");
+        return;
+      }
+      const output = await this.tail(lines).catch((error) => `\u8BFB\u53D6\u5931\u8D25\uFF1A${errorMessage(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}
+
+\`\`\`text
+${escapeFence2(output).slice(-6800)}
+\`\`\``);
+      return;
+    }
+    if (text.startsWith("/tail")) {
+      await this.gateway?.sendText(message.chatId, "\u7528\u6CD5\uFF1A/tail [20-300]");
+      return;
+    }
+    if (text === "/manual") {
+      await this.poll();
+      const view = this.currentManualView();
+      if (!view) await this.gateway?.sendText(message.chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u9065\u63A7\u7684 active tmux session\u3002");
+      else {
+        try {
+          await this.gateway?.sendManual(message.chatId, view);
+        } catch (error) {
+          await this.log(`manual card failed: ${errorMessage(error)}`);
+          await this.gateway?.sendText(
+            message.chatId,
+            "\u624B\u52A8\u9065\u63A7\u5361\u53D1\u9001\u5931\u8D25\u3002\u53EF\u4F7F\u7528 /tail 120 \u67E5\u770B\u7EC8\u7AEF\uFF0C\u6216\u4F7F\u7528 /key\u3001/type\u3001/submit \u64CD\u4F5C\u3002"
+          );
+        }
+      }
+      return;
+    }
+    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.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");
+      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.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>`);
+      return;
+    }
+    if (text === "/status") {
+      const status = await this.runtimeStatus();
+      await this.gateway?.sendStatus(message.chatId, status);
+      return;
+    }
+    if (text === "/sessions") {
+      const sessions = await this.reconcileSessions();
+      try {
+        await this.gateway?.sendSessionPicker(
+          message.chatId,
+          sessions,
+          this.state.activeSessionId
+        );
+      } catch (error) {
+        await this.log(`session picker notification failed: ${errorMessage(error)}`);
+        await this.gateway?.sendText(
+          message.chatId,
+          "Session \u9009\u62E9\u5361\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u4E5F\u53EF\u4EE5\u53D1\u9001 /use <session \u540D\u79F0> \u8FDB\u884C\u5207\u6362\u3002"
+        );
+      }
+      return;
+    }
+    const useSessionId = text.match(/^\/use\s+([a-zA-Z0-9_-]+)\s*$/)?.[1];
+    if (useSessionId) {
+      const result3 = await this.useSession(useSessionId);
+      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,
+        reply
+      );
+      return;
+    }
+    if (text === "/detach") {
+      this.pendingMessages.length = 0;
+      this.pendingInteractionInput = void 0;
+      this.unresolvedCandidate = void 0;
+      this.unresolvedNotified.clear();
+      this.state = {
+        ...this.state,
+        boundChatId: void 0,
+        autoBindDisabled: true,
+        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");
+      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");
+      } else {
+        await this.gateway?.sendStopConfirmation(message.chatId, session.paneId, this.screen.fingerprint, session.agent);
+      }
+      return;
+    }
+    const pendingInput = this.pendingInteractionInput;
+    if (pendingInput) {
+      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");
+        return;
+      }
+      await this.tmux.sendText(session.paneId, message.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");
+          return;
+        }
+        const content = `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u8865\u5145\u5185\u5BB9\u3002`;
+        await this.gateway?.completeChoiceInput(pendingInput.cardMessageId, pendingInput.action, content);
+        await this.flushPending();
+        return;
+      }
+      if (pendingInput.role === "custom-input") {
+        const refreshed = await this.withInteractionNotificationsSuppressed(async () => {
+          await this.waitForCustomInputValue(pendingInput.interactionId, pendingInput.controlId, message.content);
+          const current = this.screen;
+          if (current?.interaction?.semantics && (current.interaction.actionConfidence ?? 0) >= 0.85) {
+            await this.gateway?.updateChoice(
+              pendingInput.cardMessageId,
+              message.chatId,
+              session.paneId,
+              current,
+              session.agent
+            );
+            return true;
+          }
+          return false;
+        });
+        if (refreshed) return;
+      }
+      await this.gateway?.sendText(message.chatId, `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u8865\u5145\u5185\u5BB9\u3002`);
+      return;
+    }
+    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");
+        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`);
+      return;
+    }
+    const result2 = await this.send(message.content);
+    if (!result2.ok) await this.gateway?.sendText(message.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;
+    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");
+      return;
+    }
+    await this.bindChat(message, false);
+  }
+  canAutoBind(message) {
+    return !this.state.autoBindDisabled && Boolean(this.state.ownerOpenId) && message.senderId === this.state.ownerOpenId;
+  }
+  async bindChat(message, automatic) {
+    this.state = {
+      ...this.state,
+      ownerOpenId: this.state.ownerOpenId ?? message.senderId,
+      boundChatId: message.chatId,
+      autoBindDisabled: false,
+      bindCodeHash: void 0,
+      bindCodeExpiresAt: void 0,
+      updatedAt: Date.now()
+    };
+    await this.store.saveState(this.state);
+    await this.gateway?.sendText(
+      message.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;
+    await this.poll();
+  }
+  allowAttachAttempt(senderId) {
+    const cutoff = Date.now() - 6e4;
+    const attempts = (this.attachAttempts.get(senderId) ?? []).filter((time) => time >= cutoff);
+    if (attempts.length >= 5) return false;
+    attempts.push(Date.now());
+    this.attachAttempts.set(senderId, attempts);
+    return true;
+  }
+  shouldQueueMessage() {
+    return !this.screen || this.screen.state === "approval" || this.screen.state === "unknown" || this.screen.state === "failed" || this.screen.state === "exited" || this.screen.hasDraftInput;
+  }
+  async onLarkAction(event, action) {
+    if (event.operator.openId !== this.state.ownerOpenId || event.chatId !== this.state.boundChatId) {
+      return { type: "error", content: "\u65E0\u6743\u64CD\u4F5C\u5F53\u524D\u4F1A\u8BDD\u3002" };
+    }
+    if (action.kind === "session") {
+      const target = this.state.sessions?.[action.action];
+      if (!target || target.agent !== action.agent || target.paneId !== action.paneId || String(target.updatedAt) !== action.fingerprint) {
+        return { type: "error", content: "\u76EE\u6807 session \u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u53D1\u9001 /sessions\u3002" };
+      }
+      const result3 = await this.useSession(target.id);
+      return result3.ok ? { type: "success", content: `\u5DF2\u8FDE\u63A5\u5230 ${target.id}` } : { type: "error", content: result3.error };
+    }
+    if (action.kind === "manual") {
+      return this.withInteractionNotificationsSuppressed(() => this.handleManualAction(action, event));
+    }
+    await this.poll();
+    const session = this.activeSession();
+    if (action.kind === "choice") {
+      return this.withInteractionNotificationsSuppressed(() => this.handleChoiceAction(action, session, event));
+    }
+    if (action.paneId !== session?.paneId || action.agent !== session.agent || action.fingerprint !== this.screen?.fingerprint) {
+      return { type: "error", content: "\u4F1A\u8BDD\u753B\u9762\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u53D1\u9001 /stop\u3002" };
+    }
+    const result2 = await this.stopSession(session.id);
+    return result2.ok ? { type: "success", content: `${getAgentAdapter(session.agent).displayName} \u4F1A\u8BDD\u5DF2\u505C\u6B62\u3002` } : { type: "error", content: result2.error };
+  }
+  async handleManualAction(action, event) {
+    await this.poll();
+    const session = this.activeSession();
+    const screen = this.screen;
+    if (!session || !screen || action.sessionId !== session.id || action.agent !== session.agent || action.paneId !== session.paneId) {
+      return { type: "error", content: "\u624B\u52A8\u9065\u63A7\u5BF9\u5E94\u7684 session \u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u53D1\u9001 /manual\u3002" };
+    }
+    if (this.closedManualCards.has(event.messageId)) {
+      return {
+        type: "manual",
+        content: "\u8BE5\u624B\u52A8\u9065\u63A7\u5361\u5DF2\u7ECF\u7ED3\u675F\u3002",
+        view: this.manualView(session, screen, "exited", void 0, "\u7ED3\u675F\u9065\u63A7", action.manualMode)
+      };
+    }
+    if (action.action !== "refresh" && action.fingerprint !== screen.fingerprint) {
+      return {
+        type: "manual",
+        content: "\u7EC8\u7AEF\u753B\u9762\u5DF2\u53D8\u5316\uFF0C\u65E7\u64CD\u4F5C\u672A\u6267\u884C\u3002",
+        view: this.manualView(session, screen, "stale", "\u8BF7\u786E\u8BA4\u6700\u65B0\u7EC8\u7AEF\u753B\u9762\u540E\u91CD\u8BD5\u3002", void 0, action.manualMode)
+      };
+    }
+    if (action.action === "exit") {
+      remember(this.closedManualCards, event.messageId, 256);
+      return {
+        type: "manual",
+        content: "\u5DF2\u7ED3\u675F\u624B\u52A8\u9065\u63A7\u3002",
+        view: this.manualView(session, screen, "exited", void 0, "\u7ED3\u675F\u9065\u63A7", action.manualMode)
+      };
+    }
+    let operation = "\u5237\u65B0\u7EC8\u7AEF\u8F93\u51FA";
+    try {
+      if (action.action === "type" || action.action === "submit") {
+        const value = event.action.formValue?.[MANUAL_TEXT_FIELD];
+        if (typeof value !== "string" || !value.trim()) return { type: "error", content: "\u8BF7\u8F93\u5165\u8981\u53D1\u9001\u5230\u7EC8\u7AEF\u7684\u6587\u672C\u3002" };
+        const submit = action.action === "submit";
+        operation = submit ? "\u8F93\u5165\u6587\u672C\u5E76\u63D0\u4EA4" : "\u4EC5\u8F93\u5165\u6587\u672C";
+        await this.tmux.sendText(session.paneId, value, submit);
+      } else if (action.action !== "refresh") {
+        const key = manualTmuxKey(action.action);
+        operation = `\u6309\u952E ${action.action}`;
+        await this.tmux.sendKey(session.paneId, key);
+      }
+      if (action.action === "refresh") await this.poll();
+      else await this.settleManualScreen();
+    } catch (error) {
+      await this.poll().catch(() => void 0);
+      const current2 = this.screen ?? screen;
+      return {
+        type: "manual",
+        content: "\u624B\u52A8\u64CD\u4F5C\u5931\u8D25\u3002",
+        view: this.manualView(session, current2, "error", errorMessage(error), operation, action.manualMode)
+      };
+    }
+    const current = this.screen ?? screen;
+    if (action.manualMode !== "explicit" && safeStructuredInteraction(current)) {
+      await this.gateway?.sendChoice(event.chatId, session.paneId, current, session.agent);
+      return {
+        type: "manual",
+        content: "\u5DF2\u6062\u590D\u7ED3\u6784\u5316\u8BC6\u522B\u3002",
+        view: this.manualView(session, current, "recovered", void 0, operation, action.manualMode)
+      };
+    }
+    return {
+      type: "manual",
+      content: `${operation}\u5DF2\u6267\u884C\u3002`,
+      view: this.manualView(session, current, "active", void 0, operation, action.manualMode)
+    };
+  }
+  currentManualView() {
+    const session = this.activeSession();
+    if (!session || !this.screen || this.screen.state === "exited") return void 0;
+    return this.manualView(session, this.screen, "active", void 0, void 0, "explicit");
+  }
+  async settleManualScreen() {
+    let previousFingerprint;
+    const deadline = Date.now() + 900;
+    do {
+      await new Promise((resolve) => setTimeout(resolve, 120));
+      await this.poll();
+      const fingerprint = this.screen?.fingerprint;
+      if (fingerprint && fingerprint === previousFingerprint) return;
+      previousFingerprint = fingerprint;
+    } while (Date.now() < deadline);
+  }
+  manualView(session, screen, state = "active", notice, lastOperation, mode = "fallback") {
+    return {
+      session,
+      screen,
+      output: tailScreen(screen.normalized, 40),
+      capturedAt: /* @__PURE__ */ new Date(),
+      state,
+      notice,
+      lastOperation,
+      mode
+    };
+  }
+  async executeManualCommand(chatId, operation, execute) {
+    await this.poll();
+    const session = this.activeSession();
+    if (!session || !this.screen || this.screen.state === "exited") {
+      await this.gateway?.sendText(chatId, "\u5F53\u524D\u6CA1\u6709\u53EF\u9065\u63A7\u7684 active tmux session\u3002");
+      return;
+    }
+    try {
+      await execute(session);
+      await new Promise((resolve) => setTimeout(resolve, 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}**
+
+\`\`\`text
+${escapeFence2(output).slice(-6500)}
+\`\`\``);
+    } catch (error) {
+      await this.gateway?.sendText(chatId, `\u624B\u52A8\u64CD\u4F5C\u5931\u8D25\uFF1A${errorMessage(error)}`);
+    }
+  }
+  async handleChoiceAction(action, session, event) {
+    if (action.paneId !== session?.paneId || action.agent !== session.agent) return { type: "error", content: "\u4F1A\u8BDD\u5DF2\u53D8\u5316\u3002" };
+    if (event.action.formValue) {
+      if (action.action !== CHOICE_FORM_SUBMIT_ACTION) return { type: "error", content: "\u65E0\u6CD5\u8BC6\u522B\u8BE5\u8868\u5355\u64CD\u4F5C\uFF0C\u8BF7\u4F7F\u7528\u6700\u65B0\u5361\u7247\u3002" };
+      return this.handleToggleFormSubmit(action, session, event.action.formValue);
+    }
+    const before = this.screen?.interaction;
+    const target = this.screen?.actions.find(({ key }) => key === action.action);
+    const fingerprint = before?.revision ?? this.screen?.fingerprint ?? action.fingerprint;
+    const customAlreadySelected = target?.role === "custom-input" && (target.marker === "checked" || target.marker === "selected") && fingerprint === action.fingerprint && before?.kind === action.interactionKind;
+    const opensEditor = target?.role === "custom-input" && target.editor;
+    let result2;
+    if (customAlreadySelected) {
+      result2 = { ok: true, value: `\u7EE7\u7EED\u586B\u5199\uFF1A${target.label}` };
+    } else if (opensEditor && before?.interactionId) {
+      const navigation = await this.navigateToControl(session.paneId, target.id, before.interactionId);
+      if (!navigation.ok) return { type: "error", content: navigation.error };
+      if (opensEditor.openKey) await this.tmux.sendKey(session.paneId, opensEditor.openKey);
+      result2 = { ok: true, value: `\u7EE7\u7EED\u586B\u5199\uFF1A${target.label}` };
+    } else {
+      result2 = await this.submitChoice(action.action, fingerprint, action.interactionKind);
+    }
+    if (!result2.ok) return { type: "error", content: result2.error };
+    if (before?.semantics?.activation === "toggle" && target?.role === "answer") {
+      await this.waitForControlMarker(before.interactionId, target.id, target.marker);
+      const currentScreen = this.screen;
+      const currentTarget = currentScreen?.actions.find(({ id }) => id === target.id);
+      if (!currentScreen || !currentTarget || currentScreen.interaction?.interactionId !== before.interactionId || currentTarget.marker === target.marker) {
+        return { type: "error", content: "\u7EC8\u7AEF\u9009\u62E9\u72B6\u6001\u6CA1\u6709\u6309\u9884\u671F\u66F4\u65B0\uFF0C\u8BF7\u7528 /tail \u68C0\u67E5\u3002" };
+      }
+      return {
+        type: "refresh",
+        content: `${currentTarget.marker === "checked" || currentTarget.marker === "selected" ? "\u5DF2\u9009\u62E9" : "\u5DF2\u53D6\u6D88"}\uFF1A${target.label}`,
+        screen: currentScreen,
+        paneId: session.paneId,
+        agent: session.agent
+      };
+    }
+    if (target?.role === "custom-input" || target?.role === "chat") {
+      await new Promise((resolve) => setTimeout(resolve, 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 = {
+        sessionId: session.id,
+        interactionId: this.screen?.interaction?.interactionId ?? before.interactionId,
+        controlId: target.id,
+        role: target.role,
+        label: target.label,
+        cardMessageId: event.messageId,
+        submitOnInput: target.role === "chat" || before.semantics?.activation === "submit",
+        action
+      };
+      return { type: "awaiting-input", content: "\u8BF7\u53D1\u9001\u4E0B\u4E00\u6761\u666E\u901A\u6D88\u606F\u3002", agent: session.agent, label: target.label };
+    }
+    await this.waitForInteractionChange(before?.interactionId);
+    if (this.screen?.interaction && this.screen.interaction.interactionId !== before?.interactionId && this.screen.interaction.semantics && (this.screen.interaction.actionConfidence ?? 0) >= 0.85) {
+      return {
+        type: "refresh",
+        content: "\u5DF2\u8FDB\u5165\u4E0B\u4E00\u6B65\u786E\u8BA4\u3002",
+        screen: this.screen,
+        paneId: session.paneId,
+        agent: session.agent
+      };
+    }
+    if ((target?.role === "submit" || before?.semantics?.commit.mode === "immediate") && this.screen?.interaction?.interactionId === before?.interactionId) {
+      return { type: "error", content: "\u7EC8\u7AEF\u4ECD\u505C\u7559\u5728\u539F\u95EE\u9898\uFF0C\u672A\u786E\u8BA4\u63D0\u4EA4\u6210\u529F\u3002" };
+    }
+    await this.flushPending();
+    return { type: "success", content: result2.value };
+  }
+  async handleToggleFormSubmit(action, session, formValue) {
+    const initialScreen = this.screen;
+    const interaction = initialScreen?.interaction;
+    if (!initialScreen || !interaction?.interactionId || interaction.semantics?.activation !== "toggle" || (interaction.revision ?? initialScreen.fingerprint) !== action.fingerprint || interaction.kind !== action.interactionKind) {
+      return { type: "error", content: "\u5361\u7247\u72B6\u6001\u5DF2\u53D8\u5316\uFF0C\u8BF7\u4F7F\u7528\u6700\u65B0\u5361\u7247\u3002" };
+    }
+    const synced = await this.syncToggleFormState(session.paneId, initialScreen, formValue);
+    if (!synced.ok) return { type: "error", content: synced.error };
+    if (synced.committed) {
+      await this.waitForInteractionChange(interaction.interactionId);
+      if (this.screen?.interaction?.interactionId === interaction.interactionId) {
+        return { type: "error", content: "\u81EA\u5B9A\u4E49\u5185\u5BB9\u5DF2\u540C\u6B65\uFF0C\u4F46\u7EC8\u7AEF\u4ECD\u505C\u7559\u5728\u539F\u95EE\u9898\u3002" };
+      }
+      if (this.screen?.interaction?.semantics && (this.screen.interaction.actionConfidence ?? 0) >= 0.85) {
+        return {
+          type: "refresh",
+          content: "\u7B54\u6848\u5DF2\u63D0\u4EA4\uFF0C\u5DF2\u8FDB\u5165\u4E0B\u4E00\u6B65\u786E\u8BA4\u3002",
+          screen: this.screen,
+          paneId: session.paneId,
+          agent: session.agent
+        };
+      }
+      await this.flushPending();
+      return { type: "success", content: `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u7B54\u6848\u3002` };
+    }
+    await this.poll();
+    const current = this.screen;
+    if (!current?.interaction || current.interaction.interactionId !== interaction.interactionId) {
+      return { type: "error", content: "\u7EC8\u7AEF\u95EE\u9898\u5728\u63D0\u4EA4\u524D\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u4F7F\u7528\u6700\u65B0\u5361\u7247\u3002" };
+    }
+    const commit = current.interaction.semantics?.commit;
+    if (!commit || commit.mode === "immediate") return { type: "error", content: "\u65E0\u6CD5\u786E\u5B9A\u7EC8\u7AEF\u63D0\u4EA4\u65B9\u5F0F\uFF0C\u8BF7\u7528 /tail \u68C0\u67E5\u3002" };
+    if (commit.mode === "key") {
+      await this.tmux.sendKey(session.paneId, commit.key);
+    } else {
+      const submit = current.actions.find(({ id }) => id === commit.controlId);
+      if (!submit) return { type: "error", content: "\u7EC8\u7AEF\u63D0\u4EA4\u6309\u94AE\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u4F7F\u7528\u6700\u65B0\u5361\u7247\u3002" };
+      const navigation = await this.navigateToControl(session.paneId, submit.id, interaction.interactionId);
+      if (!navigation.ok) return { type: "error", content: navigation.error };
+      await this.tmux.sendKey(session.paneId, "Enter");
+    }
+    await this.waitForInteractionChange(interaction.interactionId);
+    if (this.screen?.interaction?.interactionId === interaction.interactionId) {
+      return { type: "error", content: "\u7EC8\u7AEF\u4ECD\u505C\u7559\u5728\u539F\u95EE\u9898\uFF0C\u672A\u786E\u8BA4\u63D0\u4EA4\u6210\u529F\u3002" };
+    }
+    if (this.screen?.interaction?.semantics && (this.screen.interaction.actionConfidence ?? 0) >= 0.85) {
+      return {
+        type: "refresh",
+        content: "\u7B54\u6848\u5DF2\u63D0\u4EA4\uFF0C\u5DF2\u8FDB\u5165\u4E0B\u4E00\u6B65\u786E\u8BA4\u3002",
+        screen: this.screen,
+        paneId: session.paneId,
+        agent: session.agent
+      };
+    }
+    await this.flushPending();
+    return { type: "success", content: `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} \u63D0\u4EA4\u7B54\u6848\u3002` };
+  }
+  async withInteractionNotificationsSuppressed(operation) {
+    this.interactionNotificationsSuppressed += 1;
+    try {
+      return await operation();
+    } finally {
+      this.interactionNotificationsSuppressed -= 1;
+    }
+  }
+  async key(key, fingerprint) {
+    return this.submitChoice(key, fingerprint);
+  }
+  async submitChoice(choice, fingerprint, expectedKind) {
+    const session = this.activeSession();
+    if (!session) return { ok: false, error: "no active managed session" };
+    await this.poll();
+    const screen = this.screen;
+    const interaction = screen?.interaction;
+    const revision = interaction?.revision ?? screen?.fingerprint;
+    if (!screen || !interaction?.semantics || !interaction.actionConfidence || interaction.actionConfidence < 0.85 || revision !== fingerprint || screen.actions.length === 0 || expectedKind && interaction.kind !== expectedKind) {
+      return { ok: false, error: "choice screen changed; refusing stale action" };
+    }
+    const target = screen.actions.find((action) => action.key === choice);
+    if (!target) return { ok: false, error: "option is not valid for current choice" };
+    if (target.shortcut && (target.role === "custom-input" || target.role === "chat")) {
+      await this.tmux.sendKey(session.paneId, target.shortcut);
+    } else {
+      const navigation = await this.navigateToControl(session.paneId, target.id, interaction.interactionId);
+      if (!navigation.ok) return navigation;
+      await this.tmux.sendKey(session.paneId, "Enter");
+    }
+    const verb = interaction.kind === "approval" ? "\u63D0\u4EA4\u5BA1\u6279\u9009\u62E9" : interaction.kind === "question" ? "\u63D0\u4EA4\u7B54\u6848" : "\u63D0\u4EA4\u9009\u62E9";
+    return { ok: true, value: `\u5DF2\u5411 ${getAgentAdapter(session.agent).displayName} ${verb}\uFF1A${target.label}` };
+  }
+  async navigateToControl(paneId, targetId, interactionId) {
+    for (let step = 0; step < 24; step += 1) {
+      const screen = this.screen;
+      if (!screen?.interaction || screen.interaction.interactionId !== interactionId) {
+        return { ok: false, error: "interaction changed while navigating; refusing action" };
+      }
+      const focusedIndex = screen.actions.findIndex(({ focused }) => focused);
+      const targetIndex = screen.actions.findIndex(({ id }) => id === targetId);
+      if (focusedIndex === -1 || targetIndex === -1) return { ok: false, error: "cannot determine current or target focus" };
+      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 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" };
+    }
+    return { ok: false, error: "terminal focus navigation exceeded its safe step limit" };
+  }
+  async waitForInteractionChange(interactionId) {
+    const deadline = Date.now() + 1500;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 75));
+      await this.poll();
+      const current = this.screen?.interaction;
+      if (!current || current.interactionId !== interactionId) return;
+    }
+  }
+  async waitForControlMarker(interactionId, controlId, marker) {
+    const deadline = Date.now() + 1500;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 75));
+      await this.poll();
+      const current = this.screen?.interaction;
+      const control = this.screen?.actions.find(({ id }) => id === controlId);
+      if (!current || current.interactionId !== interactionId || control?.marker !== marker) return;
+    }
+  }
+  async waitForCustomInputValue(interactionId, controlId, input) {
+    const expected = input.trim();
+    const deadline = Date.now() + 1500;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 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;
+    }
+  }
+  async syncToggleFormState(paneId, initialScreen, formValue) {
+    const interactionId = initialScreen.interaction?.interactionId;
+    if (!interactionId) return { ok: false, error: "\u65E0\u6CD5\u786E\u5B9A\u5F53\u524D\u7EC8\u7AEF\u95EE\u9898\u3002" };
+    const desiredControls = initialScreen.actions.flatMap((control, index) => {
+      if (control.role !== "answer" && control.role !== "custom-input") return [];
+      const selected = formChecked(formValue[choiceFormFieldName(index)]);
+      const rawInput = formValue[inlineInputName(index)];
+      const input = control.role === "custom-input" && typeof rawInput === "string" ? rawInput.trim() : void 0;
+      return [{ id: control.id, role: control.role, selected, input, editor: control.editor }];
+    }).sort((left, right) => Number(left.role === "custom-input") - Number(right.role === "custom-input"));
+    const emptyCustom = desiredControls.find(({ role, selected, input }) => role === "custom-input" && selected && !input);
+    if (emptyCustom) return { ok: false, error: "\u5DF2\u52FE\u9009\u81EA\u5B9A\u4E49\u8F93\u5165\uFF0C\u4F46\u5185\u5BB9\u4E3A\u7A7A\u3002\u8BF7\u586B\u5199\u5185\u5BB9\u540E\u518D\u63D0\u4EA4\u3002" };
+    const toggleKey = initialScreen.interaction?.semantics?.toggleKey ?? "Enter";
+    for (const desired of desiredControls) {
+      await this.poll();
+      let control = this.screen?.actions.find(({ id }) => id === desired.id);
+      if (!control || this.screen?.interaction?.interactionId !== interactionId) {
+        return { ok: false, error: "\u7EC8\u7AEF\u9009\u9879\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u4F7F\u7528\u6700\u65B0\u5361\u7247\u3002" };
+      }
+      const currentlySelected = control.marker === "checked" || control.marker === "selected";
+      if (currentlySelected !== desired.selected) {
+        const navigation2 = await this.navigateToControl(paneId, control.id, interactionId);
+        if (!navigation2.ok) return navigation2;
+        const previousMarker = control.marker;
+        await this.tmux.sendKey(paneId, toggleKey);
+        await this.waitForControlMarker(interactionId, control.id, previousMarker);
+        control = this.screen?.actions.find(({ id }) => id === desired.id);
+        const selectedAfterToggle = control?.marker === "checked" || control?.marker === "selected";
+        if (!control || selectedAfterToggle !== desired.selected) {
+          return { ok: false, error: `\u7EC8\u7AEF\u9009\u9879\u201C${control?.label ?? desired.id}\u201D\u6CA1\u6709\u6309\u9884\u671F\u66F4\u65B0\u3002` };
+        }
+      }
+      if (desired.role !== "custom-input" || !desired.selected || desired.input === void 0) continue;
+      control = this.screen?.actions.find(({ id }) => id === desired.id);
+      if (control?.inputValue?.trim() === desired.input) continue;
+      const navigation = await this.navigateToControl(paneId, desired.id, interactionId);
+      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 this.tmux.sendKey(paneId, "C-u");
+        await this.tmux.sendKey(paneId, "C-k");
+        await this.tmux.sendText(paneId, desired.input, false);
+        await this.tmux.sendKey(paneId, desired.editor.submitKey);
+        return { ok: true, committed: desired.editor.commitsInteraction };
+      }
+      await this.tmux.sendKey(paneId, "C-u");
+      await this.tmux.sendKey(paneId, "C-k");
+      await this.tmux.sendText(paneId, desired.input, false);
+      await this.waitForCustomInputValue(interactionId, desired.id, desired.input);
+      control = this.screen?.actions.find(({ id }) => id === desired.id);
+      if (!control?.inputValue || !(desired.input === control.inputValue || desired.input.startsWith(control.inputValue))) {
+        return { ok: false, error: "\u81EA\u5B9A\u4E49\u5185\u5BB9\u6CA1\u6709\u5B8C\u6574\u540C\u6B65\u5230\u7EC8\u7AEF\uFF0C\u8BF7\u91CD\u8BD5\u3002" };
+      }
+    }
+    return { ok: true, committed: false };
+  }
+  async stopSession(sessionId = this.state.activeSessionId) {
+    if (!sessionId) return { ok: false, error: "no active managed session" };
+    const session = this.state.sessions?.[sessionId];
+    if (!session) return { ok: false, error: `unknown session: ${sessionId}` };
+    if (await this.tmux.hasSession(session.sessionName)) {
+      await this.tmux.killSession(session.sessionName);
+    }
+    const sessions = { ...this.state.sessions };
+    delete sessions[sessionId];
+    const wasActive = this.state.activeSessionId === sessionId;
+    const activeSessionId = wasActive ? Object.keys(sessions)[0] : this.state.activeSessionId;
+    this.state = {
+      ...this.state,
+      sessions,
+      activeSessionId,
+      updatedAt: Date.now()
+    };
+    if (wasActive) {
+      this.screen = void 0;
+      this.previousScreen = void 0;
+      this.completedEvents.clear();
+      this.clearPendingCompletion();
+      this.pendingMessages.length = 0;
+      this.pendingInteractionInput = void 0;
+      this.unresolvedCandidate = void 0;
+      this.unresolvedNotified.clear();
+    }
+    await this.store.saveState(this.state);
+    return { ok: true };
+  }
+  async resetOwner() {
+    this.pendingMessages.length = 0;
+    this.pendingInteractionInput = void 0;
+    this.unresolvedCandidate = void 0;
+    this.unresolvedNotified.clear();
+    this.state = {
+      ...this.state,
+      ownerOpenId: void 0,
+      boundChatId: void 0,
+      autoBindDisabled: true,
+      updatedAt: Date.now()
+    };
+    await this.store.saveState(this.state);
+    return { ok: true };
+  }
+  async rotateBindCode() {
+    if (Object.keys(this.state.sessions ?? {}).length === 0) return { ok: false, error: "no managed coding-agent session is running" };
+    const bindCode = createBindCode();
+    this.state = {
+      ...this.state,
+      boundChatId: void 0,
+      autoBindDisabled: true,
+      bindCodeHash: hashBindCode(bindCode),
+      bindCodeExpiresAt: Date.now() + 10 * 6e4,
+      updatedAt: Date.now()
+    };
+    await this.store.saveState(this.state);
+    return { ok: true, value: { bindCode, expiresInSeconds: 600 } };
+  }
+  schedulePoll() {
+    if (this.closing) return;
+    this.timer = setTimeout(() => {
+      void this.runScheduledPoll();
+    }, this.config.pollIntervalMs);
+  }
+  async runScheduledPoll() {
+    const operation = this.poll().catch(async (error) => {
+      if (!this.closing) await this.log(`poll failed: ${errorMessage(error)}`);
+    });
+    this.pollInFlight = operation;
+    try {
+      await operation;
+    } finally {
+      if (this.pollInFlight === operation) this.pollInFlight = void 0;
+      if (!this.closing) this.schedulePoll();
+    }
+  }
+  async poll() {
+    const session = this.activeSession();
+    const paneId = session?.paneId;
+    if (!paneId) {
+      await this.reconcileSessions();
+      return;
+    }
+    const pane = await this.tmux.inspect(paneId);
+    const adapter = getAgentAdapter(session.agent);
+    if (!pane || pane.dead) {
+      this.updateScreen(adapter.detectScreen("", false));
+      await this.notifyTransition();
+      await this.maybeNotifyUnresolved();
+      await this.maybeNotifyCompletion();
+      await this.reconcileSessions();
+      return;
+    }
+    const raw = await this.tmux.capture(paneId, 160);
+    this.updateScreen(adapter.detectScreen(raw, true, { x: pane.cursorX, y: pane.cursorY }));
+    await this.notifyTransition();
+    await this.maybeNotifyUnresolved();
+    await this.maybeNotifyCompletion();
+    await this.flushPending();
+    await this.reconcileSessions();
+  }
+  async notifyTransition() {
+    const current = this.screen;
+    const previous = this.previousScreen;
+    this.previousScreen = current;
+    const session = this.activeSession();
+    if (!current || !session || !this.gateway) return;
+    const agentName = getAgentAdapter(session.agent).displayName;
+    if (previous?.state === current.state && previous.fingerprint === current.fingerprint && selectionSnapshot(previous) === selectionSnapshot(current)) return;
+    if (this.interactionNotificationsSuppressed > 0 && current.interaction) return;
+    try {
+      if (!this.state.boundChatId) return;
+      if (current.interaction?.semantics && current.interaction.actionConfidence && current.interaction.actionConfidence >= 0.85 && current.actions.length > 0 && current.confidence >= 0.85) {
+        await this.gateway.sendChoice(this.state.boundChatId, session.paneId, current, session.agent);
+      } else if (current.state === "failed" && previous?.state !== "failed") {
+        await this.gateway.sendText(this.state.boundChatId, `${agentName} \u68C0\u6D4B\u5230\u5931\u8D25\u72B6\u6001\uFF0C\u8BF7\u7528 /tail \u67E5\u770B\u3002`);
+      } else if (current.state === "exited" && previous?.state !== "exited") {
+        await this.gateway.sendText(this.state.boundChatId, `${agentName}/tmux pane \u5DF2\u9000\u51FA\u3002`);
+      }
+    } catch (error) {
+      await this.log(`notification failed: ${errorMessage(error)}`);
+    }
+  }
+  async maybeNotifyUnresolved() {
+    const screen = this.screen;
+    const session = this.activeSession();
+    if (this.interactionNotificationsSuppressed > 0 || !screen || !session || !this.gateway || !this.state.boundChatId || screen.state !== "input" && screen.state !== "unknown" || safeStructuredInteraction(screen)) {
+      this.unresolvedCandidate = void 0;
+      return;
+    }
+    const key = `${session.id}:${session.paneId}:${screen.fingerprint}`;
+    if (this.unresolvedCandidate?.key !== key) {
+      this.unresolvedCandidate = { key, since: Date.now() };
+      return;
+    }
+    if (Date.now() - this.unresolvedCandidate.since < 3e3 || this.unresolvedNotified.has(key)) return;
+    remember(this.unresolvedNotified, key, 256);
+    try {
+      await this.gateway.sendManual(
+        this.state.boundChatId,
+        this.manualView(session, screen, "active", "\u5F53\u524D\u7EC8\u7AEF\u4EA4\u4E92\u65E0\u6CD5\u5B89\u5168\u8BC6\u522B\uFF0C\u5DF2\u81EA\u52A8\u8FDB\u5165\u624B\u52A8\u9065\u63A7\u515C\u5E95\u3002")
+      );
+    } catch (error) {
+      await this.log(`manual fallback card failed: ${errorMessage(error)}`);
+      await this.gateway.sendText(
+        this.state.boundChatId,
+        "\u5F53\u524D\u7EC8\u7AEF\u4EA4\u4E92\u65E0\u6CD5\u5B89\u5168\u8BC6\u522B\uFF0C\u4E14\u624B\u52A8\u9065\u63A7\u5361\u53D1\u9001\u5931\u8D25\u3002\u53EF\u4F7F\u7528 /tail 120\u3001/key\u3001/type \u6216 /submit \u5904\u7406\u3002"
+      ).catch((sendError) => this.log(`manual fallback text failed: ${errorMessage(sendError)}`));
+    }
+  }
+  async handleTurnComplete(candidate) {
+    if (!validTurnCompleteCandidate(candidate)) return { ok: false, error: "invalid turn-complete candidate" };
+    const eventKey = `${candidate.agentSessionId}:${candidate.eventId}`;
+    if (this.completedEvents.has(eventKey)) return { ok: true };
+    remember(this.completedEvents, eventKey, 256);
+    if (candidate.sessionId !== this.state.activeSessionId) return { ok: true };
+    if (!this.activeSession() || !this.state.boundChatId || !this.gateway) return { ok: true };
+    this.pendingCompletion = candidate;
+    this.pendingCompletionAt = Date.now();
+    return { ok: true };
+  }
+  updateScreen(next) {
+    if (this.screen?.fingerprint !== next.fingerprint || this.screen.state !== next.state) {
+      this.outputStableSince = Date.now();
+    }
+    this.screen = next;
+  }
+  async maybeNotifyCompletion() {
+    const candidate = this.pendingCompletion;
+    const session = this.activeSession();
+    if (!candidate || !session || !this.state.boundChatId || !this.gateway) return;
+    if (this.screen?.state === "approval" || this.screen?.state === "input" || this.screen?.state === "failed" || this.screen?.state === "exited") {
+      this.clearPendingCompletion();
+      return;
+    }
+    if (this.screen?.state !== "idle") return;
+    const quietSince = Math.max(this.pendingCompletionAt, this.outputStableSince);
+    if (Date.now() - quietSince < this.completionQuietMs) return;
+    this.clearPendingCompletion();
+    const adapter = getAgentAdapter(session.agent);
+    const output = candidate.lastAssistantMessage.trim();
+    if (!output) return;
+    await this.gateway.sendMarkdown(
+      this.state.boundChatId,
+      `**${adapter.displayName} \u7B49\u5F85\u7528\u6237\u8F93\u5165**
+
+${output}`
+    );
+  }
+  clearPendingCompletion() {
+    this.pendingCompletion = void 0;
+    this.pendingCompletionAt = 0;
+  }
+  async flushPending() {
+    const session = this.activeSession();
+    if (!session || this.shouldQueueMessage()) return;
+    while (this.pendingMessages.length > 0 && !this.shouldQueueMessage()) {
+      const message = this.pendingMessages[0];
+      if (!message) {
+        this.pendingMessages.shift();
+        continue;
+      }
+      this.clearPendingCompletion();
+      await this.tmux.sendText(session.paneId, message);
+      this.pendingMessages.shift();
+    }
+    if (this.pendingMessages.length === 0 && this.state.boundChatId) {
+    }
+  }
+  activeSession() {
+    return this.state.activeSessionId ? this.state.sessions?.[this.state.activeSessionId] : void 0;
+  }
+  async reconcileSessions() {
+    const sessions = Object.values(this.state.sessions ?? {});
+    const inspections = await Promise.all(sessions.map(async (session) => ({
+      session,
+      pane: await this.tmux.inspect(session.paneId)
+    })));
+    const liveSessions = inspections.filter(({ pane }) => pane && !pane.dead).map(({ session }) => session);
+    const liveById = Object.fromEntries(liveSessions.map((session) => [session.id, session]));
+    const activeSessionId = this.state.activeSessionId && liveById[this.state.activeSessionId] ? this.state.activeSessionId : liveSessions[0]?.id;
+    const sessionsChanged = liveSessions.length !== sessions.length;
+    const activeChanged = activeSessionId !== this.state.activeSessionId;
+    if (!sessionsChanged && !activeChanged) return liveSessions;
+    const removedActive = this.state.activeSessionId ? this.state.sessions?.[this.state.activeSessionId] : void 0;
+    if (activeChanged && removedActive && !liveById[removedActive.id] && this.previousScreen?.state !== "exited" && this.state.boundChatId) {
+      await this.gateway?.sendText(
+        this.state.boundChatId,
+        `${getAgentAdapter(removedActive.agent).displayName}/tmux pane \u5DF2\u9000\u51FA\u3002`
+      ).catch((error) => this.log(`exit notification failed: ${errorMessage(error)}`));
+    }
+    this.state = {
+      ...this.state,
+      sessions: liveById,
+      activeSessionId,
+      updatedAt: Date.now()
+    };
+    if (activeChanged) {
+      this.screen = void 0;
+      this.previousScreen = void 0;
+      this.completedEvents.clear();
+      this.clearPendingCompletion();
+      this.pendingMessages.length = 0;
+      this.pendingInteractionInput = void 0;
+      this.unresolvedCandidate = void 0;
+      this.unresolvedNotified.clear();
+    }
+    await this.store.saveState(this.state);
+    return liveSessions;
+  }
+  async useSession(sessionId) {
+    const session = this.state.sessions?.[sessionId];
+    if (!session || !await this.tmux.inspect(session.paneId)) return { ok: false, error: `unknown or stopped session: ${sessionId}` };
+    this.state = { ...this.state, activeSessionId: sessionId, updatedAt: Date.now() };
+    this.screen = void 0;
+    this.previousScreen = void 0;
+    this.completedEvents.clear();
+    this.clearPendingCompletion();
+    this.pendingMessages.length = 0;
+    this.pendingInteractionInput = void 0;
+    this.unresolvedCandidate = void 0;
+    this.unresolvedNotified.clear();
+    await this.store.saveState(this.state);
+    await this.poll();
+    return { ok: true, value: session };
+  }
+  async log(message) {
+    await appendFile(this.paths.logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
+`, { mode: 384 });
+  }
+};
+function fail(error) {
+  return { ok: false, error: error instanceof Error ? error.message : String(error) };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isAlreadyExists(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+}
+function validSessionId(value) {
+  return /^[a-zA-Z0-9_-]{1,40}$/.test(value);
+}
+function remember(values, value, limit) {
+  values.add(value);
+  while (values.size > limit) {
+    const oldest = values.values().next().value;
+    if (oldest === void 0) break;
+    values.delete(oldest);
+  }
+}
+function escapeFence2(value) {
+  return value.replace(/```/g, "``\\`");
+}
+function selectionSnapshot(screen) {
+  return screen.actions.map(({ id, marker, inputValue }) => `${id}:${marker ?? ""}:${inputValue ?? ""}`).join("|");
+}
+function formChecked(value) {
+  return value === true || value === 1 || value === "true" || value === "1" || value === "on" || value === "checked";
+}
+function safeStructuredInteraction(screen) {
+  return Boolean(
+    screen.interaction?.semantics && screen.interaction.actionConfidence && screen.interaction.actionConfidence >= 0.85 && screen.actions.length > 0 && screen.confidence >= 0.85
+  );
+}
+function manualTmuxKey(value) {
+  const keys = {
+    up: "Up",
+    down: "Down",
+    left: "Left",
+    right: "Right",
+    enter: "Enter",
+    esc: "Escape",
+    tab: "Tab",
+    space: "Space",
+    backspace: "BSpace",
+    "ctrl-c": "C-c"
+  };
+  const key = keys[value.toLowerCase()];
+  if (!key) throw new Error(`\u4E0D\u652F\u6301\u7684\u624B\u52A8\u6309\u952E\uFF1A${value}`);
+  return key;
+}
+function manualTimestamp() {
+  return new Intl.DateTimeFormat("zh-CN", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  }).format(/* @__PURE__ */ new Date());
+}
+
+// src/core/paths.ts
+import { homedir as homedir2 } from "os";
+import { join } from "path";
+function resolveAppPaths(root = process.env.LARK_CODING_ASSISTANT_HOME) {
+  const base = root || join(homedir2(), ".lark-coding-assistant");
+  return {
+    root: base,
+    config: join(base, "config.json"),
+    secrets: join(base, "secrets.json"),
+    state: join(base, "state.json"),
+    logsDir: join(base, "logs"),
+    logFile: join(base, "logs", "assistant.log"),
+    runtimeDir: join(base, "runtime"),
+    socket: join(base, "runtime", "daemon.sock"),
+    pid: join(base, "runtime", "daemon.pid")
+  };
+}
+
+// src/daemon-entry.ts
+import { readFile as readFile3 } from "fs/promises";
+var paths = resolveAppPaths();
+var packageInfo = JSON.parse(
+  await readFile3(new URL("../package.json", import.meta.url), "utf8")
+);
+var daemon = new AssistantDaemon(
+  new AppStore(paths),
+  paths,
+  void 0,
+  void 0,
+  void 0,
+  void 0,
+  packageInfo.version
+);
+try {
+  await daemon.start();
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+      console.error(`${(/* @__PURE__ */ new Date()).toISOString()} daemon received ${signal}; shutting down`);
+      void daemon.close().finally(() => process.exit(0));
+    });
+  }
+} catch (error) {
+  console.error(`${(/* @__PURE__ */ new Date()).toISOString()} daemon crashed during startup`, error);
+  process.exitCode = 1;
+}
+process.on("uncaughtException", (error) => {
+  console.error(`${(/* @__PURE__ */ new Date()).toISOString()} daemon uncaught exception`, error);
+  process.exit(1);
+});
+process.on("unhandledRejection", (error) => {
+  console.error(`${(/* @__PURE__ */ new Date()).toISOString()} daemon unhandled rejection`, error);
+  process.exit(1);
+});
+//# sourceMappingURL=daemon-entry.js.map