dsh-lark-bot 0.2.7 → 0.3.0

package/dist/cli.js

@@ -1,111 +1,87 @@
-// src/cli.ts
-import { readFileSync } from "fs";
-import { Command } from "commander";
-
-// src/cli/commands/doctor.ts
-import { stat } from "fs/promises";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// src/adapters/dsh/availability.ts
-import { spawn } from "cross-spawn";
-import { existsSync } from "fs";
-async function checkDshAvailability(options) {
-  const timeoutMs = options.timeoutMs ?? 5e3;
-  const versionArgs = options.command === "node" && options.args?.[0] && existsSync(options.args[0]) ? [options.args[0], "--version"] : ["--version"];
-  return new Promise((resolve4) => {
-    const child = spawn(options.command, versionArgs, {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    const finish = (result) => {
-      if (settled) return;
-      settled = true;
-      resolve4(result);
-    };
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL");
-      finish({ ok: false, error: `timed out after ${timeoutMs}ms`, version: void 0 });
-    }, timeoutMs);
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString("utf8");
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString("utf8");
-    });
-    child.on("error", (error) => {
-      clearTimeout(timer);
-      finish({ ok: false, error: error.message, version: void 0 });
-    });
-    child.on("exit", (code) => {
-      clearTimeout(timer);
-      const version = stdout.trim();
-      if (code !== 0 && !version) {
-        finish({ ok: false, error: stderr.trim() || `exited with code ${String(code)}`, version: void 0 });
-        return;
+// src/adapters/dsh/event-channel.ts
+var EventChannel;
+var init_event_channel = __esm({
+  "src/adapters/dsh/event-channel.ts"() {
+    "use strict";
+    EventChannel = class _EventChannel {
+      static END = /* @__PURE__ */ Symbol("event-channel-end");
+      queue = [];
+      waiters = [];
+      closed = false;
+      push(event) {
+        if (this.closed) return;
+        const waiter = this.waiters.shift();
+        if (waiter) {
+          waiter(event);
+        } else {
+          this.queue.push(event);
+        }
       }
-      finish({ ok: true, error: void 0, version: version || void 0 });
-    });
-  });
-}
-
-// src/config/app-paths.ts
-import { homedir } from "os";
-import { join, resolve } from "path";
-function defaultHome() {
-  const override = process.env.DSH_LARK_HOME?.trim();
-  return override ? resolve(override) : join(homedir(), ".dsh-lark");
-}
-function resolveAppPaths(root = defaultHome()) {
-  const profileDir = (profile) => join(root, "profiles", profile);
-  const profilePath = (profile, ...parts) => join(profileDir(profile), ...parts);
-  return {
-    root,
-    configFile: join(root, "config.json"),
-    activeProfileFile: join(root, "active-profile"),
-    profileDir,
-    profilePath,
-    sessionsFile: (profile) => profilePath(profile, "sessions.json"),
-    sessionCatalogFile: (profile) => profilePath(profile, "sessions.json.catalog.json"),
-    workspacesFile: (profile) => profilePath(profile, "workspaces.json"),
-    mediaDir: (profile) => profilePath(profile, "media"),
-    logsDir: (profile) => profilePath(profile, "logs"),
-    registryFile: join(root, "registry", "processes.json"),
-    locksDir: join(root, "registry", "locks")
-  };
-}
-
-// src/config/env.ts
-import { join as join3, resolve as resolve2 } from "path";
-import { homedir as homedir2 } from "os";
+      close() {
+        if (this.closed) return;
+        this.closed = true;
+        for (const waiter of this.waiters.splice(0)) {
+          waiter(_EventChannel.END);
+        }
+      }
+      async *[Symbol.asyncIterator]() {
+        for (; ; ) {
+          if (this.closed && this.queue.length === 0) return;
+          const queued = this.queue.shift();
+          if (queued !== void 0) {
+            yield queued;
+            continue;
+          }
+          const value = await new Promise((resolve5) => {
+            this.waiters.push(resolve5);
+          });
+          if (value === _EventChannel.END) return;
+          yield value;
+        }
+      }
+    };
+  }
+});
 
 // src/config/dsh-runtime.ts
 import { existsSync as existsSync2, readdirSync } from "fs";
-import { join as join2 } from "path";
-var DS_HARNESS_RELATIVE = join2("@deepseek-ai", "dsh", "lib", "bin.js");
+import { join } from "path";
+function resolveDshHome(home, env = process.env) {
+  return env.DSH_HOME?.trim() || join(home, ".dsh");
+}
 function firstExisting(...paths) {
   return paths.find((path) => existsSync2(path));
 }
 function children(root) {
   try {
-    return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => join2(root, entry.name));
+    return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => join(root, entry.name));
   } catch {
     return [];
   }
 }
 function discoverDshBin(home, env = process.env) {
-  const dshHome = env.DSH_HOME?.trim() || join2(home, ".dsh");
+  const dshHome = resolveDshHome(home, env);
   const candidates = [
-    join2(dshHome, "profiles", "node_modules", DS_HARNESS_RELATIVE),
-    join2(home, ".npm", "_npx", "node_modules", DS_HARNESS_RELATIVE),
-    join2(home, ".cache", "pnpm", "dlx", "node_modules", DS_HARNESS_RELATIVE),
-    join2(home, ".local", "share", "pnpm", "node_modules", DS_HARNESS_RELATIVE)
+    join(dshHome, "profiles", "node_modules", DS_HARNESS_RELATIVE),
+    join(home, ".npm", "_npx", "node_modules", DS_HARNESS_RELATIVE),
+    join(home, ".cache", "pnpm", "dlx", "node_modules", DS_HARNESS_RELATIVE),
+    join(home, ".local", "share", "pnpm", "node_modules", DS_HARNESS_RELATIVE)
   ];
   const direct = firstExisting(...candidates);
   if (direct) return direct;
-  for (const root of [join2(home, ".npm", "_npx"), join2(home, ".cache", "pnpm", "dlx")]) {
+  for (const root of [join(home, ".npm", "_npx"), join(home, ".cache", "pnpm", "dlx")]) {
     for (const child of children(root)) {
-      const path = join2(child, "node_modules", DS_HARNESS_RELATIVE);
+      const path = join(child, "node_modules", DS_HARNESS_RELATIVE);
       if (existsSync2(path)) return path;
     }
   }
@@ -131,271 +107,540 @@ function resolveDshRuntime(input) {
     args: ["--profile", "headless"]
   };
 }
-
-// src/config/env.ts
-var DEFAULTS = {
-  tenant: "feishu",
-  provider: "deepseek-official",
-  model: "deepseek-v4-flash",
-  runTimeoutMs: 3e5,
-  stopGraceMs: 5e3
-};
-function nonEmpty(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : void 0;
-}
-function parseTenant(value) {
-  const tenant = nonEmpty(value) ?? DEFAULTS.tenant;
-  if (tenant !== "feishu" && tenant !== "lark") {
-    throw new Error(`DSH_LARK_TENANT must be "feishu" or "lark", got "${tenant}"`);
+var DS_HARNESS_RELATIVE;
+var init_dsh_runtime = __esm({
+  "src/config/dsh-runtime.ts"() {
+    "use strict";
+    DS_HARNESS_RELATIVE = join("@deepseek-ai", "dsh", "lib", "bin.js");
   }
-  return tenant;
+});
+
+// src/adapters/dsh/acp-runtime.ts
+import { spawn as spawn4 } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
+function acpProfileRoot(home, profile, env) {
+  return join3(resolveDshHome(home, env), "profiles", profile);
+}
+function packageJsonFor2(profile) {
+  return `${JSON.stringify(
+    {
+      name: `dsh-profile-${profile}`,
+      private: true,
+      dependencies: {
+        [ACP_PACKAGE]: ACP_VERSION
+      },
+      dsh: {
+        profile: {
+          bundles: [ACP_BASE_BUNDLE]
+        }
+      }
+    },
+    null,
+    2
+  )}
+`;
 }
-function parseDshArgs(value) {
-  const raw = value?.trim();
-  if (!raw) return [];
-  return raw.split(",").map((item) => item.trim()).filter(Boolean);
+function acpPatchYaml(provider, model) {
+  return [
+    "# dsh-lark ACP JSON-RPC runtime overlay (managed by dsh-lark-bot).",
+    "# stdout is reserved for ACP JSON-RPC frames; no console logger may load.",
+    "- insert:",
+    "    - id: acp",
+    `      name: '${ACP_PACKAGE}'`,
+    "      config:",
+    `        provider: ${provider}`,
+    `        model: ${model}`,
+    "",
+    "# Unattended IM runtime: interactive user questions cannot be answered",
+    "# through Feishu, so the tool is disabled (default-deny).",
+    "- id: user-questions",
+    "  disabled: true",
+    "",
+    "- id: system-prompt",
+    "  config:",
+    "    persona: >-",
+    "      You are a coding agent powered by the {{model}} model. Your working directory is {{cwd}}.",
+    "",
+    "- id: hmr",
+    "  disabled: true",
+    ""
+  ].join("\n");
 }
-function parseTimeout(value) {
-  const raw = value?.trim();
-  if (!raw) return DEFAULTS.runTimeoutMs;
-  const parsed = Number(raw);
-  if (!Number.isInteger(parsed) || parsed < 0) {
-    throw new Error(`DSH_LARK_RUN_TIMEOUT_MS must be a non-negative integer, got "${raw}"`);
-  }
-  return parsed;
+function acpPluginInstalled(profileRoot) {
+  const candidates = [
+    join3(profileRoot, "node_modules", ACP_PACKAGE),
+    join3(profileRoot, "..", "node_modules", ACP_PACKAGE)
+  ];
+  return candidates.some((path) => existsSync4(path));
 }
-function parseStopGrace(value) {
-  const raw = value?.trim();
-  if (!raw) return DEFAULTS.stopGraceMs;
-  const parsed = Number(raw);
-  if (!Number.isInteger(parsed) || parsed < 0) {
-    throw new Error(`DSH_LARK_STOP_GRACE_MS must be a non-negative integer, got "${raw}"`);
-  }
-  return parsed;
+function isAcpProfileReady(profileRoot) {
+  return existsSync4(join3(profileRoot, "package.json")) && existsSync4(join3(profileRoot, "cordis.yml")) && existsSync4(join3(profileRoot, "cordis.patch.yml")) && acpPluginInstalled(profileRoot);
 }
-function loadRuntimeEnv(source = process.env) {
-  const homeOverride = nonEmpty(source.DSH_LARK_HOME);
-  const workspace = nonEmpty(source.DSH_LARK_WORKSPACE);
-  const home = homeOverride ? resolve2(homeOverride) : join3(homedir2(), ".dsh-lark");
-  const osHome = homedir2();
-  const dshCommand = nonEmpty(source.DSH_LARK_DSH_COMMAND);
-  const rawDshArgs = nonEmpty(source.DSH_LARK_DSH_ARGS);
-  const dshRuntime = resolveDshRuntime({
-    home: osHome,
-    env: source,
-    ...dshCommand ? { command: dshCommand } : {},
-    ...rawDshArgs ? { args: parseDshArgs(rawDshArgs) } : {}
+function runPnpmInstall2(profileRoot) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn4("pnpm", ["install"], {
+      cwd: profileRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    child.stdout.on("data", (chunk) => {
+      output += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      output += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve5();
+        return;
+      }
+      const tail = output.trim().split("\n").slice(-8).join("\n");
+      reject(new Error(`pnpm install exited with code ${String(code)}
+${tail}`));
+    });
   });
-  return {
-    home,
-    tenant: parseTenant(source.DSH_LARK_TENANT),
-    appId: nonEmpty(source.DSH_LARK_APP_ID),
-    appSecret: nonEmpty(source.DSH_LARK_APP_SECRET),
-    workspace: workspace ? resolve2(workspace) : void 0,
-    dshCommand: dshRuntime.command,
-    dshArgs: dshRuntime.args,
-    provider: nonEmpty(source.DSH_LARK_PROVIDER) ?? DEFAULTS.provider,
-    model: nonEmpty(source.DSH_LARK_MODEL) ?? DEFAULTS.model,
-    runTimeoutMs: parseTimeout(source.DSH_LARK_RUN_TIMEOUT_MS),
-    stopGraceMs: parseStopGrace(source.DSH_LARK_STOP_GRACE_MS)
-  };
 }
-
-// src/config/profile-store.ts
-import { readFile } from "fs/promises";
-import { mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
-
-// src/platform/atomic-write.ts
-import { randomBytes } from "crypto";
-import { mkdir, rename, writeFile } from "fs/promises";
-import { dirname, join as join4 } from "path";
-async function writeFileAtomic(target, data, options = {}) {
-  const directory = dirname(target);
-  await mkdir(directory, { recursive: true });
-  const temporary = join4(directory, `.${randomBytes(8).toString("hex")}.tmp`);
+async function ensureAcpProfile(options) {
+  const profile = options.profile ?? DEFAULT_ACP_PROFILE;
+  const root = acpProfileRoot(options.home, profile, options.env);
+  const provider = options.provider ?? "deepseek-official";
+  const model = options.model ?? "deepseek-v4-flash";
+  const ready = isAcpProfileReady(root);
   try {
-    await writeFile(temporary, data, options.mode === void 0 ? void 0 : { mode: options.mode });
-    await rename(temporary, target);
+    if (!ready) {
+      await mkdir2(root, { recursive: true });
+      await writeFile2(join3(root, "package.json"), packageJsonFor2(profile), "utf8");
+      await writeFile2(join3(root, "cordis.yml"), "[]\n", "utf8");
+      await writeFile2(join3(root, "cordis.patch.yml"), acpPatchYaml(provider, model), "utf8");
+      const install = options.install ?? runPnpmInstall2;
+      await install(root);
+      if (!isAcpProfileReady(root)) {
+        return {
+          ok: false,
+          created: true,
+          error: `${ACP_PACKAGE}@${ACP_VERSION} was not found after install`
+        };
+      }
+    }
+    await writeFile2(join3(root, "cordis.patch.yml"), acpPatchYaml(provider, model), "utf8");
+    return { ok: true, created: !ready };
   } catch (error) {
-    await rmSilently(temporary);
-    throw error;
+    return {
+      ok: false,
+      created: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
 }
-async function rmSilently(path) {
-  const { rm } = await import("fs/promises");
-  try {
-    await rm(path, { force: true });
-  } catch {
+function resolveAcpLaunch(options) {
+  const profile = options.profile ?? DEFAULT_ACP_PROFILE;
+  if (options.command || options.args) {
+    return {
+      command: options.command ?? "node",
+      args: options.args ?? ["--profile", profile],
+      profile
+    };
+  }
+  const bin = options.bin ?? discoverDshBin(options.home, options.env);
+  if (bin) {
+    return { command: "node", args: [bin, "--profile", profile], profile };
   }
+  return { command: "dsh", args: ["--profile", profile], profile };
 }
-
-// src/config/profile-store.ts
-var ConfigStore = class {
-  constructor(path) {
-    this.path = path;
+var ACP_PACKAGE, ACP_VERSION, ACP_BASE_BUNDLE, DEFAULT_ACP_PROFILE;
+var init_acp_runtime = __esm({
+  "src/adapters/dsh/acp-runtime.ts"() {
+    "use strict";
+    init_dsh_runtime();
+    ACP_PACKAGE = "@deepseek-ai/dsh-acp";
+    ACP_VERSION = "0.1.0-rc.6";
+    ACP_BASE_BUNDLE = "@deepseek-ai/dsh-base";
+    DEFAULT_ACP_PROFILE = "dsh-lark-acp";
   }
-  path;
-  data;
-  async load() {
-    try {
-      const raw = await readFile(this.path, "utf8");
-      const parsed = JSON.parse(raw);
-      this.data = {
-        schemaVersion: 1,
-        activeProfile: parsed.activeProfile ?? "default",
-        profiles: Object.fromEntries(
-          Object.entries(parsed.profiles ?? {}).map(([name, profile]) => [
-            name,
-            {
-              ...profile,
-              access: {
-                allowedUsers: profile.access?.allowedUsers ?? [],
-                allowedChats: profile.access?.allowedChats ?? [],
-                admins: profile.access?.admins ?? []
-              }
-            }
-          ])
-        )
-      };
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-      this.data = {
-        schemaVersion: 1,
-        activeProfile: "default",
-        profiles: {}
-      };
+});
+
+// src/adapters/dsh/acp-adapter.ts
+var acp_adapter_exports = {};
+__export(acp_adapter_exports, {
+  AcpDshAdapter: () => AcpDshAdapter,
+  buildAcpAgentAdapter: () => buildAcpAgentAdapter,
+  translateAcpUpdate: () => translateAcpUpdate
+});
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  spawn as defaultSpawn
+} from "child_process";
+import { homedir } from "os";
+import { Readable as NodeReadable, Writable as NodeWritable } from "stream";
+import {
+  ClientSideConnection,
+  ndJsonStream,
+  PROTOCOL_VERSION
+} from "@agentclientprotocol/sdk";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textOfContent(content) {
+  if (!isRecord3(content) || typeof content.text !== "string") return "";
+  return content.text;
+}
+function translateAcpUpdate(notification) {
+  const update = notification.update;
+  if (!isRecord3(update)) return [];
+  switch (update.sessionUpdate) {
+    case "agent_message_chunk":
+      return textOfContent(update.content) ? [{ type: "text", delta: textOfContent(update.content) }] : [];
+    case "agent_thought_chunk":
+      return textOfContent(update.content) ? [{ type: "thinking", delta: textOfContent(update.content) }] : [];
+    case "tool_call": {
+      if (typeof update.toolCallId !== "string") return [];
+      return [
+        {
+          type: "tool_use",
+          id: update.toolCallId,
+          name: typeof update.title === "string" ? update.title : "tool",
+          input: update.rawInput ?? {}
+        }
+      ];
     }
-    return this.data;
+    default:
+      return [];
   }
-  getActiveProfile() {
-    const data = this.getData();
-    return data.profiles[data.activeProfile];
+}
+function mapApprovalOutcome(outcome, options) {
+  if (outcome === "cancelled") {
+    return { outcome: { outcome: "cancelled" } };
   }
-  getProfile(name) {
-    const data = this.getData();
-    return data.profiles[name];
+  const wanted = outcome === "allowed-once" ? "allow_once" : "reject_once";
+  const option = options.find((item) => item.kind === wanted);
+  if (!option) return { outcome: { outcome: "cancelled" } };
+  return { outcome: { outcome: "selected", optionId: option.optionId } };
+}
+function buildPromptText2(prompt, images) {
+  return images?.length ? `${prompt}
+
+Image files attached to this message:
+${images.join("\n")}` : prompt;
+}
+function waitForChildExit2(child, timeoutMs) {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return Promise.resolve({ code: child.exitCode, timedOut: false });
   }
-  async saveProfile(name, input) {
-    const data = this.getData();
-    const existing = data.profiles[name];
-    const profile = {
-      schemaVersion: 1,
-      agentKind: "dsh",
-      tenant: input.tenant,
-      accounts: {
-        appId: input.appId,
-        appSecret: input.appSecret
-      },
-      workspaces: {
-        default: input.workspace ?? existing?.workspaces.default ?? void 0
-      },
-      preferences: {
-        model: input.model ?? existing?.preferences.model ?? void 0,
-        stopGraceMs: input.stopGraceMs ?? existing?.preferences.stopGraceMs ?? void 0,
-        runTimeoutMs: input.runTimeoutMs ?? existing?.preferences.runTimeoutMs ?? void 0
+  return new Promise((resolve5) => {
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+      child.removeListener("exit", onExit);
+      resolve5({ code: child.exitCode, timedOut: true });
+    }, timeoutMs) : void 0;
+    const onExit = (code) => {
+      if (timer !== void 0) clearTimeout(timer);
+      resolve5({ code, timedOut: false });
+    };
+    child.once("exit", onExit);
+  });
+}
+async function disposeChild(child, graceMs) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  child.stdin?.end();
+  if (!(await waitForChildExit2(child, graceMs)).timedOut) return;
+  child.kill("SIGTERM");
+  if (!(await waitForChildExit2(child, graceMs)).timedOut) return;
+  child.kill("SIGKILL");
+}
+function withTimeout(promise, timeoutMs) {
+  return new Promise((resolve5, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`ACP probe timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve5(value);
       },
-      access: {
-        allowedUsers: input.access?.allowedUsers ?? existing?.access?.allowedUsers ?? [],
-        allowedChats: input.access?.allowedChats ?? existing?.access?.allowedChats ?? [],
-        admins: input.access?.admins ?? existing?.access?.admins ?? []
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
       }
-    };
-    if (input.operatorOpenId && !profile.access.allowedUsers.includes(input.operatorOpenId)) {
-      profile.access.allowedUsers.push(input.operatorOpenId);
-      profile.access.admins.push(input.operatorOpenId);
-    }
-    data.profiles[name] = profile;
-    data.activeProfile = name;
-    await this.persist();
-  }
-  getData() {
-    if (!this.data) {
-      throw new Error("ConfigStore must be loaded before use");
-    }
-    return this.data;
-  }
-  async persist() {
-    const data = this.getData();
-    await mkdir2(dirname2(this.path), { recursive: true });
-    await writeFileAtomic(this.path, `${JSON.stringify(data, null, 2)}
-`, {
-      mode: 384
-    });
-  }
-};
-
-// src/cli/commands/doctor.ts
-async function runDoctor(options) {
-  const env = loadRuntimeEnv({
-    ...process.env,
-    ...options.workspace ? { DSH_LARK_WORKSPACE: options.workspace } : {},
-    ...options.tenant ? { DSH_LARK_TENANT: options.tenant } : {},
-    ...options.appId ? { DSH_LARK_APP_ID: options.appId } : {},
-    ...options.appSecret ? { DSH_LARK_APP_SECRET: options.appSecret } : {}
+    );
   });
-  const paths = resolveAppPaths(env.home);
-  const profileName = options.profile ?? "default";
-  const store = new ConfigStore(paths.configFile);
-  await store.load();
-  const profile = store.getProfile(profileName);
-  const lines = [
-    "dsh-lark-bot doctor",
-    `version: ${options.version ?? "unknown"}`,
-    `node: ${process.version}`,
-    `profile: ${profileName}`,
-    `home: ${paths.root}`,
-    `dsh_command: ${env.dshCommand}`,
-    `dsh_args: ${env.dshArgs.join(",")}`
-  ];
-  let critical = false;
-  if (!profile) {
-    lines.push("config: missing");
-    critical = true;
-  } else {
-    lines.push(
-      [
-        "config: ok",
-        `tenant=${profile.tenant}`,
-        `app_id=${profile.accounts.appId}`,
-        `app_secret=${profile.accounts.appSecret ? "present" : "missing"}`,
-        `allowed_users=${profile.access.allowedUsers.length}`,
-        `allowed_chats=${profile.access.allowedChats.length}`
-      ].join(" ")
+}
+async function buildAcpAgentAdapter(env, preferences) {
+  const runtimeOptions = {
+    home: homedir(),
+    env: process.env,
+    provider: env.provider,
+    model: preferences.model ?? env.model,
+    ...env.dshExplicit ? { command: env.dshCommand, args: env.dshArgs } : {}
+  };
+  const ensure = await ensureAcpProfile(runtimeOptions);
+  if (!ensure.ok) {
+    throw new Error(
+      `ACP runtime profile setup failed: ${ensure.error ?? "unknown error"} (install pnpm, or set DSH_LARK_ADAPTER=headless for the legacy adapter)`
     );
-    if (!profile.accounts.appId || !profile.accounts.appSecret) critical = true;
-  }
-  const workspace = options.workspace ?? profile?.workspaces.default ?? env.workspace ?? paths.profilePath(profileName, "workspace");
-  try {
-    const info = await stat(workspace);
-    lines.push(`workspace: ${workspace} (${info.isDirectory() ? "directory" : "not-directory"})`);
-  } catch {
-    lines.push(`workspace: ${workspace} (missing)`);
   }
-  const availability = await checkDshAvailability({
-    command: env.dshCommand,
-    args: env.dshArgs
+  const launch = resolveAcpLaunch(runtimeOptions);
+  return new AcpDshAdapter({
+    launch,
+    provider: env.provider,
+    model: preferences.model ?? env.model
   });
-  if (availability.ok) {
-    lines.push(`dsh: ok${availability.version ? ` (${availability.version})` : ""}`);
-  } else {
-    lines.push(`dsh: unavailable (${availability.error ?? "unknown"})`);
-    critical = true;
-  }
-  const output = options.output ?? ((text) => process.stdout.write(text));
-  output(`${lines.join("\n")}
-`);
-  if (critical) process.exitCode = 1;
 }
+var AcpDshAdapter;
+var init_acp_adapter = __esm({
+  "src/adapters/dsh/acp-adapter.ts"() {
+    "use strict";
+    init_acp_runtime();
+    init_event_channel();
+    AcpDshAdapter = class {
+      id = "dsh-acp";
+      displayName = "DeepSeek Harness (ACP)";
+      launch;
+      model;
+      probeTimeoutMs;
+      spawn;
+      stopGraceMs;
+      constructor(options) {
+        this.launch = options.launch;
+        this.model = options.model;
+        this.probeTimeoutMs = options.probeTimeoutMs ?? 15e3;
+        this.spawn = options.spawn;
+        this.stopGraceMs = 5e3;
+      }
+      async isAvailable() {
+        return (await this.checkAvailability()).ok;
+      }
+      async checkAvailability() {
+        const child = this.spawnChild(process.cwd());
+        if (!child.stdin || !child.stdout) {
+          await disposeChild(child, this.stopGraceMs);
+          return { ok: false, error: "ACP child did not expose protocol streams", version: void 0 };
+        }
+        const conn = new ClientSideConnection(
+          () => ({
+            requestPermission: () => Promise.resolve({ outcome: { outcome: "cancelled" } }),
+            sessionUpdate: () => Promise.resolve()
+          }),
+          ndJsonStream(
+            NodeWritable.toWeb(child.stdin),
+            NodeReadable.toWeb(child.stdout)
+          )
+        );
+        try {
+          const info = await withTimeout(
+            conn.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} }),
+            this.probeTimeoutMs
+          );
+          const name = info.agentInfo?.name ?? "deepseek-harness-acp";
+          const version = info.agentInfo?.version ?? "unknown";
+          return { ok: true, error: void 0, version: `${name}@${version}` };
+        } catch (error) {
+          return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+            version: void 0
+          };
+        } finally {
+          await disposeChild(child, this.stopGraceMs);
+        }
+      }
+      run(options) {
+        const cwd = options.cwd ?? process.cwd();
+        const model = options.model ?? this.model;
+        const stopRequested = { value: false };
+        const channel = new EventChannel();
+        const child = this.spawnChild(cwd);
+        let serverSessionId;
+        let conn;
+        let hadError = false;
+        const clientSessionId = `acp-${randomUUID2().replaceAll("-", "")}`;
+        const makeClient = (_agent) => ({
+          sessionUpdate: async (notification) => {
+            for (const event of translateAcpUpdate(notification)) {
+              if (event.type === "error") hadError = true;
+              channel.push(event);
+            }
+          },
+          requestPermission: async (request) => {
+            if (!options.onApprovalRequest) {
+              return { outcome: { outcome: "cancelled" } };
+            }
+            const approval = {
+              id: request.toolCall.toolCallId,
+              sessionId: request.sessionId,
+              toolName: typeof request.toolCall.title === "string" ? request.toolCall.title : "tool",
+              reason: void 0,
+              options: request.options.map((item) => ({
+                optionId: item.optionId,
+                name: item.name,
+                kind: item.kind
+              }))
+            };
+            const outcome = await options.onApprovalRequest(approval);
+            return mapApprovalOutcome(outcome, request.options);
+          }
+        });
+        const task = (async () => {
+          if (!child.stdin || !child.stdout) {
+            throw new Error("ACP child did not expose protocol streams");
+          }
+          conn = new ClientSideConnection(
+            makeClient,
+            ndJsonStream(
+              NodeWritable.toWeb(child.stdin),
+              NodeReadable.toWeb(child.stdout)
+            )
+          );
+          await conn.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} });
+          const created = await conn.newSession({ cwd, mcpServers: [] });
+          serverSessionId = created.sessionId;
+          const blocks = [
+            { type: "text", text: buildPromptText2(options.prompt, options.images) }
+          ];
+          const response = await conn.prompt({ sessionId: serverSessionId, prompt: blocks });
+          if (response.stopReason === "cancelled") {
+            if (!stopRequested.value) {
+              channel.push({ type: "error", message: "ACP turn cancelled", terminationReason: "interrupted" });
+              hadError = true;
+            }
+            return;
+          }
+          if (response.stopReason === "refusal" || response.stopReason === "max_turn_requests") {
+            channel.push({
+              type: "error",
+              message: `ACP turn stopped with reason: ${response.stopReason}`,
+              terminationReason: "failed"
+            });
+            hadError = true;
+            return;
+          }
+          if (response.usage) {
+            const usage = {
+              type: "usage",
+              ...typeof response.usage.inputTokens === "number" ? { inputTokens: response.usage.inputTokens } : {},
+              ...typeof response.usage.outputTokens === "number" ? { outputTokens: response.usage.outputTokens } : {}
+            };
+            channel.push(usage);
+          }
+        })().catch((error) => {
+          if (!stopRequested.value) {
+            channel.push({
+              type: "error",
+              message: error instanceof Error ? error.message : String(error),
+              terminationReason: "failed"
+            });
+            hadError = true;
+          }
+        }).finally(() => {
+          channel.close();
+        });
+        async function* events() {
+          yield {
+            type: "system",
+            sessionId: clientSessionId,
+            cwd,
+            model
+          };
+          for await (const event of channel) {
+            yield event;
+          }
+          await task;
+          if (!hadError) {
+            yield {
+              type: "done",
+              sessionId: clientSessionId,
+              terminationReason: stopRequested.value ? "interrupted" : "normal"
+            };
+          }
+        }
+        return {
+          runId: options.runId,
+          events: events(),
+          stop: async () => {
+            stopRequested.value = true;
+            if (conn && serverSessionId !== void 0) {
+              try {
+                await conn.cancel({ sessionId: serverSessionId });
+              } catch {
+              }
+            }
+            await disposeChild(child, this.stopGraceMs);
+          },
+          waitForExit: (timeoutMs) => waitForChildExit2(child, timeoutMs).then((result) => !result.timedOut && result.code !== null)
+        };
+      }
+      spawnChild(cwd) {
+        const spawnFn = this.spawn ?? defaultSpawn;
+        return spawnFn(this.launch.command, this.launch.args, {
+          cwd,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      }
+    };
+  }
+});
 
-// src/cli/commands/start.ts
-import { mkdir as mkdir5 } from "fs/promises";
+// src/cli.ts
+import { readFileSync } from "fs";
+import { Command } from "commander";
+
+// src/cli/commands/doctor.ts
+import { stat } from "fs/promises";
+
+// src/adapters/index.ts
+import { homedir as homedir2 } from "os";
 
 // src/adapters/dsh/adapter.ts
 import { spawn as spawn2 } from "cross-spawn";
 import { createInterface } from "readline";
 
+// src/adapters/dsh/availability.ts
+import { spawn } from "cross-spawn";
+import { existsSync } from "fs";
+async function checkDshAvailability(options) {
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const versionArgs = options.command === "node" && options.args?.[0] && existsSync(options.args[0]) ? [options.args[0], "--version"] : ["--version"];
+  return new Promise((resolve5) => {
+    const child = spawn(options.command, versionArgs, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve5(result);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish({ ok: false, error: `timed out after ${timeoutMs}ms`, version: void 0 });
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      finish({ ok: false, error: error.message, version: void 0 });
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      const version = stdout.trim();
+      if (code !== 0 && !version) {
+        finish({ ok: false, error: stderr.trim() || `exited with code ${String(code)}`, version: void 0 });
+        return;
+      }
+      finish({ ok: true, error: void 0, version: version || void 0 });
+    });
+  });
+}
+
 // src/adapters/dsh/translate.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -598,14 +843,14 @@ async function waitForExitResult(child, timeoutMs) {
   if (child.exitCode !== null || child.signalCode !== null) {
     return { code: child.exitCode, timedOut: false };
   }
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const onExit = (code) => {
       if (timer !== void 0) clearTimeout(timer);
-      resolve4({ code, timedOut: false });
+      resolve5({ code, timedOut: false });
     };
     const timer = timeoutMs > 0 ? setTimeout(() => {
       child.removeListener("exit", onExit);
-      resolve4({ code: child.exitCode, timedOut: true });
+      resolve5({ code: child.exitCode, timedOut: true });
     }, timeoutMs) : void 0;
     child.once("exit", onExit);
   });
@@ -622,863 +867,2207 @@ async function waitForChildExit(child, timeoutMs) {
   return !result.timedOut && result.code !== null;
 }
 
-// src/bot/active-runs.ts
-var ActiveRuns = class {
-  runs = /* @__PURE__ */ new Map();
-  set(scope, handle) {
-    this.runs.set(scope, handle);
-  }
-  get(scope) {
-    return this.runs.get(scope);
+// src/adapters/dsh/sdk-adapter.ts
+import { randomUUID } from "crypto";
+import {
+  DeepSeekHarness,
+  HarnessClient
+} from "@deepseek-ai/dsh-sdk-client";
+
+// src/adapters/dsh/sdk-translate.ts
+init_event_channel();
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function safeParseJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function textOfBlocks(blocks) {
+  if (!Array.isArray(blocks)) return "";
+  return blocks.filter(isRecord2).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("");
+}
+function translateChunk(chunk, tracker) {
+  if (!isRecord2(chunk)) return [];
+  switch (chunk.type) {
+    case "reasoning-delta":
+      return typeof chunk.text === "string" && chunk.text ? [{ type: "thinking", delta: chunk.text }] : [];
+    case "text-delta":
+      return typeof chunk.text === "string" && chunk.text ? [{ type: "text", delta: chunk.text }] : [];
+    case "tool-call-delta": {
+      const id = stringValue2(chunk.id);
+      if (!id || tracker.emitted.has(id)) return [];
+      tracker.emitted.add(id);
+      return [
+        {
+          type: "tool_use",
+          id,
+          name: stringValue2(chunk.name) ?? "tool",
+          input: {}
+        }
+      ];
+    }
+    default:
+      return [];
   }
-  delete(scope) {
-    return this.runs.delete(scope);
+}
+function translateToolResult(data) {
+  if (!isRecord2(data)) return [];
+  const message = isRecord2(data.message) ? data.message : void 0;
+  const block = Array.isArray(message?.content) ? message.content[0] : void 0;
+  const toolCallId = stringValue2(
+    isRecord2(block) ? block.toolCallId : void 0
+  );
+  if (!toolCallId) return [];
+  const output = textOfBlocks(isRecord2(block) ? block.content : void 0);
+  const isError = data.error !== void 0 || (isRecord2(block) ? block.isError === true : false);
+  return [
+    {
+      type: "tool_result",
+      id: toolCallId,
+      output,
+      isError
+    }
+  ];
+}
+function translateAssistantMessage(data) {
+  if (!isRecord2(data) || !isRecord2(data.usage)) return [];
+  const usage = data.usage;
+  const inputTokens = typeof usage.inputTokens === "number" ? usage.inputTokens : void 0;
+  const outputTokens = typeof usage.outputTokens === "number" ? usage.outputTokens : void 0;
+  if (inputTokens === void 0 && outputTokens === void 0) return [];
+  return [
+    {
+      type: "usage",
+      ...inputTokens === void 0 ? {} : { inputTokens },
+      ...outputTokens === void 0 ? {} : { outputTokens }
+    }
+  ];
+}
+function translateTurnEnd(data) {
+  if (!isRecord2(data) || !isRecord2(data.reason) || data.reason.kind !== "error") return [];
+  const failure = isRecord2(data.reason.error) ? data.reason.error : void 0;
+  const message = stringValue2(failure?.message) ?? "dsh turn failed";
+  return [{ type: "error", message, terminationReason: "failed" }];
+}
+function translateSessionEvent(event, tracker) {
+  if (!isRecord2(event) || typeof event.type !== "string") return [];
+  switch (event.type) {
+    case "assistant/chunk":
+      return translateChunk(isRecord2(event.data) ? event.data.chunk : void 0, tracker);
+    case "tool/call": {
+      const data = isRecord2(event.data) ? event.data : void 0;
+      const id = stringValue2(data?.callId);
+      if (!id) return [];
+      return [
+        {
+          type: "tool_use",
+          id,
+          name: stringValue2(data?.name) ?? "tool",
+          input: safeParseJson(data?.arguments)
+        }
+      ];
+    }
+    case "tool/result":
+      return translateToolResult(event.data);
+    case "assistant/message":
+      return translateAssistantMessage(event.data);
+    case "turn/end":
+      return translateTurnEnd(event.data);
+    default:
+      return [];
   }
-  async interrupt(scope) {
-    const handle = this.runs.get(scope);
-    if (!handle) return false;
-    this.runs.delete(scope);
-    await handle.stop();
-    return true;
+}
+function translateNotification(notification, sessionId, tracker) {
+  if (notification.method !== "session.event") return [];
+  const params = isRecord2(notification.params) ? notification.params : void 0;
+  if (params?.sessionId !== sessionId) return [];
+  return translateSessionEvent(params.event, tracker);
+}
+function buildPromptText(prompt, images) {
+  return images?.length ? `${prompt}
+
+Image files attached to this message:
+${images.join("\n")}` : prompt;
+}
+function createSdkRun(harness, prompt, options) {
+  const channel = new EventChannel();
+  const tracker = { emitted: /* @__PURE__ */ new Set() };
+  let hadError = false;
+  const task = harness.run(buildPromptText(prompt, options.images), {
+    sessionId: options.sessionId,
+    onNotification: (notification) => {
+      for (const event of translateNotification(notification, options.sessionId, tracker)) {
+        if (event.type === "error") hadError = true;
+        channel.push(event);
+      }
+    }
+  }).catch((error) => {
+    if (!options.stopRequested.value) {
+      channel.push({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+        terminationReason: "failed"
+      });
+      hadError = true;
+    }
+  }).finally(() => {
+    channel.close();
+  });
+  async function* events() {
+    yield {
+      type: "system",
+      sessionId: options.sessionId,
+      cwd: options.cwd,
+      model: options.model
+    };
+    for await (const event of channel) {
+      yield event;
+    }
+    await task;
+    if (!hadError) {
+      yield {
+        type: "done",
+        sessionId: options.sessionId,
+        terminationReason: options.stopRequested.value ? "interrupted" : "normal"
+      };
+    }
   }
-};
+  return { events: events(), settled: task.then(() => void 0) };
+}
 
-// src/bot/pending-queue.ts
-var PendingQueue = class {
-  constructor(quietMs, onFlush) {
-    this.quietMs = quietMs;
-    this.onFlush = onFlush;
+// src/adapters/dsh/sdk-adapter.ts
+function waitWithTimeout(promise, timeoutMs) {
+  return new Promise((resolve5) => {
+    const timer = setTimeout(() => resolve5(false), timeoutMs > 0 ? timeoutMs : 5e3);
+    promise.then(
+      () => {
+        clearTimeout(timer);
+        resolve5(true);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve5(true);
+      }
+    );
+  });
+}
+var SdkDshAdapter = class {
+  id = "dsh-sdk";
+  displayName = "DeepSeek Harness (SDK)";
+  launch;
+  provider;
+  model;
+  maxTokens;
+  probeTimeoutMs;
+  harnessFactory;
+  runtimes = /* @__PURE__ */ new Map();
+  disposed = false;
+  constructor(options) {
+    this.launch = options.launch;
+    this.provider = options.provider;
+    this.model = options.model;
+    this.maxTokens = options.maxTokens;
+    this.probeTimeoutMs = options.probeTimeoutMs ?? 15e3;
+    this.harnessFactory = options.harnessFactory ?? ((cwd) => this.createHarness(cwd));
   }
-  quietMs;
-  onFlush;
-  pending = /* @__PURE__ */ new Map();
-  timers = /* @__PURE__ */ new Map();
-  blocked = /* @__PURE__ */ new Set();
-  flushing = /* @__PURE__ */ new Set();
-  push(scope, item) {
-    const batch = this.pending.get(scope) ?? [];
-    batch.push(item);
-    this.pending.set(scope, batch);
-    this.schedule(scope);
-  }
-  block(scope) {
-    this.blocked.add(scope);
-    this.clearTimer(scope);
-  }
-  unblock(scope) {
-    this.blocked.delete(scope);
-    this.schedule(scope);
+  async isAvailable() {
+    return (await this.checkAvailability()).ok;
   }
-  async flushNow(scope) {
-    this.clearTimer(scope);
-    if (this.flushing.has(scope)) return;
-    const batch = this.pending.get(scope) ?? [];
-    this.pending.delete(scope);
-    if (batch.length === 0) return;
-    this.flushing.add(scope);
+  async checkAvailability() {
+    if (this.disposed) {
+      return { ok: false, error: "adapter disposed", version: void 0 };
+    }
+    const client = new HarnessClient({
+      command: this.launch.command,
+      args: this.launch.args,
+      cwd: process.cwd(),
+      requestTimeoutMs: this.probeTimeoutMs
+    });
     try {
-      await this.onFlush(scope, batch);
+      client.start();
+      const info = await client.initialize({
+        cwd: process.cwd(),
+        provider: this.provider,
+        model: this.model,
+        ...this.maxTokens === void 0 ? {} : { maxTokens: this.maxTokens }
+      });
+      return {
+        ok: true,
+        error: void 0,
+        version: `${info.serverInfo.name}@${info.serverInfo.version}`
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+        version: void 0
+      };
     } finally {
-      this.flushing.delete(scope);
+      await client.close();
     }
   }
-  hasPending(scope) {
-    return (this.pending.get(scope)?.length ?? 0) > 0;
-  }
-  isBlocked(scope) {
-    return this.blocked.has(scope);
+  run(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const entry = this.runtimeFor(cwd);
+    const sessionId = options.sessionId ?? `session-${randomUUID().replaceAll("-", "")}`;
+    const stopRequested = { value: false };
+    const handle = createSdkRun(entry.harness, options.prompt, {
+      sessionId,
+      cwd,
+      model: options.model ?? this.model,
+      images: options.images,
+      stopRequested
+    });
+    return {
+      runId: options.runId,
+      events: handle.events,
+      stop: async () => {
+        stopRequested.value = true;
+        await this.closeRuntime(cwd);
+      },
+      waitForExit: (timeoutMs) => waitWithTimeout(handle.settled, timeoutMs)
+    };
   }
-  schedule(scope) {
-    if (this.blocked.has(scope) || this.flushing.has(scope)) return;
-    if (this.timers.has(scope)) return;
-    if (!this.hasPending(scope)) return;
-    this.timers.set(
-      scope,
-      setTimeout(() => {
-        this.timers.delete(scope);
-        void this.flushNow(scope);
-      }, this.quietMs)
+  /** Close every runtime subprocess (used on bridge shutdown). */
+  async dispose() {
+    this.disposed = true;
+    const entries = [...this.runtimes.values()];
+    this.runtimes.clear();
+    await Promise.allSettled(
+      entries.map((entry) => entry.harness.close())
     );
   }
-  clearTimer(scope) {
-    const timer = this.timers.get(scope);
-    if (timer === void 0) return;
-    clearTimeout(timer);
-    this.timers.delete(scope);
-  }
-};
-
-// src/bot/run-policy.ts
-var RunPolicyStore = class {
-  timeouts = /* @__PURE__ */ new Map();
-  get(scope) {
-    return this.timeouts.get(scope);
-  }
-  set(scope, runTimeoutMs) {
-    this.timeouts.set(scope, runTimeoutMs);
+  createHarness(cwd) {
+    return new DeepSeekHarness({
+      launch: {
+        command: this.launch.command,
+        args: this.launch.args,
+        cwd
+      },
+      cwd,
+      provider: this.provider,
+      model: this.model,
+      ...this.maxTokens === void 0 ? {} : { maxTokens: this.maxTokens }
+    });
   }
-  clear(scope) {
-    return this.timeouts.delete(scope);
+  runtimeFor(cwd) {
+    if (this.disposed) {
+      throw new Error("SdkDshAdapter is disposed");
+    }
+    const existing = this.runtimes.get(cwd);
+    if (existing) return existing;
+    const entry = { harness: this.harnessFactory(cwd) };
+    this.runtimes.set(cwd, entry);
+    return entry;
+  }
+  async closeRuntime(cwd) {
+    const entry = this.runtimes.get(cwd);
+    if (!entry) return;
+    this.runtimes.delete(cwd);
+    try {
+      await entry.harness.close();
+    } catch (error) {
+      void error;
+    }
   }
 };
 
-// src/bridge/channel.ts
-import { createLarkChannel } from "@larksuite/channel";
-
-// src/commands/index.ts
-import { resolve as resolve3 } from "path";
-
-// src/card/workspace-card.ts
-function renderWorkspaceCard(input) {
-  const entries = input.index;
-  const markdown2 = [
-    `**\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55**
-\`${input.current}\``,
+// src/adapters/dsh/sdk-runtime.ts
+init_dsh_runtime();
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+var SDK_SERVER_PACKAGE = "@deepseek-ai/dsh-sdk-jsonrpc-server";
+var SDK_SERVER_VERSION = "0.1.0-rc.6";
+var SDK_BASE_BUNDLE = "@deepseek-ai/dsh-base";
+var DEFAULT_SDK_PROFILE = "dsh-lark";
+function sdkProfileRoot(home, profile, env) {
+  return join2(resolveDshHome(home, env), "profiles", profile);
+}
+function packageJsonFor(profile) {
+  return `${JSON.stringify(
+    {
+      name: `dsh-profile-${profile}`,
+      private: true,
+      dependencies: {
+        [SDK_SERVER_PACKAGE]: SDK_SERVER_VERSION
+      },
+      dsh: {
+        profile: {
+          bundles: [SDK_BASE_BUNDLE]
+        }
+      }
+    },
+    null,
+    2
+  )}
+`;
+}
+function patchYamlFor() {
+  return [
+    "# dsh-lark SDK JSON-RPC runtime overlay (managed by dsh-lark-bot).",
+    "# stdout is reserved for SDK JSON-RPC frames; no console logger may load.",
+    "- insert:",
+    "    - id: sdk-jsonrpc-server",
+    `      name: '${SDK_SERVER_PACKAGE}'`,
+    "      config:",
+    "        maxTokensAsSuccess: true",
     "",
-    ...entries.length > 0 ? entries.map(
-      ({ name, cwd, lastUsed }) => `- **${name}** \u2192 \`${cwd}\`${lastUsed ? ` \xB7 ${new Date(lastUsed).toLocaleString()}` : ""}`
-    ) : ["\u6682\u65E0\u547D\u540D\u5DE5\u4F5C\u7A7A\u95F4\u3002"]
+    "# Unattended IM runtime: interactive user questions cannot be answered",
+    "# through Feishu, so the tool is disabled (default-deny).",
+    "- id: user-questions",
+    "  disabled: true",
+    "",
+    "- id: system-prompt",
+    "  config:",
+    "    persona: >-",
+    "      You are a coding agent powered by the {{model}} model. Your working directory is {{cwd}}.",
+    "",
+    "- id: hmr",
+    "  disabled: true",
+    ""
   ].join("\n");
-  return {
-    schema: "2.0",
-    config: {
-      summary: { content: "\u5DE5\u4F5C\u7A7A\u95F4\u5BFC\u822A" }
-    },
-    body: {
-      elements: [
-        {
-          tag: "markdown",
-          content: markdown2
-        }
-      ]
-    }
-  };
 }
-
-// src/commands/index.ts
-var HELP = [
-  "**dsh-lark-bot \u547D\u4EE4**",
-  "",
-  "- `/new` `/reset` \u2014 \u5F00\u59CB\u65B0\u4F1A\u8BDD",
-  "- `/cd <path>` \u2014 \u5207\u6362\u5DE5\u4F5C\u76EE\u5F55\u5E76\u91CD\u7F6E\u4F1A\u8BDD",
-  "- `/ws list|save <name>|use <name>|remove <name>` \u2014 \u7BA1\u7406\u5DE5\u4F5C\u7A7A\u95F4",
-  "- `/status` \u2014 \u67E5\u770B\u5F53\u524D\u72B6\u6001",
-  "- `/resume` \u2014 \u67E5\u770B\u5F53\u524D\u4F1A\u8BDD\u6700\u8FD1\u4E0A\u4E0B\u6587",
-  "- `/stop` \u2014 \u7EC8\u6B62\u5F53\u524D\u4EFB\u52A1",
-  "- `/timeout [N|off|default]` \u2014 \u67E5\u770B\u6216\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6",
-  "- `/invite user|admin|group <id>` \u2014 \u7BA1\u7406\u8BBF\u95EE\u767D\u540D\u5355",
-  "- `/help` \u2014 \u663E\u793A\u672C\u5E2E\u52A9"
-].join("\n");
-async function reply(ctx, markdown2) {
-  await ctx.channel.sendMarkdown(ctx.chatId, markdown2, {
-    replyTo: ctx.messageId
-  });
+function sdkServerInstalled(profileRoot) {
+  const candidates = [
+    join2(profileRoot, "node_modules", SDK_SERVER_PACKAGE),
+    join2(profileRoot, "..", "node_modules", SDK_SERVER_PACKAGE)
+  ];
+  return candidates.some((path) => existsSync3(path));
 }
-async function handleNew(_args, ctx) {
-  const wasRunning = await ctx.activeRuns.interrupt(ctx.scope);
-  ctx.sessions.clear(ctx.scope);
-  await reply(ctx, wasRunning ? "\u5DF2\u4E2D\u65AD\u5F53\u524D\u4EFB\u52A1\u5E76\u5F00\u59CB\u65B0\u4F1A\u8BDD\u3002" : "\u5DF2\u5F00\u59CB\u65B0\u4F1A\u8BDD\u3002");
+function isSdkProfileReady(profileRoot) {
+  return existsSync3(join2(profileRoot, "package.json")) && existsSync3(join2(profileRoot, "cordis.yml")) && existsSync3(join2(profileRoot, "cordis.patch.yml")) && sdkServerInstalled(profileRoot);
 }
-async function handleCd(args, ctx) {
-  const path = args.trim();
-  if (!path) {
-    await reply(ctx, "\u7528\u6CD5\uFF1A`/cd <path>`");
-    return;
-  }
-  const cwd = resolve3(path);
-  await ctx.activeRuns.interrupt(ctx.scope);
-  ctx.workspaces.setCwd(ctx.scope, cwd);
-  ctx.sessions.clear(ctx.scope);
-  await reply(ctx, `\u5DF2\u5207\u6362\u5DE5\u4F5C\u76EE\u5F55\uFF1A\`${cwd}\`\uFF0C\u4F1A\u8BDD\u5DF2\u91CD\u7F6E\u3002`);
+function runPnpmInstall(profileRoot) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn3("pnpm", ["install"], {
+      cwd: profileRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    child.stdout.on("data", (chunk) => {
+      output += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      output += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve5();
+        return;
+      }
+      const tail = output.trim().split("\n").slice(-8).join("\n");
+      reject(new Error(`pnpm install exited with code ${String(code)}
+${tail}`));
+    });
+  });
 }
-async function handleWs(args, ctx) {
-  const [sub, ...rest] = args.trim().split(/\s+/);
-  const name = rest.join(" ").trim();
-  if (!sub || sub === "list") {
-    const current = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
-    const named = ctx.workspaces.listNamed();
-    const index = ctx.workspaces.listIndex();
-    if (ctx.channel.sendCard) {
-      await ctx.channel.sendCard(ctx.chatId, renderWorkspaceCard({ current, index }));
-      return;
+async function ensureSdkProfile(options) {
+  const profile = options.profile ?? DEFAULT_SDK_PROFILE;
+  const root = sdkProfileRoot(options.home, profile, options.env);
+  if (isSdkProfileReady(root)) return { ok: true, created: false };
+  try {
+    await mkdir(root, { recursive: true });
+    await writeFile(join2(root, "package.json"), packageJsonFor(profile), "utf8");
+    await writeFile(join2(root, "cordis.yml"), "[]\n", "utf8");
+    await writeFile(join2(root, "cordis.patch.yml"), patchYamlFor(), "utf8");
+    const install = options.install ?? runPnpmInstall;
+    await install(root);
+    if (!isSdkProfileReady(root)) {
+      return {
+        ok: false,
+        created: true,
+        error: `${SDK_SERVER_PACKAGE}@${SDK_SERVER_VERSION} was not found after install`
+      };
     }
-    const lines = Object.entries(named).map(
-      ([key, value]) => `- **${key}** \u2192 \`${value}\`${value === current ? " \u2190 \u5F53\u524D" : ""}`
-    );
-    await reply(
-      ctx,
-      [
-        `\u5F53\u524D cwd\uFF1A\`${current}\``,
-        "",
-        ...lines.length > 0 ? lines : ["\u6682\u65E0\u547D\u540D\u5DE5\u4F5C\u7A7A\u95F4\u3002"]
-      ].join("\n")
-    );
-    return;
+    return { ok: true, created: true };
+  } catch (error) {
+    return {
+      ok: false,
+      created: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
   }
-  if (sub === "save") {
-    if (!name) {
-      await reply(ctx, "\u7528\u6CD5\uFF1A`/ws save <name>`");
-      return;
-    }
-    const current = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
-    ctx.workspaces.saveNamed(name, current);
-    await reply(ctx, `\u5DF2\u4FDD\u5B58\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}** \u2192 \`${current}\``);
-    return;
+}
+function resolveSdkLaunch(options) {
+  const profile = options.profile ?? DEFAULT_SDK_PROFILE;
+  if (options.command || options.args) {
+    return {
+      command: options.command ?? "node",
+      args: options.args ?? ["--profile", profile],
+      profile
+    };
   }
-  if (sub === "use") {
-    if (!name) {
-      await reply(ctx, "\u7528\u6CD5\uFF1A`/ws use <name>`");
-      return;
+  const bin = options.bin ?? discoverDshBin(options.home, options.env);
+  if (bin) {
+    return { command: "node", args: [bin, "--profile", profile], profile };
+  }
+  return { command: "dsh", args: ["--profile", profile], profile };
+}
+
+// src/adapters/index.ts
+async function buildAgentAdapter(env, preferences = { stopGraceMs: void 0, model: void 0 }) {
+  switch (env.adapterMode) {
+    case "headless": {
+      const options = {
+        command: env.dshCommand,
+        args: env.dshArgs
+      };
+      if (preferences.stopGraceMs !== void 0) {
+        options.stopGraceMs = preferences.stopGraceMs;
+      }
+      return new DshAdapter(options);
     }
-    const cwd = ctx.workspaces.getNamed(name);
-    if (!cwd) {
-      await reply(ctx, `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`);
-      return;
+    case "acp": {
+      const { buildAcpAgentAdapter: buildAcpAgentAdapter2 } = await Promise.resolve().then(() => (init_acp_adapter(), acp_adapter_exports));
+      return buildAcpAgentAdapter2(env, preferences);
     }
-    await ctx.activeRuns.interrupt(ctx.scope);
-    ctx.workspaces.setCwd(ctx.scope, cwd);
-    ctx.workspaces.touchNamed(name);
-    ctx.sessions.clear(ctx.scope);
-    await reply(ctx, `\u5DF2\u5207\u6362\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}** \u2192 \`${cwd}\``);
-    return;
-  }
-  if (sub === "remove") {
-    if (!name) {
-      await reply(ctx, "\u7528\u6CD5\uFF1A`/ws remove <name>`");
-      return;
+    case "sdk":
+    default: {
+      const runtimeOptions = {
+        home: homedir2(),
+        env: process.env,
+        ...env.dshExplicit ? { command: env.dshCommand, args: env.dshArgs } : {}
+      };
+      const ensure = await ensureSdkProfile(runtimeOptions);
+      if (!ensure.ok) {
+        throw new Error(
+          `SDK runtime profile setup failed: ${ensure.error ?? "unknown error"} (install pnpm, or set DSH_LARK_ADAPTER=headless for the legacy adapter)`
+        );
+      }
+      const launch = resolveSdkLaunch(runtimeOptions);
+      return new SdkDshAdapter({
+        launch,
+        provider: env.provider,
+        model: preferences.model ?? env.model,
+        ...env.maxTokens === void 0 ? {} : { maxTokens: env.maxTokens }
+      });
     }
-    const removed = ctx.workspaces.removeNamed(name);
-    await reply(ctx, removed ? `\u5DF2\u5220\u9664\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**` : `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`);
-    return;
   }
-  await reply(ctx, "\u672A\u77E5 `/ws` \u5B50\u547D\u4EE4\uFF0C\u8BF7\u4F7F\u7528 list / save / use / remove\u3002");
 }
-async function handleStatus(_args, ctx) {
-  const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
-  const session = ctx.sessions.getRaw(ctx.scope)?.sessionId ?? "(\u65E0)";
-  const running = Boolean(ctx.activeRuns.get(ctx.scope));
-  const scopeLabel = ctx.chatMode === "topic" ? `${ctx.scope}\uFF08\u8BDD\u9898\u72EC\u7ACB session\uFF09` : ctx.scope;
-  await reply(
-    ctx,
-    [
-      `\u{1F9ED} **scope**: \`${scopeLabel}\``,
-      `\u{1F4C1} **cwd**: \`${cwd}\``,
-      `\u{1F517} **session**: \`${session}\``,
-      `\u{1F3C3} **active run**: ${running ? "yes" : "no"}`
-    ].join("\n")
-  );
+
+// src/config/app-paths.ts
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve } from "path";
+function defaultHome() {
+  const override = process.env.DSH_LARK_HOME?.trim();
+  return override ? resolve(override) : join4(homedir3(), ".dsh-lark");
 }
-async function handleResume(_args, ctx) {
-  const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
-  const history = ctx.sessions.historyFor(ctx.scope, cwd);
-  if (history.length === 0) {
-    await reply(ctx, "\u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u5386\u53F2\u4E0A\u4E0B\u6587\u3002");
-    return;
-  }
-  const recent = history.slice(-6).map((message) => {
-    const speaker = message.role === "user" ? "\u{1F464}" : "\u{1F916}";
-    return `${speaker} ${message.content.slice(0, 300)}`;
-  });
-  await reply(ctx, [`\u5F53\u524D scope\uFF1A\`${ctx.scope}\``, "", ...recent].join("\n"));
+function resolveAppPaths(root = defaultHome()) {
+  const profileDir = (profile) => join4(root, "profiles", profile);
+  const profilePath = (profile, ...parts) => join4(profileDir(profile), ...parts);
+  return {
+    root,
+    configFile: join4(root, "config.json"),
+    activeProfileFile: join4(root, "active-profile"),
+    profileDir,
+    profilePath,
+    sessionsFile: (profile) => profilePath(profile, "sessions.json"),
+    sessionCatalogFile: (profile) => profilePath(profile, "sessions.json.catalog.json"),
+    workspacesFile: (profile) => profilePath(profile, "workspaces.json"),
+    mediaDir: (profile) => profilePath(profile, "media"),
+    logsDir: (profile) => profilePath(profile, "logs"),
+    registryFile: join4(root, "registry", "processes.json"),
+    locksDir: join4(root, "registry", "locks")
+  };
 }
-async function handleStop(_args, ctx) {
-  const stopped = await ctx.activeRuns.interrupt(ctx.scope);
-  await reply(ctx, stopped ? "\u5DF2\u8BF7\u6C42\u7EC8\u6B62\u5F53\u524D\u4EFB\u52A1\u3002" : "\u5F53\u524D\u6CA1\u6709\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\u3002");
+
+// src/config/env.ts
+init_dsh_runtime();
+import { join as join5, resolve as resolve2 } from "path";
+import { homedir as homedir4 } from "os";
+var DEFAULTS = {
+  tenant: "feishu",
+  provider: "deepseek-official",
+  model: "deepseek-v4-flash",
+  runTimeoutMs: 3e5,
+  stopGraceMs: 5e3
+};
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
 }
-async function handleTimeout(args, ctx) {
-  const input = args.trim();
-  const effectiveMs = ctx.runPolicies.get(ctx.scope) ?? ctx.defaultRunTimeoutMs;
-  if (!input) {
-    const minutes2 = effectiveMs > 0 ? Math.round(effectiveMs / 6e4) : 0;
-    await reply(
-      ctx,
-      minutes2 > 0 ? `\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A${minutes2} \u5206\u949F\u3002\u53EF\u7528 \`/timeout <N|off|default>\` \u8C03\u6574\u3002` : "\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A\u5173\u95ED\u3002"
-    );
-    return;
-  }
-  if (input === "off") {
-    ctx.runPolicies.set(ctx.scope, 0);
-    await reply(ctx, "\u5DF2\u5173\u95ED\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\u3002");
-    return;
-  }
-  if (input === "default") {
-    ctx.runPolicies.clear(ctx.scope);
-    await reply(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u8FD0\u884C\u8D85\u65F6\u3002");
-    return;
-  }
-  const minutes = Number(input);
-  if (!Number.isInteger(minutes) || minutes <= 0) {
-    await reply(ctx, "\u7528\u6CD5\uFF1A`/timeout <N|off|default>`\uFF0CN \u4E3A\u5927\u4E8E 0 \u7684\u5206\u949F\u6570\u3002");
-    return;
+function parseTenant(value) {
+  const tenant = nonEmpty(value) ?? DEFAULTS.tenant;
+  if (tenant !== "feishu" && tenant !== "lark") {
+    throw new Error(`DSH_LARK_TENANT must be "feishu" or "lark", got "${tenant}"`);
   }
-  ctx.runPolicies.set(ctx.scope, minutes * 6e4);
-  await reply(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A${minutes} \u5206\u949F\u3002`);
+  return tenant;
 }
-async function handleInvite(args, ctx) {
-  const [kind, ...rest] = args.trim().split(/\s+/);
-  const id = rest.join(" ").trim();
-  if (kind === "list") {
-    const snapshot = ctx.accessManager.snapshot();
-    await reply(
-      ctx,
-      [
-        "**\u8BBF\u95EE\u767D\u540D\u5355**",
-        `users: ${snapshot.allowedUsers.join(", ") || "(\u7A7A)"}`,
-        `chats: ${snapshot.allowedChats.join(", ") || "(\u7A7A)"}`,
-        `admins: ${snapshot.admins.join(", ") || "(\u7A7A)"}`
-      ].join("\n")
-    );
-    return;
-  }
-  if (!kind || !id) {
-    await reply(
-      ctx,
-      "\u7528\u6CD5\uFF1A`/invite user|admin|group <id>`\u3001`/invite list`\u3001`/invite remove user|group <id>`"
-    );
-    return;
-  }
-  if (kind === "user") {
-    await ctx.accessManager.addUser(id);
-    await reply(ctx, `\u5DF2\u5141\u8BB8\u7528\u6237\uFF1A\`${id}\``);
-    return;
-  }
-  if (kind === "admin") {
-    await ctx.accessManager.addAdmin(id);
-    await reply(ctx, `\u5DF2\u8BBE\u4E3A\u7BA1\u7406\u5458\uFF1A\`${id}\``);
-    return;
-  }
-  if (kind === "group") {
-    await ctx.accessManager.addChat(id);
-    await reply(ctx, `\u5DF2\u5141\u8BB8\u7FA4\u804A\uFF1A\`${id}\``);
-    return;
-  }
-  if (kind === "remove") {
-    const [sub, target] = rest;
-    if (sub === "user" && target) {
-      await ctx.accessManager.removeUser(target);
-      await reply(ctx, `\u5DF2\u79FB\u9664\u7528\u6237\uFF1A\`${target}\``);
-      return;
-    }
-    if (sub === "group" && target) {
-      await ctx.accessManager.removeChat(target);
-      await reply(ctx, `\u5DF2\u79FB\u9664\u7FA4\u804A\uFF1A\`${target}\``);
-      return;
-    }
-    await reply(ctx, "\u7528\u6CD5\uFF1A`/invite remove user <id>` \u6216 `/invite remove group <chatId>`");
-    return;
-  }
-  await reply(ctx, "\u672A\u77E5 `/invite` \u7C7B\u578B\uFF0C\u8BF7\u4F7F\u7528 user / admin / group / list / remove\u3002");
+function parseDshArgs(value) {
+  const raw = value?.trim();
+  if (!raw) return [];
+  return raw.split(",").map((item) => item.trim()).filter(Boolean);
 }
-async function handleHelp(_args, ctx) {
-  await reply(ctx, HELP);
+function parseTimeout(value) {
+  const raw = value?.trim();
+  if (!raw) return DEFAULTS.runTimeoutMs;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`DSH_LARK_RUN_TIMEOUT_MS must be a non-negative integer, got "${raw}"`);
+  }
+  return parsed;
 }
-var handlers = {
-  "/new": handleNew,
-  "/reset": handleNew,
-  "/cd": handleCd,
-  "/ws": handleWs,
-  "/status": handleStatus,
-  "/resume": handleResume,
-  "/stop": handleStop,
-  "/timeout": handleTimeout,
-  "/invite": handleInvite,
-  "/help": handleHelp
-};
-async function tryHandleCommand(text, ctx) {
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("/")) return false;
-  const [command, ...rest] = trimmed.split(/\s+/);
-  const handler = handlers[command ?? ""];
-  if (!handler) return false;
-  await handler(rest.join(" "), ctx);
-  return true;
+function parseStopGrace(value) {
+  const raw = value?.trim();
+  if (!raw) return DEFAULTS.stopGraceMs;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`DSH_LARK_STOP_GRACE_MS must be a non-negative integer, got "${raw}"`);
+  }
+  return parsed;
 }
-
-// src/core/logger.ts
-var REDACTED = "[redacted]";
-var SENSITIVE_KEY = /(secret|token|password|api[_-]?key)/i;
-function redactValue(value, key, depth) {
-  if (SENSITIVE_KEY.test(key)) return REDACTED;
-  if (depth === 0) return value;
-  if (Array.isArray(value)) {
-    return value.map((item, index) => redactValue(item, `${key}.${index}`, depth - 1));
+function parseAdapterMode(value) {
+  const mode = nonEmpty(value) ?? "sdk";
+  if (mode !== "sdk" && mode !== "acp" && mode !== "headless") {
+    throw new Error(`DSH_LARK_ADAPTER must be "sdk", "acp" or "headless", got "${mode}"`);
   }
-  if (value && typeof value === "object") {
-    const out = {};
-    for (const [childKey, childValue] of Object.entries(value)) {
-      out[childKey] = redactValue(childValue, childKey, depth - 1);
-    }
-    return out;
+  return mode;
+}
+function parseMaxTokens(value) {
+  const raw = value?.trim();
+  if (!raw) return void 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`DSH_LARK_MAX_TOKENS must be a positive integer, got "${raw}"`);
   }
-  return value;
+  return parsed;
 }
-function redactFields(fields, depth = 4) {
-  return redactValue(fields, "", depth);
+function parseBoolean(value, fallback) {
+  const raw = value?.trim().toLowerCase();
+  if (!raw) return fallback;
+  if (raw === "1" || raw === "true" || raw === "yes") return true;
+  if (raw === "0" || raw === "false" || raw === "no") return false;
+  return fallback;
 }
-function serializeMessage(level, category, event, fields) {
-  const entry = {
-    time: (/* @__PURE__ */ new Date()).toISOString(),
-    level,
-    category,
-    event,
-    fields: redactFields(fields)
-  };
-  return JSON.stringify(entry);
+function parseFreshness(value) {
+  const raw = value?.trim();
+  if (!raw) return 6e5;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`DSH_LARK_EVENT_FRESHNESS_MS must be a non-negative integer, got "${raw}"`);
+  }
+  return parsed;
 }
-function createLogger(output = process.stderr) {
-  const write = (level, category, event, fields) => {
-    output.write(`${serializeMessage(level, category, event, fields)}
-`);
-  };
+function loadRuntimeEnv(source = process.env) {
+  const homeOverride = nonEmpty(source.DSH_LARK_HOME);
+  const workspace = nonEmpty(source.DSH_LARK_WORKSPACE);
+  const home = homeOverride ? resolve2(homeOverride) : join5(homedir4(), ".dsh-lark");
+  const osHome = homedir4();
+  const explicitCommand = nonEmpty(source.DSH_LARK_DSH_COMMAND);
+  const rawDshArgs = nonEmpty(source.DSH_LARK_DSH_ARGS);
+  const dshExplicit = explicitCommand !== void 0 || rawDshArgs !== void 0;
+  const dshRuntime = resolveDshRuntime({
+    home: osHome,
+    env: source,
+    ...explicitCommand ? { command: explicitCommand } : {},
+    ...rawDshArgs ? { args: parseDshArgs(rawDshArgs) } : {}
+  });
   return {
-    info: (category, event, fields = {}) => write("info", category, event, fields),
-    warn: (category, event, fields = {}) => write("warn", category, event, fields),
-    error: (category, event, fields = {}) => write("error", category, event, fields),
-    fail(category, error, fields = {}) {
-      const message = error instanceof Error ? error.message : String(error);
-      write("error", category, "fail", { message, ...fields });
-    }
+    home,
+    tenant: parseTenant(source.DSH_LARK_TENANT),
+    appId: nonEmpty(source.DSH_LARK_APP_ID),
+    appSecret: nonEmpty(source.DSH_LARK_APP_SECRET),
+    workspace: workspace ? resolve2(workspace) : void 0,
+    dshCommand: dshRuntime.command,
+    dshArgs: dshRuntime.args,
+    dshExplicit,
+    adapterMode: parseAdapterMode(source.DSH_LARK_ADAPTER),
+    provider: nonEmpty(source.DSH_LARK_PROVIDER) ?? DEFAULTS.provider,
+    model: nonEmpty(source.DSH_LARK_MODEL) ?? DEFAULTS.model,
+    maxTokens: parseMaxTokens(source.DSH_LARK_MAX_TOKENS),
+    runTimeoutMs: parseTimeout(source.DSH_LARK_RUN_TIMEOUT_MS),
+    stopGraceMs: parseStopGrace(source.DSH_LARK_STOP_GRACE_MS),
+    accessDefaultDeny: parseBoolean(source.DSH_LARK_ACCESS_DEFAULT_DENY, false),
+    eventFreshnessMs: parseFreshness(source.DSH_LARK_EVENT_FRESHNESS_MS)
   };
 }
-var log = createLogger();
 
-// src/bridge/lark-channel.ts
-function adaptLarkChannel(channel) {
-  const base = {
-    async sendMarkdown(chatId, markdown2, options) {
-      const sendOptions = {};
-      if (options?.replyTo) sendOptions.replyTo = options.replyTo;
-      await channel.send(chatId, { markdown: markdown2 }, sendOptions);
-    }
-  };
-  return {
-    ...base,
-    async sendCard(chatId, card) {
-      await channel.send(chatId, { card }, {});
-    },
-    async streamCard(chatId, initial, producer, options) {
-      const sendOptions = {};
-      if (options?.replyTo) sendOptions.replyTo = options.replyTo;
-      await channel.stream(
-        chatId,
-        {
-          card: {
-            initial,
-            producer: async (controller) => {
-              await producer(controller);
-            }
-          }
-        },
-        sendOptions
-      );
+// src/config/profile-store.ts
+import { readFile } from "fs/promises";
+import { mkdir as mkdir4 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+
+// src/platform/atomic-write.ts
+import { randomBytes } from "crypto";
+import { mkdir as mkdir3, rename, writeFile as writeFile3 } from "fs/promises";
+import { dirname, join as join6 } from "path";
+async function writeFileAtomic(target, data, options = {}) {
+  const directory = dirname(target);
+  await mkdir3(directory, { recursive: true });
+  const temporary = join6(directory, `.${randomBytes(8).toString("hex")}.tmp`);
+  try {
+    await writeFile3(temporary, data, options.mode === void 0 ? void 0 : { mode: options.mode });
+    await rename(temporary, target);
+  } catch (error) {
+    await rmSilently(temporary);
+    throw error;
+  }
+}
+async function rmSilently(path) {
+  const { rm } = await import("fs/promises");
+  try {
+    await rm(path, { force: true });
+  } catch {
+  }
+}
+
+// src/config/profile-store.ts
+var ConfigStore = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  data;
+  async load() {
+    try {
+      const raw = await readFile(this.path, "utf8");
+      const parsed = JSON.parse(raw);
+      this.data = {
+        schemaVersion: 1,
+        activeProfile: parsed.activeProfile ?? "default",
+        profiles: Object.fromEntries(
+          Object.entries(parsed.profiles ?? {}).map(([name, profile]) => [
+            name,
+            {
+              ...profile,
+              access: {
+                allowedUsers: profile.access?.allowedUsers ?? [],
+                allowedChats: profile.access?.allowedChats ?? [],
+                admins: profile.access?.admins ?? []
+              }
+            }
+          ])
+        )
+      };
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      this.data = {
+        schemaVersion: 1,
+        activeProfile: "default",
+        profiles: {}
+      };
+    }
+    return this.data;
+  }
+  getActiveProfile() {
+    const data = this.getData();
+    return data.profiles[data.activeProfile];
+  }
+  getProfile(name) {
+    const data = this.getData();
+    return data.profiles[name];
+  }
+  async saveProfile(name, input) {
+    const data = this.getData();
+    const existing = data.profiles[name];
+    const profile = {
+      schemaVersion: 1,
+      agentKind: "dsh",
+      tenant: input.tenant,
+      accounts: {
+        appId: input.appId,
+        appSecret: input.appSecret
+      },
+      workspaces: {
+        default: input.workspace ?? existing?.workspaces.default ?? void 0
+      },
+      preferences: {
+        model: input.model ?? existing?.preferences.model ?? void 0,
+        stopGraceMs: input.stopGraceMs ?? existing?.preferences.stopGraceMs ?? void 0,
+        runTimeoutMs: input.runTimeoutMs ?? existing?.preferences.runTimeoutMs ?? void 0
+      },
+      access: {
+        allowedUsers: input.access?.allowedUsers ?? existing?.access?.allowedUsers ?? [],
+        allowedChats: input.access?.allowedChats ?? existing?.access?.allowedChats ?? [],
+        admins: input.access?.admins ?? existing?.access?.admins ?? []
+      }
+    };
+    if (input.operatorOpenId && !profile.access.allowedUsers.includes(input.operatorOpenId)) {
+      profile.access.allowedUsers.push(input.operatorOpenId);
+      profile.access.admins.push(input.operatorOpenId);
+    }
+    data.profiles[name] = profile;
+    data.activeProfile = name;
+    await this.persist();
+  }
+  getData() {
+    if (!this.data) {
+      throw new Error("ConfigStore must be loaded before use");
+    }
+    return this.data;
+  }
+  async persist() {
+    const data = this.getData();
+    await mkdir4(dirname2(this.path), { recursive: true });
+    await writeFileAtomic(this.path, `${JSON.stringify(data, null, 2)}
+`, {
+      mode: 384
+    });
+  }
+};
+
+// src/cli/commands/doctor.ts
+async function runDoctor(options) {
+  const env = loadRuntimeEnv({
+    ...process.env,
+    ...options.workspace ? { DSH_LARK_WORKSPACE: options.workspace } : {},
+    ...options.tenant ? { DSH_LARK_TENANT: options.tenant } : {},
+    ...options.appId ? { DSH_LARK_APP_ID: options.appId } : {},
+    ...options.appSecret ? { DSH_LARK_APP_SECRET: options.appSecret } : {}
+  });
+  const paths = resolveAppPaths(env.home);
+  const profileName = options.profile ?? "default";
+  const store = new ConfigStore(paths.configFile);
+  await store.load();
+  const profile = store.getProfile(profileName);
+  const lines = [
+    "dsh-lark-bot doctor",
+    `version: ${options.version ?? "unknown"}`,
+    `node: ${process.version}`,
+    `profile: ${profileName}`,
+    `home: ${paths.root}`,
+    `adapter: ${env.adapterMode}`,
+    `dsh_command: ${env.dshCommand}`,
+    `dsh_args: ${env.dshArgs.join(",")}`
+  ];
+  let critical = false;
+  if (!profile) {
+    lines.push("config: missing");
+    critical = true;
+  } else {
+    lines.push(
+      [
+        "config: ok",
+        `tenant=${profile.tenant}`,
+        `app_id=${profile.accounts.appId}`,
+        `app_secret=${profile.accounts.appSecret ? "present" : "missing"}`,
+        `allowed_users=${profile.access.allowedUsers.length}`,
+        `allowed_chats=${profile.access.allowedChats.length}`
+      ].join(" ")
+    );
+    if (!profile.accounts.appId || !profile.accounts.appSecret) critical = true;
+  }
+  const workspace = options.workspace ?? profile?.workspaces.default ?? env.workspace ?? paths.profilePath(profileName, "workspace");
+  try {
+    const info = await stat(workspace);
+    lines.push(`workspace: ${workspace} (${info.isDirectory() ? "directory" : "not-directory"})`);
+  } catch {
+    lines.push(`workspace: ${workspace} (missing)`);
+  }
+  try {
+    const adapter = await buildAgentAdapter(env, {
+      stopGraceMs: profile?.preferences.stopGraceMs,
+      model: profile?.preferences.model
+    });
+    const availability = await adapter.checkAvailability();
+    if (availability.ok) {
+      lines.push(`dsh: ok${availability.version ? ` (${availability.version})` : ""}`);
+    } else {
+      lines.push(`dsh: unavailable (${availability.error ?? "unknown"})`);
+      critical = true;
+    }
+    await adapter.dispose?.();
+  } catch (error) {
+    lines.push(`dsh: unavailable (${error instanceof Error ? error.message : String(error)})`);
+    critical = true;
+  }
+  const output = options.output ?? ((text) => process.stdout.write(text));
+  output(`${lines.join("\n")}
+`);
+  if (critical) process.exitCode = 1;
+}
+
+// src/cli/commands/start.ts
+import { mkdir as mkdir7 } from "fs/promises";
+
+// src/bot/active-runs.ts
+var ActiveRuns = class {
+  runs = /* @__PURE__ */ new Map();
+  set(scope, handle) {
+    this.runs.set(scope, handle);
+  }
+  get(scope) {
+    return this.runs.get(scope);
+  }
+  delete(scope) {
+    return this.runs.delete(scope);
+  }
+  async interrupt(scope) {
+    const handle = this.runs.get(scope);
+    if (!handle) return false;
+    this.runs.delete(scope);
+    await handle.stop();
+    return true;
+  }
+};
+
+// src/config/security.ts
+import { realpathSync } from "fs";
+import { isIP } from "net";
+import { isAbsolute, relative, resolve as resolve3, sep } from "path";
+var REDACTED = "[redacted]";
+var SECRET_PATTERNS = [
+  { label: "bearer", pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/g, keyed: false },
+  { label: "deepseek-key", pattern: /\bsk-[A-Za-z0-9_-]{8,}/g, keyed: false },
+  { label: "api-key", pattern: /\b(api[_-]?key)\s*[=:]\s*["']?[A-Za-z0-9._~+/=-]{8,}/gi, keyed: true }
+];
+function redactSecrets(text) {
+  let result = text;
+  for (const { pattern, keyed } of SECRET_PATTERNS) {
+    result = keyed ? result.replace(pattern, (_match, keyName) => `${keyName}=${REDACTED}`) : result.replace(pattern, REDACTED);
+  }
+  return result;
+}
+function resolveReal(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve3(path);
+  }
+}
+function isPathWithin(root, candidate) {
+  const rootReal = resolveReal(root);
+  const candidateReal = resolveReal(candidate);
+  const rel = relative(rootReal, candidateReal);
+  return rel === "" || !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+function truncateUtf8Safe(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  let slice = text.slice(0, maxBytes);
+  while (Buffer.byteLength(slice, "utf8") > maxBytes && slice.length > 0) {
+    slice = slice.slice(0, -1);
+  }
+  const code = slice.charCodeAt(slice.length - 1);
+  if (code >= 55296 && code <= 56319) {
+    slice = slice.slice(0, -1);
+  }
+  return slice;
+}
+function isEventFresh(timestampMs, windowMs, now = Date.now()) {
+  if (timestampMs === void 0) return true;
+  return now - timestampMs <= windowMs;
+}
+
+// src/core/logger.ts
+var REDACTED2 = "[redacted]";
+var SENSITIVE_KEY = /(secret|token|password|api[_-]?key)/i;
+function redactValue(value, key, depth) {
+  if (SENSITIVE_KEY.test(key)) return REDACTED2;
+  if (typeof value === "string") return redactSecrets(value);
+  if (depth === 0) return value;
+  if (Array.isArray(value)) {
+    return value.map((item, index) => redactValue(item, `${key}.${index}`, depth - 1));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [childKey, childValue] of Object.entries(value)) {
+      out[childKey] = redactValue(childValue, childKey, depth - 1);
+    }
+    return out;
+  }
+  return value;
+}
+function redactFields(fields, depth = 4) {
+  return redactValue(fields, "", depth);
+}
+function serializeMessage(level, category, event, fields) {
+  const entry = {
+    time: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    category,
+    event,
+    fields: redactFields(fields)
+  };
+  return JSON.stringify(entry);
+}
+function createLogger(output = process.stderr) {
+  const write = (level, category, event, fields) => {
+    output.write(`${serializeMessage(level, category, event, fields)}
+`);
+  };
+  return {
+    info: (category, event, fields = {}) => write("info", category, event, fields),
+    warn: (category, event, fields = {}) => write("warn", category, event, fields),
+    error: (category, event, fields = {}) => write("error", category, event, fields),
+    fail(category, error, fields = {}) {
+      const message = error instanceof Error ? error.message : String(error);
+      write("error", category, "fail", { message, ...fields });
+    }
+  };
+}
+var log = createLogger();
+
+// src/bot/approvals.ts
+var ApprovalRegistry = class {
+  pending = /* @__PURE__ */ new Map();
+  register(scope, request) {
+    const key = `${scope}:${request.id}`;
+    const existing = this.pending.get(key);
+    if (existing) return Promise.resolve("cancelled");
+    return new Promise((resolve5) => {
+      this.pending.set(key, { request, resolve: resolve5, settled: false });
+    });
+  }
+  resolve(scope, id, outcome) {
+    const key = `${scope}:${id}`;
+    const pending = this.pending.get(key);
+    if (!pending || pending.settled) return false;
+    pending.settled = true;
+    this.pending.delete(key);
+    pending.resolve(outcome);
+    return true;
+  }
+  /** Settle every pending approval for a scope (run end / dispose). */
+  settleAll(scope, outcome) {
+    let count = 0;
+    for (const [key, pending] of this.pending) {
+      if (!key.startsWith(`${scope}:`)) continue;
+      if (pending.settled) continue;
+      pending.settled = true;
+      this.pending.delete(key);
+      pending.resolve(outcome);
+      count += 1;
+    }
+    if (count > 0) {
+      log.warn("approvals", "settled-pending", { scope, outcome, count });
+    }
+    return count;
+  }
+  pendingCount(scope) {
+    let count = 0;
+    for (const key of this.pending.keys()) {
+      if (key.startsWith(`${scope}:`)) count += 1;
+    }
+    return count;
+  }
+};
+
+// src/bot/density-store.ts
+var DensityStore = class {
+  constructor(defaultDensity = "standard") {
+    this.defaultDensity = defaultDensity;
+  }
+  defaultDensity;
+  overrides = /* @__PURE__ */ new Map();
+  get(scope) {
+    return this.overrides.get(scope) ?? this.defaultDensity;
+  }
+  set(scope, density) {
+    this.overrides.set(scope, density);
+  }
+  clear(scope) {
+    return this.overrides.delete(scope);
+  }
+};
+
+// src/bot/pending-queue.ts
+var PendingQueue = class {
+  constructor(quietMs, onFlush) {
+    this.quietMs = quietMs;
+    this.onFlush = onFlush;
+  }
+  quietMs;
+  onFlush;
+  pending = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  blocked = /* @__PURE__ */ new Set();
+  flushing = /* @__PURE__ */ new Set();
+  push(scope, item) {
+    const batch = this.pending.get(scope) ?? [];
+    batch.push(item);
+    this.pending.set(scope, batch);
+    this.schedule(scope);
+  }
+  block(scope) {
+    this.blocked.add(scope);
+    this.clearTimer(scope);
+  }
+  unblock(scope) {
+    this.blocked.delete(scope);
+    this.schedule(scope);
+  }
+  async flushNow(scope) {
+    this.clearTimer(scope);
+    if (this.flushing.has(scope)) return;
+    const batch = this.pending.get(scope) ?? [];
+    this.pending.delete(scope);
+    if (batch.length === 0) return;
+    this.flushing.add(scope);
+    try {
+      await this.onFlush(scope, batch);
+    } finally {
+      this.flushing.delete(scope);
+    }
+  }
+  hasPending(scope) {
+    return (this.pending.get(scope)?.length ?? 0) > 0;
+  }
+  isBlocked(scope) {
+    return this.blocked.has(scope);
+  }
+  schedule(scope) {
+    if (this.blocked.has(scope) || this.flushing.has(scope)) return;
+    if (this.timers.has(scope)) return;
+    if (!this.hasPending(scope)) return;
+    this.timers.set(
+      scope,
+      setTimeout(() => {
+        this.timers.delete(scope);
+        void this.flushNow(scope);
+      }, this.quietMs)
+    );
+  }
+  clearTimer(scope) {
+    const timer = this.timers.get(scope);
+    if (timer === void 0) return;
+    clearTimeout(timer);
+    this.timers.delete(scope);
+  }
+};
+
+// src/bot/questions.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var QuestionRegistry = class {
+  pending = /* @__PURE__ */ new Map();
+  register(scope, input) {
+    const id = `question-${randomUUID3().replaceAll("-", "")}`;
+    const full = { ...input, id };
+    const promise = new Promise((resolve5) => {
+      this.pending.set(`${scope}:${id}`, { input: full, resolve: resolve5, settled: false });
+    });
+    return { id, promise };
+  }
+  resolve(scope, id, answer) {
+    const pending = this.pending.get(`${scope}:${id}`);
+    if (!pending || pending.settled) return false;
+    pending.settled = true;
+    this.pending.delete(`${scope}:${id}`);
+    pending.resolve(answer);
+    return true;
+  }
+  settleAll(scope) {
+    let count = 0;
+    for (const [key, pending] of this.pending) {
+      if (!key.startsWith(`${scope}:`)) continue;
+      if (pending.settled) continue;
+      pending.settled = true;
+      this.pending.delete(key);
+      pending.resolve(void 0);
+      count += 1;
+    }
+    return count;
+  }
+  get(scope, id) {
+    return this.pending.get(`${scope}:${id}`)?.input;
+  }
+};
+
+// src/bot/run-policy.ts
+var RunPolicyStore = class {
+  timeouts = /* @__PURE__ */ new Map();
+  get(scope) {
+    return this.timeouts.get(scope);
+  }
+  set(scope, runTimeoutMs) {
+    this.timeouts.set(scope, runTimeoutMs);
+  }
+  clear(scope) {
+    return this.timeouts.delete(scope);
+  }
+};
+
+// src/bridge/channel.ts
+import { createLarkChannel } from "@larksuite/channel";
+
+// src/commands/index.ts
+import { resolve as resolve4 } from "path";
+
+// src/card/workspace-card.ts
+function renderWorkspaceCard(input) {
+  const entries = input.index;
+  const markdown2 = [
+    `**\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55**
+\`${input.current}\``,
+    "",
+    ...entries.length > 0 ? entries.map(
+      ({ name, cwd, lastUsed }) => `- **${name}** \u2192 \`${cwd}\`${lastUsed ? ` \xB7 ${new Date(lastUsed).toLocaleString()}` : ""}`
+    ) : ["\u6682\u65E0\u547D\u540D\u5DE5\u4F5C\u7A7A\u95F4\u3002"]
+  ].join("\n");
+  return {
+    schema: "2.0",
+    config: {
+      summary: { content: "\u5DE5\u4F5C\u7A7A\u95F4\u5BFC\u822A" }
+    },
+    body: {
+      elements: [
+        {
+          tag: "markdown",
+          content: markdown2
+        }
+      ]
+    }
+  };
+}
+
+// src/card/density.ts
+var CARD_DENSITIES = ["compact", "standard", "detailed"];
+function parseCardDensity(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return void 0;
+  if (CARD_DENSITIES.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+
+// src/bridge/run-flow.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/card/run-state.ts
+var initialState = {
+  blocks: [],
+  reasoning: { content: "", active: false },
+  usage: void 0,
+  footer: "thinking",
+  terminal: "running",
+  errorMsg: void 0,
+  idleTimeoutMinutes: void 0
+};
+function closeStreamingText(blocks) {
+  return blocks.map(
+    (block) => block.kind === "text" && block.streaming ? { ...block, streaming: false } : block
+  );
+}
+function reduce(state, event) {
+  switch (event.type) {
+    case "text": {
+      const last = state.blocks[state.blocks.length - 1];
+      if (last?.kind === "text" && last.streaming) {
+        return {
+          ...state,
+          blocks: [
+            ...state.blocks.slice(0, -1),
+            { ...last, content: last.content + event.delta }
+          ],
+          reasoning: { ...state.reasoning, active: false },
+          footer: "streaming"
+        };
+      }
+      return {
+        ...state,
+        blocks: [...state.blocks, { kind: "text", content: event.delta, streaming: true }],
+        reasoning: { ...state.reasoning, active: false },
+        footer: "streaming"
+      };
     }
+    case "thinking":
+      return {
+        ...state,
+        reasoning: {
+          content: state.reasoning.content + event.delta,
+          active: true
+        },
+        footer: "thinking"
+      };
+    case "final_text":
+      return {
+        ...state,
+        blocks: [
+          ...closeStreamingText(state.blocks),
+          { kind: "text", content: event.content, streaming: false }
+        ],
+        reasoning: { ...state.reasoning, active: false },
+        footer: null
+      };
+    case "usage":
+      return {
+        ...state,
+        usage: {
+          inputTokens: event.inputTokens,
+          outputTokens: event.outputTokens
+        }
+      };
+    case "tool_use":
+      return {
+        ...state,
+        blocks: [
+          ...closeStreamingText(state.blocks),
+          {
+            kind: "tool",
+            tool: {
+              id: event.id,
+              name: event.name,
+              input: event.input,
+              status: "running"
+            }
+          }
+        ],
+        reasoning: { ...state.reasoning, active: false },
+        footer: "tool_running"
+      };
+    case "tool_result":
+      return {
+        ...state,
+        blocks: state.blocks.map((block) => {
+          if (block.kind !== "tool" || block.tool.id !== event.id) return block;
+          return {
+            ...block,
+            tool: {
+              ...block.tool,
+              status: event.isError ? "error" : "done",
+              output: event.output
+            }
+          };
+        })
+      };
+    case "error":
+      return {
+        ...state,
+        terminal: event.terminationReason === "interrupted" ? "interrupted" : event.terminationReason === "timeout" ? "idle_timeout" : "error",
+        errorMsg: event.terminationReason === "failed" ? event.message : void 0,
+        idleTimeoutMinutes: void 0,
+        footer: null
+      };
+    case "done":
+      return {
+        ...state,
+        blocks: closeStreamingText(state.blocks),
+        reasoning: { ...state.reasoning, active: false },
+        terminal: event.terminationReason === "interrupted" ? "interrupted" : event.terminationReason === "timeout" ? "idle_timeout" : "done",
+        footer: null
+      };
+    default:
+      return state;
+  }
+}
+function markInterrupted(state) {
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoning: { ...state.reasoning, active: false },
+    terminal: "interrupted",
+    footer: null
+  };
+}
+function markIdleTimeout(state, minutes) {
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoning: { ...state.reasoning, active: false },
+    terminal: "idle_timeout",
+    footer: null,
+    idleTimeoutMinutes: minutes
+  };
+}
+function finalizeIfRunning(state) {
+  if (state.terminal !== "running") return state;
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoning: { ...state.reasoning, active: false },
+    terminal: "done",
+    footer: null
   };
 }
 
-// src/bridge/channel.ts
-async function startChannel(deps) {
-  const channel = (deps.createChannel ?? createLarkChannel)({
-    appId: deps.appId,
-    appSecret: deps.appSecret,
-    domain: deps.tenant === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn",
-    source: "dsh-lark-bot",
-    policy: {
-      dmMode: deps.allowedUsers?.length ? "allowlist" : "open",
-      requireMention: true,
-      respondToMentionAll: false,
-      ...deps.allowedUsers ? { dmAllowlist: deps.allowedUsers } : {},
-      ...deps.allowedChats ? { groupAllowlist: deps.allowedChats } : {}
-    },
-    safety: {
-      chatQueue: { enabled: false }
+// src/card/run-renderer.ts
+function markdown(content) {
+  return { tag: "markdown", content };
+}
+function noteMd(content) {
+  return { tag: "markdown", content, text_size: "notation" };
+}
+function footerStatus(status) {
+  const text = status === "thinking" ? "\u{1F9E0} \u6B63\u5728\u601D\u8003" : status === "tool_running" ? "\u{1F9F0} \u6B63\u5728\u8C03\u7528\u5DE5\u5177" : "\u270D\uFE0F \u6B63\u5728\u8F93\u51FA";
+  return noteMd(text);
+}
+function summaryText(state) {
+  if (state.terminal === "interrupted") return "\u5DF2\u4E2D\u65AD";
+  if (state.terminal === "idle_timeout") return "\u5DF2\u8D85\u65F6";
+  if (state.terminal === "error") return "\u51FA\u9519";
+  if (state.terminal === "done") return "\u5DF2\u5B8C\u6210";
+  if (state.footer === "tool_running") return "\u6B63\u5728\u8C03\u7528\u5DE5\u5177";
+  if (state.footer === "streaming") return "\u6B63\u5728\u8F93\u51FA";
+  return "\u601D\u8003\u4E2D";
+}
+function stopButton() {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: "\u23F9 \u7EC8\u6B62" },
+    type: "danger",
+    value: { cmd: "stop" }
+  };
+}
+function textBlock(block) {
+  return markdown(block.content);
+}
+function toolBlock(tool) {
+  const icon = tool.status === "error" ? "\u26A0\uFE0F" : tool.status === "done" ? "\u2705" : "\u23F3";
+  return markdown(`${icon} **${tool.name}**`);
+}
+function usageLine(state) {
+  if (!state.usage) return "";
+  const parts = [];
+  if (state.usage.inputTokens !== void 0) parts.push(`in ${state.usage.inputTokens}`);
+  if (state.usage.outputTokens !== void 0) parts.push(`out ${state.usage.outputTokens}`);
+  return parts.length ? `\uFF08tokens ${parts.join(" \xB7 ")}\uFF09` : "";
+}
+function renderStandard(state) {
+  const elements = [];
+  if (state.reasoning.content) {
+    elements.push(
+      noteMd(
+        state.reasoning.active ? "\u{1F9E0} \u6B63\u5728\u601D\u8003\u2026" : `\u{1F9E0} \u601D\u8003\u5B8C\u6210\uFF1A${state.reasoning.content.slice(0, 300)}`
+      )
+    );
+  }
+  for (const block of state.blocks) {
+    if (block.kind === "text") {
+      elements.push(textBlock(block));
+    } else if (block.tool.status !== "done") {
+      elements.push(toolBlock(block.tool));
+    }
+  }
+  if (state.terminal === "interrupted") {
+    elements.push(noteMd("_\u23F9 \u5DF2\u88AB\u4E2D\u65AD_"));
+  } else if (state.terminal === "idle_timeout") {
+    elements.push(noteMd(`_\u23F1 ${state.idleTimeoutMinutes ?? 0} \u5206\u949F\u65E0\u54CD\u5E94\uFF0C\u5DF2\u81EA\u52A8\u7EC8\u6B62_`));
+  } else if (state.terminal === "error" && state.errorMsg) {
+    elements.push(noteMd(`\u26A0\uFE0F agent \u5931\u8D25\uFF1A${state.errorMsg}`));
+  } else if (state.terminal === "done" && elements.length === 0) {
+    elements.push(noteMd("_\uFF08\u672A\u8FD4\u56DE\u5185\u5BB9\uFF09_"));
+  } else if (state.terminal === "done") {
+    const usage = usageLine(state);
+    if (usage) elements.push(noteMd(usage));
+  }
+  if (state.terminal === "running") {
+    if (state.footer) elements.push(footerStatus(state.footer));
+    elements.push(stopButton());
+  }
+  return {
+    schema: "2.0",
+    config: {
+      streaming_mode: state.terminal === "running",
+      summary: { content: summaryText(state) }
     },
-    outbound: {
-      streamThrottleMs: 400
+    body: { elements }
+  };
+}
+function renderCompact(state) {
+  const elements = [noteMd(summaryText(state))];
+  if (state.terminal === "running" && state.footer) {
+    elements.push(footerStatus(state.footer));
+  }
+  if (state.terminal === "running") {
+    elements.push(stopButton());
+  }
+  return {
+    schema: "2.0",
+    config: {
+      streaming_mode: state.terminal === "running",
+      summary: { content: summaryText(state) }
     },
-    includeRawEvent: true,
-    handshakeTimeoutMs: 8e3,
-    httpTimeoutMs: 3e4,
-    respectProxyEnv: true
-  });
-  const streaming = adaptLarkChannel(channel);
-  const commandChannel = streaming;
-  channel.on({
-    message: async (msg) => {
-      const scope = scopeForMessage(msg);
-      const context = {
-        scope,
-        chatId: msg.chatId,
-        messageId: msg.messageId,
-        threadId: msg.threadId,
-        chatMode: msg.chatMode ?? msg.chatType,
-        sessions: deps.sessions,
-        workspaces: deps.workspaces,
-        activeRuns: deps.activeRuns,
-        runPolicies: deps.runPolicies,
-        defaultRunTimeoutMs: deps.defaultRunTimeoutMs,
-        accessManager: deps.accessManager,
-        channel: commandChannel,
-        defaultWorkspace: deps.defaultWorkspace
-      };
-      const handled = await tryHandleCommand(msg.content, context).catch((error) => {
-        log.fail("channel-command", error, { scope });
-        return false;
-      });
-      if (!handled) deps.pending.push(scope, msg);
+    body: { elements }
+  };
+}
+function renderDetailed(state) {
+  const elements = [];
+  if (state.reasoning.content) {
+    elements.push(
+      noteMd(
+        state.reasoning.active ? "\u{1F9E0} \u6B63\u5728\u601D\u8003\u2026" : `\u{1F9E0} **\u601D\u8003\u8FC7\u7A0B**
+${state.reasoning.content.slice(0, 2e3)}`
+      )
+    );
+  }
+  for (const block of state.blocks) {
+    if (block.kind === "text") {
+      elements.push(textBlock(block));
+      continue;
+    }
+    const tool = block.tool;
+    const icon = tool.status === "error" ? "\u26A0\uFE0F" : tool.status === "done" ? "\u2705" : "\u23F3";
+    const lines = [`${icon} **${tool.name}**`];
+    if (tool.input !== void 0 && tool.input !== "") {
+      lines.push(`\u8F93\u5165\uFF1A\`\`\`
+${safeJsonPreview(tool.input)}
+\`\`\``);
+    }
+    if (tool.output) {
+      lines.push(`\u8F93\u51FA\uFF1A${tool.output.slice(0, 500)}`);
+    }
+    elements.push(markdown(lines.join("\n")));
+  }
+  if (state.terminal === "interrupted") {
+    elements.push(noteMd("_\u23F9 \u5DF2\u88AB\u4E2D\u65AD_"));
+  } else if (state.terminal === "idle_timeout") {
+    elements.push(noteMd(`_\u23F1 ${state.idleTimeoutMinutes ?? 0} \u5206\u949F\u65E0\u54CD\u5E94\uFF0C\u5DF2\u81EA\u52A8\u7EC8\u6B62_`));
+  } else if (state.terminal === "error" && state.errorMsg) {
+    elements.push(noteMd(`\u26A0\uFE0F agent \u5931\u8D25\uFF1A${state.errorMsg}`));
+  } else if (state.terminal === "done") {
+    const usage = usageLine(state);
+    if (usage) elements.push(noteMd(usage));
+  }
+  if (state.terminal === "running") {
+    if (state.footer) elements.push(footerStatus(state.footer));
+    elements.push(stopButton());
+  }
+  return {
+    schema: "2.0",
+    config: {
+      streaming_mode: state.terminal === "running",
+      summary: { content: summaryText(state) }
     },
-    cardAction: async (event) => {
-      const value = event.action.value && typeof event.action.value === "object" ? event.action.value : void 0;
-      if (value?.cmd === "stop") {
-        const scope = event.raw ? await resolveCardScope(event.chatId, event.raw) : event.chatId;
-        await deps.activeRuns.interrupt(scope);
+    body: { elements }
+  };
+}
+function safeJsonPreview(value) {
+  if (typeof value === "string") return value.slice(0, 300);
+  try {
+    return JSON.stringify(value).slice(0, 300);
+  } catch {
+    return String(value).slice(0, 300);
+  }
+}
+function renderCard(state, density = "standard") {
+  if (density === "compact") return renderCompact(state);
+  if (density === "detailed") return renderDetailed(state);
+  return renderStandard(state);
+}
+
+// src/card/approval-card.ts
+function renderApprovalCard(input) {
+  const allow = input.options.find((option) => option.kind === "allow_once") ?? input.options.find((option) => option.kind === "allow_always");
+  const reject = input.options.find((option) => option.kind === "reject_once") ?? input.options.find((option) => option.kind === "reject_always");
+  const markdown2 = [
+    "\u{1F510} **\u5BA1\u6279\u8BF7\u6C42**",
+    "",
+    `**\u5DE5\u5177** \`${input.toolName}\``,
+    ...input.reason ? ["", input.reason] : []
+  ].join("\n");
+  const actions = [
+    ...allow ? [
+      {
+        tag: "button",
+        text: { tag: "plain_text", content: `\u2705 ${allow.name}` },
+        type: "primary",
+        value: { cmd: "approve", id: input.id, outcome: "allow" }
       }
+    ] : [],
+    ...reject ? [
+      {
+        tag: "button",
+        text: { tag: "plain_text", content: `\u26D4 ${reject.name}` },
+        type: "danger",
+        value: { cmd: "approve", id: input.id, outcome: "reject" }
+      }
+    ] : []
+  ];
+  return {
+    schema: "2.0",
+    config: {
+      summary: { content: "\u5BA1\u6279\u8BF7\u6C42" }
     },
-    reconnecting: () => {
-      log.warn("channel", "reconnecting", {});
-    },
-    reconnected: () => {
-      log.info("channel", "reconnected", {});
-    },
-    error: (error) => {
-      log.fail("channel", error);
+    body: {
+      elements: [
+        { tag: "markdown", content: markdown2 },
+        { tag: "action", actions }
+      ]
     }
-  });
-  await channel.connect();
+  };
+}
+
+// src/card/question-card.ts
+function formElement(input) {
+  if (input.kind === "text") {
+    return {
+      tag: "input",
+      name: "answer",
+      placeholder: { tag: "plain_text", content: input.placeholder ?? "\u8BF7\u8F93\u5165\u7B54\u6848\u2026" }
+    };
+  }
+  const options = (input.options ?? []).map((option, index) => ({
+    text: { tag: "plain_text", content: option },
+    value: `option-${index}`
+  }));
+  if (input.kind === "multi") {
+    return {
+      tag: "multi_select_static",
+      name: "answer",
+      placeholder: { tag: "plain_text", content: "\u8BF7\u9009\u62E9\uFF08\u53EF\u591A\u9009\uFF09\u2026" },
+      options
+    };
+  }
   return {
-    channel,
-    disconnect: () => channel.disconnect()
+    tag: "select_static",
+    name: "answer",
+    placeholder: { tag: "plain_text", content: "\u8BF7\u9009\u62E9\u2026" },
+    options
+  };
+}
+function renderQuestionCard(input) {
+  return {
+    schema: "2.0",
+    config: {
+      summary: { content: "\u95EE\u9898" }
+    },
+    body: {
+      elements: [
+        { tag: "markdown", content: `\u2753 ${input.question}` },
+        formElement(input),
+        {
+          tag: "action",
+          actions: [
+            {
+              tag: "button",
+              text: { tag: "plain_text", content: "\u63D0\u4EA4" },
+              type: "primary",
+              value: { cmd: "question-submit", id: input.id }
+            }
+          ]
+        }
+      ]
+    }
   };
 }
-function scopeForMessage(msg) {
-  if (msg.chatMode === "topic" && msg.threadId) return `${msg.chatId}:${msg.threadId}`;
-  return msg.chatId;
-}
-async function resolveCardScope(chatId, raw) {
-  return raw.message?.thread_id ? `${chatId}:${raw.message.thread_id}` : chatId;
+function extractQuestionAnswer(kind, value, options) {
+  const answer = value;
+  if (kind === "text") {
+    return typeof answer === "string" && answer.trim() ? answer.trim() : void 0;
+  }
+  const selected = Array.isArray(answer) ? answer.map((item) => String(item)) : typeof answer === "string" && answer ? [answer] : [];
+  if (selected.length === 0) return void 0;
+  const labels = options ?? [];
+  const resolved = selected.map((item) => {
+    const match = /^option-(\d+)$/.exec(item);
+    if (match) {
+      const index = Number(match[1]);
+      return labels[index] ?? item;
+    }
+    return item;
+  });
+  return kind === "single" ? resolved[0] : resolved;
 }
 
 // src/bridge/run-flow.ts
-import { randomUUID } from "crypto";
-
-// src/card/run-state.ts
-var initialState = {
-  blocks: [],
-  reasoning: { content: "", active: false },
-  footer: "thinking",
-  terminal: "running",
-  errorMsg: void 0,
-  idleTimeoutMinutes: void 0
-};
-function closeStreamingText(blocks) {
-  return blocks.map(
-    (block) => block.kind === "text" && block.streaming ? { ...block, streaming: false } : block
-  );
-}
-function reduce(state, event) {
-  switch (event.type) {
-    case "text": {
-      const last = state.blocks[state.blocks.length - 1];
-      if (last?.kind === "text" && last.streaming) {
-        return {
-          ...state,
-          blocks: [
-            ...state.blocks.slice(0, -1),
-            { ...last, content: last.content + event.delta }
-          ],
-          reasoning: { ...state.reasoning, active: false },
-          footer: "streaming"
-        };
-      }
-      return {
-        ...state,
-        blocks: [...state.blocks, { kind: "text", content: event.delta, streaming: true }],
-        reasoning: { ...state.reasoning, active: false },
-        footer: "streaming"
-      };
-    }
-    case "thinking":
-      return {
-        ...state,
-        reasoning: {
-          content: state.reasoning.content + event.delta,
-          active: true
-        },
-        footer: "thinking"
-      };
-    case "final_text":
-      return {
-        ...state,
-        blocks: [
-          ...closeStreamingText(state.blocks),
-          { kind: "text", content: event.content, streaming: false }
-        ],
-        reasoning: { ...state.reasoning, active: false },
-        footer: null
-      };
-    case "tool_use":
-      return {
-        ...state,
-        blocks: [
-          ...closeStreamingText(state.blocks),
-          {
-            kind: "tool",
-            tool: {
-              id: event.id,
-              name: event.name,
-              input: event.input,
-              status: "running"
+async function runAgentBatch(input) {
+  const replyOptions = input.replyTo ? { replyTo: input.replyTo } : {};
+  if (input.activeRuns.get(input.scope)) {
+    await input.channel.sendMarkdown(input.chatId, "\u5F53\u524D\u4F1A\u8BDD\u5DF2\u6709\u4EFB\u52A1\u6B63\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148 `/stop` \u6216\u7B49\u5F85\u5B8C\u6210\u3002", {
+      ...replyOptions
+    });
+    return;
+  }
+  const requestedCwd = input.workspaces.cwdFor(input.scope) ?? input.defaultWorkspace;
+  const workspace = input.workspaceManager ? await input.workspaceManager.ensure(input.scope, requestedCwd) : { cwd: requestedCwd };
+  const cwd = workspace.cwd;
+  const sessionId = input.sessions.resumeFor(input.scope, cwd);
+  const history = input.sessions.historyFor(input.scope, cwd);
+  const prompt = buildPrompt(history, input.messages);
+  const runId = randomUUID4();
+  const run = input.adapter.run({
+    runId,
+    prompt,
+    cwd,
+    sessionId,
+    model: input.model,
+    images: input.images,
+    stopGraceMs: input.stopGraceMs,
+    ...input.approvals ? {
+      onApprovalRequest: approvalHandlerFor({
+        approvals: input.approvals,
+        channel: input.channel,
+        chatId: input.chatId,
+        scope: input.scope
+      })
+    } : {}
+  });
+  input.activeRuns.set(input.scope, { runId, stop: run.stop });
+  let state = initialState;
+  const stopRequested = { value: false };
+  const timeoutMs = input.runPolicies?.get(input.scope) ?? input.runTimeoutMs ?? 0;
+  let timedOut = false;
+  let assistantOutput = "";
+  const density = input.densityStore?.get(input.scope) ?? "standard";
+  try {
+    await input.channel.streamCard(
+      input.chatId,
+      renderCard(state, density),
+      async (controller) => {
+        const consume = async () => {
+          for await (const event of run.events) {
+            if (timedOut) return;
+            state = applyEvent(state, event, stopRequested);
+            if (event.type === "final_text") {
+              assistantOutput = event.content;
+            } else if (event.type === "text") {
+              assistantOutput += event.delta;
             }
-          }
-        ],
-        reasoning: { ...state.reasoning, active: false },
-        footer: "tool_running"
-      };
-    case "tool_result":
-      return {
-        ...state,
-        blocks: state.blocks.map((block) => {
-          if (block.kind !== "tool" || block.tool.id !== event.id) return block;
-          return {
-            ...block,
-            tool: {
-              ...block.tool,
-              status: event.isError ? "error" : "done",
-              output: event.output
+            if (event.type === "system" && event.sessionId) {
+              input.sessions.set(input.scope, event.sessionId, event.cwd ?? cwd);
             }
-          };
-        })
-      };
-    case "error":
-      return {
-        ...state,
-        terminal: event.terminationReason === "interrupted" ? "interrupted" : event.terminationReason === "timeout" ? "idle_timeout" : "error",
-        errorMsg: event.terminationReason === "failed" ? event.message : void 0,
-        idleTimeoutMinutes: void 0,
-        footer: null
-      };
-    case "done":
-      return {
-        ...state,
-        blocks: closeStreamingText(state.blocks),
-        reasoning: { ...state.reasoning, active: false },
-        terminal: event.terminationReason === "interrupted" ? "interrupted" : event.terminationReason === "timeout" ? "idle_timeout" : "done",
-        footer: null
-      };
-    default:
-      return state;
+            await controller.update(renderCard(state, density));
+          }
+        };
+        let timeoutTimer;
+        const timeoutPromise = timeoutMs > 0 ? new Promise((resolve5) => {
+          timeoutTimer = setTimeout(() => {
+            timedOut = true;
+            void run.stop();
+            resolve5();
+          }, timeoutMs);
+        }) : void 0;
+        try {
+          if (timeoutPromise) {
+            await Promise.race([consume(), timeoutPromise]);
+          } else {
+            await consume();
+          }
+          state = timedOut ? markIdleTimeout(state, timeoutMs / 6e4) : finalizeIfRunning(state);
+          await controller.update(renderCard(state, density));
+        } finally {
+          if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
+        }
+      },
+      replyOptions
+    );
+    input.sessions.recordExchange(input.scope, cwd, input.messages, assistantOutput);
+  } catch (error) {
+    log.fail("run-flow", error, { scope: input.scope, runId });
+    state = markInterrupted(state);
+    try {
+      await input.channel.sendMarkdown(input.chatId, `\u26A0\uFE0F agent \u8FD0\u884C\u5931\u8D25\uFF1A${errorMessage(error)}`, {
+        ...replyOptions
+      });
+    } catch {
+    }
+  } finally {
+    input.activeRuns.delete(input.scope);
+    if (input.approvals) {
+      input.approvals.settleAll(input.scope, "cancelled");
+    }
+    if (input.questions) {
+      input.questions.settleAll(input.scope);
+    }
   }
 }
-function markInterrupted(state) {
-  return {
-    ...state,
-    blocks: closeStreamingText(state.blocks),
-    reasoning: { ...state.reasoning, active: false },
-    terminal: "interrupted",
-    footer: null
+function approvalHandlerFor(input) {
+  return async (request) => {
+    if (!input.approvals || !input.channel.sendCard) return "cancelled";
+    const promise = input.approvals.register(input.scope, request);
+    try {
+      await input.channel.sendCard(
+        input.chatId,
+        renderApprovalCard({
+          id: request.id,
+          toolName: request.toolName,
+          reason: request.reason,
+          options: request.options
+        })
+      );
+    } catch (error) {
+      log.fail("approval-card", error, { scope: input.scope });
+      input.approvals.settleAll(input.scope, "cancelled");
+      return "cancelled";
+    }
+    return promise;
   };
 }
-function markIdleTimeout(state, minutes) {
-  return {
-    ...state,
-    blocks: closeStreamingText(state.blocks),
-    reasoning: { ...state.reasoning, active: false },
-    terminal: "idle_timeout",
-    footer: null,
-    idleTimeoutMinutes: minutes
+function questionHandlerFor(input) {
+  return async (question) => {
+    if (!input.questions || !input.channel.sendCard) return void 0;
+    const { id, promise } = input.questions.register(input.scope, {
+      kind: question.kind,
+      question: question.question,
+      ...question.options === void 0 ? {} : { options: question.options },
+      ...question.placeholder === void 0 ? {} : { placeholder: question.placeholder }
+    });
+    try {
+      await input.channel.sendCard(input.chatId, renderQuestionCard({ ...question, id }));
+    } catch (error) {
+      log.fail("question-card", error, { scope: input.scope });
+      input.questions.settleAll(input.scope);
+      return void 0;
+    }
+    return promise;
   };
 }
-function finalizeIfRunning(state) {
-  if (state.terminal !== "running") return state;
-  return {
-    ...state,
-    blocks: closeStreamingText(state.blocks),
-    reasoning: { ...state.reasoning, active: false },
-    terminal: "done",
-    footer: null
-  };
+function buildPrompt(history, messages) {
+  if (history.length === 0) return messages.join("\n\n");
+  const transcript = history.map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.content}`).join("\n\n");
+  return [
+    "Continue the conversation using the history below.",
+    "",
+    transcript,
+    "",
+    `Current user message:
+${messages.join("\n\n")}`
+  ].join("\n");
+}
+function applyEvent(state, event, stopRequested) {
+  if (event.type === "done" && event.terminationReason === "interrupted") {
+    stopRequested.value = true;
+    return markInterrupted(state);
+  }
+  if (event.type === "error" && event.terminationReason === "timeout") {
+    return markIdleTimeout(state, 0);
+  }
+  return reduce(state, event);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/index.ts
+var HELP = [
+  "**dsh-lark-bot \u547D\u4EE4**",
+  "",
+  "- `/new` `/reset` \u2014 \u5F00\u59CB\u65B0\u4F1A\u8BDD",
+  "- `/cd <path>` \u2014 \u5207\u6362\u5DE5\u4F5C\u76EE\u5F55\u5E76\u91CD\u7F6E\u4F1A\u8BDD",
+  "- `/ws list|save <name>|use <name>|remove <name>` \u2014 \u7BA1\u7406\u5DE5\u4F5C\u7A7A\u95F4",
+  "- `/status` \u2014 \u67E5\u770B\u5F53\u524D\u72B6\u6001",
+  "- `/resume` \u2014 \u67E5\u770B\u5F53\u524D\u4F1A\u8BDD\u6700\u8FD1\u4E0A\u4E0B\u6587",
+  "- `/stop` \u2014 \u7EC8\u6B62\u5F53\u524D\u4EFB\u52A1",
+  "- `/timeout [N|off|default]` \u2014 \u67E5\u770B\u6216\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6",
+  "- `/density [compact|standard|detailed]` \u2014 \u67E5\u770B\u6216\u8BBE\u7F6E\u5361\u7247\u5BC6\u5EA6",
+  "- `/ask <\u95EE\u9898>` \u2014 \u53D1\u9001\u7ED3\u6784\u5316\u95EE\u7B54\u5361\uFF08\u56DE\u7B54\u5C06\u8BB0\u5165\u4F1A\u8BDD\uFF09",
+  "- `/invite user|admin|group <id>` \u2014 \u7BA1\u7406\u8BBF\u95EE\u767D\u540D\u5355",
+  "- `/help` \u2014 \u663E\u793A\u672C\u5E2E\u52A9"
+].join("\n");
+async function reply(ctx, markdown2) {
+  await ctx.channel.sendMarkdown(ctx.chatId, markdown2, {
+    replyTo: ctx.messageId
+  });
+}
+async function handleNew(_args, ctx) {
+  const wasRunning = await ctx.activeRuns.interrupt(ctx.scope);
+  ctx.sessions.clear(ctx.scope);
+  await reply(ctx, wasRunning ? "\u5DF2\u4E2D\u65AD\u5F53\u524D\u4EFB\u52A1\u5E76\u5F00\u59CB\u65B0\u4F1A\u8BDD\u3002" : "\u5DF2\u5F00\u59CB\u65B0\u4F1A\u8BDD\u3002");
 }
-
-// src/card/run-renderer.ts
-function markdown(content) {
-  return { tag: "markdown", content };
+async function handleCd(args, ctx) {
+  const path = args.trim();
+  if (!path) {
+    await reply(ctx, "\u7528\u6CD5\uFF1A`/cd <path>`");
+    return;
+  }
+  const cwd = resolve4(path);
+  await ctx.activeRuns.interrupt(ctx.scope);
+  ctx.workspaces.setCwd(ctx.scope, cwd);
+  ctx.sessions.clear(ctx.scope);
+  await reply(ctx, `\u5DF2\u5207\u6362\u5DE5\u4F5C\u76EE\u5F55\uFF1A\`${cwd}\`\uFF0C\u4F1A\u8BDD\u5DF2\u91CD\u7F6E\u3002`);
 }
-function noteMd(content) {
-  return { tag: "markdown", content, text_size: "notation" };
+async function handleWs(args, ctx) {
+  const [sub, ...rest] = args.trim().split(/\s+/);
+  const name = rest.join(" ").trim();
+  if (!sub || sub === "list") {
+    const current = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
+    const named = ctx.workspaces.listNamed();
+    const index = ctx.workspaces.listIndex();
+    if (ctx.channel.sendCard) {
+      await ctx.channel.sendCard(ctx.chatId, renderWorkspaceCard({ current, index }));
+      return;
+    }
+    const lines = Object.entries(named).map(
+      ([key, value]) => `- **${key}** \u2192 \`${value}\`${value === current ? " \u2190 \u5F53\u524D" : ""}`
+    );
+    await reply(
+      ctx,
+      [
+        `\u5F53\u524D cwd\uFF1A\`${current}\``,
+        "",
+        ...lines.length > 0 ? lines : ["\u6682\u65E0\u547D\u540D\u5DE5\u4F5C\u7A7A\u95F4\u3002"]
+      ].join("\n")
+    );
+    return;
+  }
+  if (sub === "save") {
+    if (!name) {
+      await reply(ctx, "\u7528\u6CD5\uFF1A`/ws save <name>`");
+      return;
+    }
+    const current = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
+    ctx.workspaces.saveNamed(name, current);
+    await reply(ctx, `\u5DF2\u4FDD\u5B58\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}** \u2192 \`${current}\``);
+    return;
+  }
+  if (sub === "use") {
+    if (!name) {
+      await reply(ctx, "\u7528\u6CD5\uFF1A`/ws use <name>`");
+      return;
+    }
+    const cwd = ctx.workspaces.getNamed(name);
+    if (!cwd) {
+      await reply(ctx, `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`);
+      return;
+    }
+    await ctx.activeRuns.interrupt(ctx.scope);
+    ctx.workspaces.setCwd(ctx.scope, cwd);
+    ctx.workspaces.touchNamed(name);
+    ctx.sessions.clear(ctx.scope);
+    await reply(ctx, `\u5DF2\u5207\u6362\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}** \u2192 \`${cwd}\``);
+    return;
+  }
+  if (sub === "remove") {
+    if (!name) {
+      await reply(ctx, "\u7528\u6CD5\uFF1A`/ws remove <name>`");
+      return;
+    }
+    const removed = ctx.workspaces.removeNamed(name);
+    await reply(ctx, removed ? `\u5DF2\u5220\u9664\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**` : `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`);
+    return;
+  }
+  await reply(ctx, "\u672A\u77E5 `/ws` \u5B50\u547D\u4EE4\uFF0C\u8BF7\u4F7F\u7528 list / save / use / remove\u3002");
 }
-function footerStatus(status) {
-  const text = status === "thinking" ? "\u{1F9E0} \u6B63\u5728\u601D\u8003" : status === "tool_running" ? "\u{1F9F0} \u6B63\u5728\u8C03\u7528\u5DE5\u5177" : "\u270D\uFE0F \u6B63\u5728\u8F93\u51FA";
-  return noteMd(text);
+async function handleStatus(_args, ctx) {
+  const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
+  const session = ctx.sessions.getRaw(ctx.scope)?.sessionId ?? "(\u65E0)";
+  const running = Boolean(ctx.activeRuns.get(ctx.scope));
+  const scopeLabel = ctx.chatMode === "topic" ? `${ctx.scope}\uFF08\u8BDD\u9898\u72EC\u7ACB session\uFF09` : ctx.scope;
+  await reply(
+    ctx,
+    [
+      `\u{1F9ED} **scope**: \`${scopeLabel}\``,
+      `\u{1F4C1} **cwd**: \`${cwd}\``,
+      `\u{1F517} **session**: \`${session}\``,
+      `\u{1F3C3} **active run**: ${running ? "yes" : "no"}`
+    ].join("\n")
+  );
 }
-function summaryText(state) {
-  if (state.terminal === "interrupted") return "\u5DF2\u4E2D\u65AD";
-  if (state.terminal === "idle_timeout") return "\u5DF2\u8D85\u65F6";
-  if (state.terminal === "error") return "\u51FA\u9519";
-  if (state.terminal === "done") return "\u5DF2\u5B8C\u6210";
-  if (state.footer === "tool_running") return "\u6B63\u5728\u8C03\u7528\u5DE5\u5177";
-  if (state.footer === "streaming") return "\u6B63\u5728\u8F93\u51FA";
-  return "\u601D\u8003\u4E2D";
+async function handleResume(_args, ctx) {
+  const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
+  const history = ctx.sessions.historyFor(ctx.scope, cwd);
+  if (history.length === 0) {
+    await reply(ctx, "\u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u5386\u53F2\u4E0A\u4E0B\u6587\u3002");
+    return;
+  }
+  const recent = history.slice(-6).map((message) => {
+    const speaker = message.role === "user" ? "\u{1F464}" : "\u{1F916}";
+    return `${speaker} ${message.content.slice(0, 300)}`;
+  });
+  await reply(ctx, [`\u5F53\u524D scope\uFF1A\`${ctx.scope}\``, "", ...recent].join("\n"));
 }
-function stopButton() {
-  return {
-    tag: "button",
-    text: { tag: "plain_text", content: "\u23F9 \u7EC8\u6B62" },
-    type: "danger",
-    value: { cmd: "stop" }
-  };
+async function handleStop(_args, ctx) {
+  const stopped = await ctx.activeRuns.interrupt(ctx.scope);
+  await reply(ctx, stopped ? "\u5DF2\u8BF7\u6C42\u7EC8\u6B62\u5F53\u524D\u4EFB\u52A1\u3002" : "\u5F53\u524D\u6CA1\u6709\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\u3002");
 }
-function textBlock(block) {
-  return markdown(block.content);
+async function handleTimeout(args, ctx) {
+  const input = args.trim();
+  const effectiveMs = ctx.runPolicies.get(ctx.scope) ?? ctx.defaultRunTimeoutMs;
+  if (!input) {
+    const minutes2 = effectiveMs > 0 ? Math.round(effectiveMs / 6e4) : 0;
+    await reply(
+      ctx,
+      minutes2 > 0 ? `\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A${minutes2} \u5206\u949F\u3002\u53EF\u7528 \`/timeout <N|off|default>\` \u8C03\u6574\u3002` : "\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A\u5173\u95ED\u3002"
+    );
+    return;
+  }
+  if (input === "off") {
+    ctx.runPolicies.set(ctx.scope, 0);
+    await reply(ctx, "\u5DF2\u5173\u95ED\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\u3002");
+    return;
+  }
+  if (input === "default") {
+    ctx.runPolicies.clear(ctx.scope);
+    await reply(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u8FD0\u884C\u8D85\u65F6\u3002");
+    return;
+  }
+  const minutes = Number(input);
+  if (!Number.isInteger(minutes) || minutes <= 0) {
+    await reply(ctx, "\u7528\u6CD5\uFF1A`/timeout <N|off|default>`\uFF0CN \u4E3A\u5927\u4E8E 0 \u7684\u5206\u949F\u6570\u3002");
+    return;
+  }
+  ctx.runPolicies.set(ctx.scope, minutes * 6e4);
+  await reply(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A${minutes} \u5206\u949F\u3002`);
 }
-function toolBlock(tool) {
-  const icon = tool.status === "error" ? "\u26A0\uFE0F" : tool.status === "done" ? "\u2705" : "\u23F3";
-  return markdown(`${icon} **${tool.name}**`);
+async function handleDensity(args, ctx) {
+  const input = args.trim().toLowerCase();
+  if (!input) {
+    const current = ctx.densityStore?.get(ctx.scope) ?? "standard";
+    await reply(
+      ctx,
+      `\u5F53\u524D\u5361\u7247\u5BC6\u5EA6\uFF1A**${current}**\u3002\u53EF\u7528 \`/density compact|standard|detailed\` \u8C03\u6574\u3002`
+    );
+    return;
+  }
+  if (input === "default") {
+    ctx.densityStore?.clear(ctx.scope);
+    await reply(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u5361\u7247\u5BC6\u5EA6\u3002");
+    return;
+  }
+  const density = parseCardDensity(input);
+  if (!density) {
+    await reply(ctx, "\u7528\u6CD5\uFF1A`/density [compact|standard|detailed|default]`");
+    return;
+  }
+  ctx.densityStore?.set(ctx.scope, density);
+  await reply(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u5361\u7247\u5BC6\u5EA6\uFF1A**${density}**\u3002`);
 }
-function renderCard(state) {
-  const elements = [];
-  if (state.reasoning.content) {
-    elements.push(
-      noteMd(
-        state.reasoning.active ? "\u{1F9E0} \u6B63\u5728\u601D\u8003\u2026" : `\u{1F9E0} \u601D\u8003\u5B8C\u6210\uFF1A${state.reasoning.content.slice(0, 300)}`
-      )
+async function handleAsk(args, ctx) {
+  const question = args.trim();
+  if (!question) {
+    await reply(ctx, "\u7528\u6CD5\uFF1A`/ask <\u95EE\u9898>`");
+    return;
+  }
+  if (!ctx.questions) {
+    await reply(ctx, "\u95EE\u7B54\u5361\u672A\u542F\u7528\uFF08\u8BF7\u786E\u8BA4 questions \u5DF2\u63A5\u7EBF\uFF09\u3002");
+    return;
+  }
+  const answer = await questionHandlerFor({
+    questions: ctx.questions,
+    channel: ctx.channel,
+    chatId: ctx.chatId,
+    scope: ctx.scope
+  })({
+    kind: "text",
+    question,
+    id: ""
+  });
+  if (answer !== void 0) {
+    const text = Array.isArray(answer) ? answer.join("\u3001") : answer;
+    ctx.sessions.recordExchange(ctx.scope, ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace, [text], void 0);
+    await reply(ctx, `\u5DF2\u8BB0\u5F55\u4F60\u7684\u56DE\u7B54\uFF0C\u5E76\u5199\u5165\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u3002`);
+  } else {
+    await reply(ctx, "\u672A\u6536\u5230\u56DE\u7B54\uFF08\u5361\u7247\u53EF\u80FD\u5DF2\u8D85\u65F6\u6216\u88AB\u5FFD\u7565\uFF09\u3002");
+  }
+}
+async function handleInvite(args, ctx) {
+  const [kind, ...rest] = args.trim().split(/\s+/);
+  const id = rest.join(" ").trim();
+  if (kind === "list") {
+    const snapshot = ctx.accessManager.snapshot();
+    await reply(
+      ctx,
+      [
+        "**\u8BBF\u95EE\u767D\u540D\u5355**",
+        `users: ${snapshot.allowedUsers.join(", ") || "(\u7A7A)"}`,
+        `chats: ${snapshot.allowedChats.join(", ") || "(\u7A7A)"}`,
+        `admins: ${snapshot.admins.join(", ") || "(\u7A7A)"}`
+      ].join("\n")
     );
+    return;
   }
-  for (const block of state.blocks) {
-    elements.push(block.kind === "text" ? textBlock(block) : toolBlock(block.tool));
+  if (!kind || !id) {
+    await reply(
+      ctx,
+      "\u7528\u6CD5\uFF1A`/invite user|admin|group <id>`\u3001`/invite list`\u3001`/invite remove user|group <id>`"
+    );
+    return;
   }
-  if (state.terminal === "interrupted") {
-    elements.push(noteMd("_\u23F9 \u5DF2\u88AB\u4E2D\u65AD_"));
-  } else if (state.terminal === "idle_timeout") {
-    elements.push(noteMd(`_\u23F1 ${state.idleTimeoutMinutes ?? 0} \u5206\u949F\u65E0\u54CD\u5E94\uFF0C\u5DF2\u81EA\u52A8\u7EC8\u6B62_`));
-  } else if (state.terminal === "error" && state.errorMsg) {
-    elements.push(noteMd(`\u26A0\uFE0F agent \u5931\u8D25\uFF1A${state.errorMsg}`));
-  } else if (state.terminal === "done" && elements.length === 0) {
-    elements.push(noteMd("_\uFF08\u672A\u8FD4\u56DE\u5185\u5BB9\uFF09_"));
+  if (kind === "user") {
+    await ctx.accessManager.addUser(id);
+    await reply(ctx, `\u5DF2\u5141\u8BB8\u7528\u6237\uFF1A\`${id}\``);
+    return;
   }
-  if (state.terminal === "running") {
-    if (state.footer) elements.push(footerStatus(state.footer));
-    elements.push(stopButton());
+  if (kind === "admin") {
+    await ctx.accessManager.addAdmin(id);
+    await reply(ctx, `\u5DF2\u8BBE\u4E3A\u7BA1\u7406\u5458\uFF1A\`${id}\``);
+    return;
+  }
+  if (kind === "group") {
+    await ctx.accessManager.addChat(id);
+    await reply(ctx, `\u5DF2\u5141\u8BB8\u7FA4\u804A\uFF1A\`${id}\``);
+    return;
+  }
+  if (kind === "remove") {
+    const [sub, target] = rest;
+    if (sub === "user" && target) {
+      await ctx.accessManager.removeUser(target);
+      await reply(ctx, `\u5DF2\u79FB\u9664\u7528\u6237\uFF1A\`${target}\``);
+      return;
+    }
+    if (sub === "group" && target) {
+      await ctx.accessManager.removeChat(target);
+      await reply(ctx, `\u5DF2\u79FB\u9664\u7FA4\u804A\uFF1A\`${target}\``);
+      return;
+    }
+    await reply(ctx, "\u7528\u6CD5\uFF1A`/invite remove user <id>` \u6216 `/invite remove group <chatId>`");
+    return;
   }
+  await reply(ctx, "\u672A\u77E5 `/invite` \u7C7B\u578B\uFF0C\u8BF7\u4F7F\u7528 user / admin / group / list / remove\u3002");
+}
+async function handleHelp(_args, ctx) {
+  await reply(ctx, HELP);
+}
+var handlers = {
+  "/new": handleNew,
+  "/reset": handleNew,
+  "/cd": handleCd,
+  "/ws": handleWs,
+  "/status": handleStatus,
+  "/resume": handleResume,
+  "/stop": handleStop,
+  "/timeout": handleTimeout,
+  "/density": handleDensity,
+  "/ask": handleAsk,
+  "/invite": handleInvite,
+  "/help": handleHelp
+};
+async function tryHandleCommand(text, ctx) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/")) return false;
+  const [command, ...rest] = trimmed.split(/\s+/);
+  const handler = handlers[command ?? ""];
+  if (!handler) return false;
+  await handler(rest.join(" "), ctx);
+  return true;
+}
+
+// src/bridge/lark-channel.ts
+function adaptLarkChannel(channel) {
+  const base = {
+    async sendMarkdown(chatId, markdown2, options) {
+      const sendOptions = {};
+      if (options?.replyTo) sendOptions.replyTo = options.replyTo;
+      await channel.send(chatId, { markdown: markdown2 }, sendOptions);
+    }
+  };
   return {
-    schema: "2.0",
-    config: {
-      streaming_mode: state.terminal === "running",
-      summary: { content: summaryText(state) }
+    ...base,
+    async sendCard(chatId, card) {
+      await channel.send(chatId, { card }, {});
     },
-    body: { elements }
+    async streamCard(chatId, initial, producer, options) {
+      const sendOptions = {};
+      if (options?.replyTo) sendOptions.replyTo = options.replyTo;
+      await channel.stream(
+        chatId,
+        {
+          card: {
+            initial,
+            producer: async (controller) => {
+              await producer(controller);
+            }
+          }
+        },
+        sendOptions
+      );
+    }
   };
 }
 
-// src/bridge/run-flow.ts
-async function runAgentBatch(input) {
-  const replyOptions = input.replyTo ? { replyTo: input.replyTo } : {};
-  if (input.activeRuns.get(input.scope)) {
-    await input.channel.sendMarkdown(input.chatId, "\u5F53\u524D\u4F1A\u8BDD\u5DF2\u6709\u4EFB\u52A1\u6B63\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148 `/stop` \u6216\u7B49\u5F85\u5B8C\u6210\u3002", {
-      ...replyOptions
-    });
-    return;
-  }
-  const requestedCwd = input.workspaces.cwdFor(input.scope) ?? input.defaultWorkspace;
-  const workspace = input.workspaceManager ? await input.workspaceManager.ensure(input.scope, requestedCwd) : { cwd: requestedCwd };
-  const cwd = workspace.cwd;
-  const sessionId = input.sessions.resumeFor(input.scope, cwd);
-  const history = input.sessions.historyFor(input.scope, cwd);
-  const prompt = buildPrompt(history, input.messages);
-  const runId = randomUUID();
-  const run = input.adapter.run({
-    runId,
-    prompt,
-    cwd,
-    sessionId,
-    model: input.model,
-    images: input.images,
-    stopGraceMs: input.stopGraceMs
+// src/bridge/channel.ts
+async function startChannel(deps) {
+  const channel = (deps.createChannel ?? createLarkChannel)({
+    appId: deps.appId,
+    appSecret: deps.appSecret,
+    domain: deps.tenant === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn",
+    source: "dsh-lark-bot",
+    policy: {
+      dmMode: deps.allowedUsers?.length ? "allowlist" : deps.accessDefaultDeny === true ? "disabled" : "open",
+      requireMention: true,
+      respondToMentionAll: false,
+      ...deps.allowedUsers ? { dmAllowlist: deps.allowedUsers } : {},
+      ...deps.allowedChats ? { groupAllowlist: deps.allowedChats } : {}
+    },
+    safety: {
+      chatQueue: { enabled: false }
+    },
+    outbound: {
+      streamThrottleMs: 400
+    },
+    includeRawEvent: true,
+    resolveChatMode: true,
+    handshakeTimeoutMs: 8e3,
+    httpTimeoutMs: 3e4,
+    respectProxyEnv: true
   });
-  input.activeRuns.set(input.scope, { runId, stop: run.stop });
-  let state = initialState;
-  const stopRequested = { value: false };
-  const timeoutMs = input.runPolicies?.get(input.scope) ?? input.runTimeoutMs ?? 0;
-  let timedOut = false;
-  let assistantOutput = "";
-  try {
-    await input.channel.streamCard(
-      input.chatId,
-      renderCard(state),
-      async (controller) => {
-        const consume = async () => {
-          for await (const event of run.events) {
-            if (timedOut) return;
-            state = applyEvent(state, event, stopRequested);
-            if (event.type === "final_text") {
-              assistantOutput = event.content;
-            } else if (event.type === "text") {
-              assistantOutput += event.delta;
-            }
-            if (event.type === "system" && event.sessionId) {
-              input.sessions.set(input.scope, event.sessionId, event.cwd ?? cwd);
-            }
-            await controller.update(renderCard(state));
-          }
-        };
-        let timeoutTimer;
-        const timeoutPromise = timeoutMs > 0 ? new Promise((resolve4) => {
-          timeoutTimer = setTimeout(() => {
-            timedOut = true;
-            void run.stop();
-            resolve4();
-          }, timeoutMs);
-        }) : void 0;
-        try {
-          if (timeoutPromise) {
-            await Promise.race([consume(), timeoutPromise]);
-          } else {
-            await consume();
-          }
-          state = timedOut ? markIdleTimeout(state, timeoutMs / 6e4) : finalizeIfRunning(state);
-          await controller.update(renderCard(state));
-        } finally {
-          if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
-        }
-      },
-      replyOptions
-    );
-    input.sessions.recordExchange(input.scope, cwd, input.messages, assistantOutput);
-  } catch (error) {
-    log.fail("run-flow", error, { scope: input.scope, runId });
-    state = markInterrupted(state);
-    try {
-      await input.channel.sendMarkdown(input.chatId, `\u26A0\uFE0F agent \u8FD0\u884C\u5931\u8D25\uFF1A${errorMessage(error)}`, {
-        ...replyOptions
+  const streaming = adaptLarkChannel(channel);
+  const commandChannel = streaming;
+  channel.on({
+    message: async (msg) => {
+      const scope = scopeForMessage(msg);
+      if (deps.eventFreshnessMs !== void 0 && deps.eventFreshnessMs > 0 && !isEventFresh(msg.createTime, deps.eventFreshnessMs)) {
+        log.warn("channel", "stale-message-dropped", {
+          scope,
+          ageMs: Date.now() - msg.createTime
+        });
+        return;
+      }
+      const context = {
+        scope,
+        chatId: msg.chatId,
+        messageId: msg.messageId,
+        threadId: msg.threadId,
+        chatMode: msg.chatMode ?? msg.chatType,
+        sessions: deps.sessions,
+        workspaces: deps.workspaces,
+        activeRuns: deps.activeRuns,
+        runPolicies: deps.runPolicies,
+        defaultRunTimeoutMs: deps.defaultRunTimeoutMs,
+        accessManager: deps.accessManager,
+        approvals: deps.approvals,
+        questions: deps.questions,
+        densityStore: deps.densityStore,
+        channel: commandChannel,
+        defaultWorkspace: deps.defaultWorkspace
+      };
+      const handled = await tryHandleCommand(msg.content, context).catch((error) => {
+        log.fail("channel-command", error, { scope });
+        return false;
       });
-    } catch {
+      if (!handled) deps.pending.push(scope, msg);
+    },
+    cardAction: async (event) => {
+      const value = event.action.value && typeof event.action.value === "object" ? event.action.value : void 0;
+      const scope = event.raw ? await resolveCardScope(event.chatId, event.raw) : event.chatId;
+      if (value?.cmd === "stop") {
+        await deps.activeRuns.interrupt(scope);
+        return;
+      }
+      if (value?.cmd === "approve" && typeof value.id === "string" && deps.approvals) {
+        const outcome = value.outcome === "allow" ? "allowed-once" : "rejected";
+        deps.approvals.resolve(scope, value.id, outcome);
+        return;
+      }
+      if (value?.cmd === "question-submit" && typeof value.id === "string" && deps.questions) {
+        const question = deps.questions.get(scope, value.id);
+        const form = event.action.formValue;
+        if (question) {
+          const answer = extractQuestionAnswer(
+            question.kind,
+            form?.answer,
+            question.options
+          );
+          deps.questions.resolve(scope, value.id, answer);
+        }
+      }
+    },
+    reconnecting: () => {
+      log.warn("channel", "reconnecting", {});
+    },
+    reconnected: () => {
+      log.info("channel", "reconnected", {});
+    },
+    error: (error) => {
+      log.fail("channel", error);
     }
-  } finally {
-    input.activeRuns.delete(input.scope);
-  }
-}
-function buildPrompt(history, messages) {
-  if (history.length === 0) return messages.join("\n\n");
-  const transcript = history.map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.content}`).join("\n\n");
-  return [
-    "Continue the conversation using the history below.",
-    "",
-    transcript,
-    "",
-    `Current user message:
-${messages.join("\n\n")}`
-  ].join("\n");
+  });
+  await channel.connect();
+  return {
+    channel,
+    disconnect: () => channel.disconnect()
+  };
 }
-function applyEvent(state, event, stopRequested) {
-  if (event.type === "done" && event.terminationReason === "interrupted") {
-    stopRequested.value = true;
-    return markInterrupted(state);
-  }
-  if (event.type === "error" && event.terminationReason === "timeout") {
-    return markIdleTimeout(state, 0);
-  }
-  return reduce(state, event);
+function scopeForMessage(msg) {
+  if (msg.chatMode === "topic" && msg.threadId) return `${msg.chatId}:${msg.threadId}`;
+  return msg.chatId;
 }
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+async function resolveCardScope(chatId, raw) {
+  return raw.message?.thread_id ? `${chatId}:${raw.message.thread_id}` : chatId;
 }
 
 // src/config/access-manager.ts
@@ -1587,15 +3176,21 @@ async function onboardPersonalAgent(deps = {}) {
 }
 
 // src/media/attachments.ts
-import { mkdir as mkdir3, readFile as readFile2, stat as stat2 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir5, readFile as readFile2, stat as stat2 } from "fs/promises";
+import { join as join7 } from "path";
 var MAX_TEXT_FILE_BYTES = 256e3;
+function assertSafeMediaName(mediaDir, destination) {
+  if (!isPathWithin(mediaDir, destination)) {
+    throw new Error(`unsafe attachment destination rejected: ${destination}`);
+  }
+}
 async function prepareAttachments(channel, message, mediaDir) {
-  await mkdir3(mediaDir, { recursive: true });
+  await mkdir5(mediaDir, { recursive: true });
   const result = { imagePaths: [], textFileNotes: [] };
   for (const resource of message.resources) {
     if (!channel || resource.type !== "image" && resource.type !== "file") continue;
-    const destination = join5(mediaDir, `${message.messageId}-${resource.fileKey}`);
+    const destination = join7(mediaDir, `${message.messageId}-${resource.fileKey}`);
+    assertSafeMediaName(mediaDir, destination);
     await channel.downloadResourceToFile(
       message.messageId,
       resource.fileKey,
@@ -1612,9 +3207,10 @@ async function prepareAttachments(channel, message, mediaDir) {
       continue;
     }
     const content = await readFile2(destination, "utf8");
+    const safeContent = truncateUtf8Safe(content, MAX_TEXT_FILE_BYTES);
     result.textFileNotes.push(
       `[attachment: ${resource.fileName ?? resource.fileKey}]
-${content}`
+${safeContent}`
     );
   }
   return result;
@@ -1735,8 +3331,8 @@ var SessionStore = class {
 // src/workspace/git-worktree.ts
 import { execFile } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
-import { access, copyFile, mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname3, join as join6 } from "path";
+import { access, copyFile, mkdir as mkdir6 } from "fs/promises";
+import { dirname as dirname3, join as join8 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 async function defaultRunGit(args, cwd) {
@@ -1755,11 +3351,11 @@ async function exists(path) {
   }
 }
 async function defaultCopyRulesFile(source, target) {
-  await mkdir4(dirname3(target), { recursive: true });
+  await mkdir6(dirname3(target), { recursive: true });
   await copyFile(source, target);
 }
 function slugify(scope) {
-  const slug = scope.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  const slug = scope.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^[.]+/, "").replace(/^-+|-+$/g, "").slice(0, 64);
   return slug || "session";
 }
 var GitWorktreeManager = class {
@@ -1775,13 +3371,16 @@ var GitWorktreeManager = class {
     const isGit = await this.isGitRepository(base);
     if (!isGit) return { cwd: base, created: false };
     const slug = slugify(scope);
-    const target = join6(this.options.worktreesRoot, slug);
+    const target = join8(this.options.worktreesRoot, slug);
+    if (!isPathWithin(this.options.worktreesRoot, target)) {
+      throw new Error(`unsafe worktree target rejected: ${target}`);
+    }
     if (await exists(target)) {
       await this.ensureProjectRules(base, target);
       return { cwd: target, created: false };
     }
     const branch = `dsh-lark/${slug}-${Date.now().toString(36)}-${randomBytes2(3).toString("hex")}`;
-    await mkdir4(this.options.worktreesRoot, { recursive: true });
+    await mkdir6(this.options.worktreesRoot, { recursive: true });
     await this.runGit(["worktree", "add", "-b", branch, target, "HEAD"], base);
     await this.ensureProjectRules(base, target);
     return { cwd: target, created: true, branch };
@@ -1795,9 +3394,9 @@ var GitWorktreeManager = class {
     }
   }
   async ensureProjectRules(base, target) {
-    const destination = join6(target, "AGENTS.md");
+    const destination = join8(target, "AGENTS.md");
     if (await exists(destination)) return;
-    const sourceCandidates = [join6(base, ".dsh-lark", "AGENTS.md"), join6(base, "AGENTS.md")];
+    const sourceCandidates = [join8(base, ".dsh-lark", "AGENTS.md"), join8(base, "AGENTS.md")];
     for (const source of sourceCandidates) {
       if (await exists(source)) {
         await this.copyRulesFile(source, destination);
@@ -1947,24 +3546,31 @@ async function runStart(options) {
     return;
   }
   const defaultWorkspace = options.workspace ?? activeProfile.workspaces.default ?? env.workspace ?? paths.profilePath(profileName, "workspace");
-  await mkdir5(defaultWorkspace, { recursive: true });
+  await mkdir7(defaultWorkspace, { recursive: true });
   const sessions = new SessionStore(paths.sessionsFile(profileName));
   const workspaces = new WorkspaceStore(paths.workspacesFile(profileName));
   const worktreeManager = new GitWorktreeManager({
     worktreesRoot: paths.profilePath(profileName, "worktrees")
   });
   await Promise.all([sessions.load(), workspaces.load()]);
-  const adapterOptions = {
-    command: env.dshCommand,
-    args: env.dshArgs,
-    stopGraceMs: env.stopGraceMs
-  };
-  if (activeProfile.preferences.stopGraceMs !== void 0) {
-    Object.assign(adapterOptions, { stopGraceMs: activeProfile.preferences.stopGraceMs });
+  let adapter;
+  try {
+    adapter = await buildAgentAdapter(env, {
+      stopGraceMs: activeProfile.preferences.stopGraceMs ?? env.stopGraceMs,
+      model: activeProfile.preferences.model
+    });
+  } catch (error) {
+    log.fail("adapter", error);
+    process.stderr.write(`agent adapter \u521D\u59CB\u5316\u5931\u8D25\uFF1A${errorMessage2(error)}
+`);
+    process.exitCode = 1;
+    return;
   }
-  const adapter = new DshAdapter(adapterOptions);
   const activeRuns = new ActiveRuns();
   const runPolicies = new RunPolicyStore();
+  const approvals = new ApprovalRegistry();
+  const questions = new QuestionRegistry();
+  const densityStore = new DensityStore();
   let streaming;
   let larkChannel;
   const pending = new PendingQueue(DEBOUNCE_MS, async (scope, batch) => {
@@ -1992,6 +3598,9 @@ async function runStart(options) {
         workspaceManager: worktreeManager,
         activeRuns,
         runPolicies,
+        approvals,
+        questions,
+        densityStore,
         channel: streaming,
         defaultWorkspace,
         replyTo: first.messageId,
@@ -2016,10 +3625,15 @@ async function runStart(options) {
     workspaces,
     activeRuns,
     runPolicies,
+    approvals,
+    questions,
+    densityStore,
     defaultRunTimeoutMs: activeProfile.preferences.runTimeoutMs ?? env.runTimeoutMs,
     accessManager,
     pending,
     defaultWorkspace,
+    accessDefaultDeny: env.accessDefaultDeny,
+    eventFreshnessMs: env.eventFreshnessMs,
     allowedUsers: activeProfile.access.allowedUsers,
     allowedChats: activeProfile.access.allowedChats
   };
@@ -2040,14 +3654,18 @@ async function runStart(options) {
 `);
   await waitForShutdown();
   await bridge.disconnect();
+  await adapter.dispose?.();
   await Promise.all([sessions.flush(), workspaces.flush()]);
 }
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 function waitForShutdown() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const shutdown = () => {
       process.off("SIGINT", shutdown);
       process.off("SIGTERM", shutdown);
-      resolve4();
+      resolve5();
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);