dsh-lark-bot 0.17.0 → 0.17.2

package/README.md

@@ -165,7 +165,7 @@ transcript 卡并持久绑定。私聊允许已授权用户；member scope 仅
 
 **`/newg <群名>`**：自动新建私密群、拉发送者入群并回复群链接——新群即新 scope / 新会话，当前会话不受影响。需应用具备 `im:chat` 与 `im:chat.members:write_only` 权限。
 
-同一 scope（私聊 / 群聊 / 话题）默认 **2 个任务并行**（`DSH_LARK_SCOPE_CONCURRENCY` 或 `/concurrency` 调整）：多条消息以独立 run 并行推进，每个 run 使用独立 dsh session 与 runId；`/status` 查看当前 workspace 的 run，`/new` 只停止当前 workspace，`/stop` 一次性终止 scope 内全部运行。
+同一 scope（私聊 / 群聊 / 话题）默认 **2 个任务并行**（`DSH_LARK_SCOPE_CONCURRENCY` 或 `/concurrency` 调整）：多条消息以独立 run 并行推进，每个 run 使用独立 dsh session 与 runId；SDK runtime 以 `scope + workspace` 为取消域，同一 scope 的并发 session 也会切到独立 runtime，因此卡片停止只影响该 run，`/stop` 只终止当前 scope 的全部运行，不会误停其他群。`/status` 查看当前 workspace 的 run，`/new` 只停止当前 workspace。
 
 **会话状态卡**：`/status` 展示工作区、有效模型、session、显式投影绑定/cursor、active runs、版本、上下文占用、
 累计 input / output / cache token，以及待审批 / 待提问 / 待批准计划；点击“刷新”会原位更新同一张卡。
@@ -395,7 +395,7 @@ dsh plugin --profile dsh-lark remove dsh-lark-bot
 
 ## 兼容性
 
-- **DeepSeek Harness（`dsh`）**：已验证 **dsh 0.1.0-rc.8**（最后验证 2026-08-20：临时安装 + SDK JSON-RPC / ACP runtime initialize、工具/审批、live session 续接与 restart collision 探针），通过官方 `@deepseek-ai/dsh-sdk-client` / `@deepseek-ai/dsh-acp` 接入；
+- **DeepSeek Harness（`dsh`）**：已验证 **dsh 0.1.0-rc.8**（最后验证 2026-08-22：临时安装 + SDK JSON-RPC / ACP runtime initialize、工具/审批、live session 续接与 restart collision 探针），通过官方 `@deepseek-ai/dsh-sdk-client` / `@deepseek-ai/dsh-acp` 接入；
   具体锁定版本、升级政策与自动化探测见 [`docs/COMPATIBILITY.md`](docs/COMPATIBILITY.md)，
   adapter 接入细节见 [`docs/adapter-notes.md`](docs/adapter-notes.md)，rc.8 差异、已知风险和
   自动/人工验证边界见 [`docs/DSH_RC8_AUDIT.md`](docs/DSH_RC8_AUDIT.md)。
@@ -409,10 +409,12 @@ dsh plugin --profile dsh-lark remove dsh-lark-bot
 
 ## 已知限制
 
-- ACP 模式会话每次全新（上游限制，无续跑）；SDK 协议暂无 mid-turn cancel，`/stop` 会关闭
-  对应 runtime 并自动重建。
+- ACP 模式会话每次全新（上游限制，无续跑）；SDK 协议暂无 mid-turn cancel，停止操作会关闭
+  该 run 所属的隔离 runtime 并自动重建，不会关闭其他 scope 或并发 run 的 runtime。SDK 只在当前
+  bridge 进程仍持有同一个 live runtime 时原生续接 session；进程重启、停止或模型切换后会主动
+  新建 session 并回放 bridge transcript，避免把旧 ID 交给 rc.8 新 runtime 触发 `id collision`。
 - 桥接引擎作为 dsh 插件在 dsh 进程内运行，agent 执行使用官方 dsh SDK runtime 子进程
-  （嵌套 runtime 是有意取舍，用于按工作区隔离的 runtime 池与 scope 内并行 run）。
+  （嵌套 runtime 是有意取舍，用于按 scope + workspace 隔离取消域与并行 run）。
   唯一的进程级例外是默认安装的「安全网守护」——它独立于 dsh / Cordis 常驻，仅在 dsh
   下线后接管飞书通道，正常运行时保持静默。
 - 飞书文档评论、富文本回复为规划中能力，尚未实现。

package/README_EN.md

@@ -165,7 +165,7 @@ message mappings, plus only the unfinished card body needed to resume that card
 
 **`/newg <group name>`**: auto-creates a private group, invites the sender and replies with a group link — chatting in the new group starts a fresh scope/session while the current session is untouched. Requires the `im:chat` and `im:chat.members:write_only` scopes.
 
-Each scope (DM / group / topic) runs up to **2 tasks in parallel** by default (adjust with `DSH_LARK_SCOPE_CONCURRENCY` or `/concurrency`): successive messages become independent runs, each with its own dsh session and run id. `/status` lists runs for the current workspace; `/new` stops only that workspace, while `/stop` interrupts all runs in the scope.
+Each scope (DM / group / topic) runs up to **2 tasks in parallel** by default (adjust with `DSH_LARK_SCOPE_CONCURRENCY` or `/concurrency`): successive messages become independent runs, each with its own dsh session and run id. SDK runtimes use `scope + workspace` as their cancellation domain, and concurrent sessions in one scope are split into separate runtimes, so a card stop affects only that run and `/stop` affects only the current scope—never another group. `/status` lists runs for the current workspace; `/new` stops only that workspace.
 
 **Session status card**: `/status` shows the workspace, effective model, session, explicit projection binding/cursor, active runs, version,
 context occupancy, cumulative input/output/cache tokens, and pending approvals/questions/plans. **Refresh**
@@ -391,15 +391,15 @@ See [`docs/QUICK_START.md`](docs/QUICK_START.md) for installation details, state
 
 ## Compatibility
 
-- **DeepSeek Harness (`dsh`)**: verified against **dsh 0.1.0-rc.8** (last verified 2026-08-20: clean temporary install, SDK JSON-RPC / ACP initialize, tool/approval, live-session resume, and restart-collision probes), connected through the official `@deepseek-ai/dsh-sdk-client` / `@deepseek-ai/dsh-acp`; see [`docs/COMPATIBILITY.md`](docs/COMPATIBILITY.md) for exact pins and probing, [`docs/adapter-notes.md`](docs/adapter-notes.md) for adapter details, and [`docs/DSH_RC8_AUDIT.md`](docs/DSH_RC8_AUDIT.md) for rc.8 risks and verification boundaries.
+- **DeepSeek Harness (`dsh`)**: verified against **dsh 0.1.0-rc.8** (last verified 2026-08-22: clean temporary install, SDK JSON-RPC / ACP initialize, tool/approval, live-session resume, and restart-collision probes), connected through the official `@deepseek-ai/dsh-sdk-client` / `@deepseek-ai/dsh-acp`; see [`docs/COMPATIBILITY.md`](docs/COMPATIBILITY.md) for exact pins and probing, [`docs/adapter-notes.md`](docs/adapter-notes.md) for adapter details, and [`docs/DSH_RC8_AUDIT.md`](docs/DSH_RC8_AUDIT.md) for rc.8 risks and verification boundaries.
 - **Runtime**: Node.js ≥ 22.19 (see `engines` in `package.json`).
 - **Platform**: Linux / macOS / Windows (Feishu outbound WebSocket long connection; no public server, domain or tunneling required).
 - The default adapter is the official **`@deepseek-ai/dsh-sdk-client`** (SDK JSON-RPC runtime with native continuation, streaming events, and the rc.8 approval answerer); `DSH_LARK_ADAPTER=acp` switches to the official **ACP server** with protocol-native approval; `headless` keeps the legacy subprocess fallback; `DSH_LARK_ADAPTER=web` drives the **local dsh web agent** (`session.prompt` + `/api/events.mux` — the web agent becomes the single writer, eliminating multi-writer session-log corruption at the root). On first start the bot creates the runtime profile at `~/.dsh/profiles/dsh-lark-sdk` (or `dsh-lark-acp`).
 
 ## Known limitations
 
-- ACP sessions are always fresh (an upstream limit); the SDK protocol has no mid-turn cancel, so `/stop` closes and recreates the runtime.
-- The engine runs in-process as a dsh plugin; agent execution uses the official dsh SDK runtime subprocess — a deliberate nested-runtime design for per-workspace runtime pools and parallel runs. The one process-level exception is the safety-net guardian installed by default — a minimal resident process independent of dsh / Cordis that only takes over the Feishu channel after dsh goes down and stays silent otherwise.
+- ACP sessions are always fresh (an upstream limit); the SDK protocol has no mid-turn cancel, so stopping a run closes and recreates only that run's isolated runtime. Other scopes and concurrent runs keep their own runtimes. Native SDK continuation is used only while this bridge process still owns the same live runtime; after restart, stop, or model switch the bridge creates a fresh session and replays its transcript instead of handing rc.8 a stale ID that would trigger `id collision`.
+- The engine runs in-process as a dsh plugin; agent execution uses the official dsh SDK runtime subprocess — a deliberate nested-runtime design for scope/workspace cancellation domains and parallel runs. The one process-level exception is the safety-net guardian installed by default — a minimal resident process independent of dsh / Cordis that only takes over the Feishu channel after dsh goes down and stays silent otherwise.
 - Feishu doc comments and rich-text replies are planned, not yet implemented.
 - pnpm ≥ 10 build policy is handled by `setup`; when installing manually and `ERR_PNPM_IGNORED_BUILDS` appears, add `allowBuilds: { protobufjs: true }` to the profile's `pnpm-workspace.yaml` and retry.
 

package/dist/cli.js

@@ -64,7 +64,7 @@ var init_dsh_compat = __esm({
       sdkServer: "0.1.0-rc.8",
       acp: "0.1.0-rc.8",
       node: ">=22.19.0",
-      verifiedAt: "2026-08-20"
+      verifiedAt: "2026-08-22"
     };
   }
 });
@@ -1498,12 +1498,17 @@ var SdkDshAdapter = class {
   }
   run(options) {
     const cwd = options.cwd ?? process.cwd();
+    const runtimeKey = options.runtimeKey ?? cwd;
     const route = {
       provider: options.provider ?? this.provider,
       model: options.model ?? this.model
     };
-    const entry = this.runtimeFor(cwd, route);
-    const sessionId = options.sessionId ?? `session-${randomUUID().replaceAll("-", "")}`;
+    let sessionId = options.sessionId ?? `session-${randomUUID().replaceAll("-", "")}`;
+    const current = this.runtimes.get(runtimeKey);
+    if (current?.active) {
+      sessionId = `session-${randomUUID().replaceAll("-", "")}`;
+    }
+    const entry = this.runtimeFor(runtimeKey, cwd, route, sessionId);
     const stopRequested = { value: false };
     entry.active += 1;
     const handle = createSdkRun(entry.harness, options.prompt, {
@@ -1519,11 +1524,17 @@ var SdkDshAdapter = class {
       events: handle.events,
       stop: async () => {
         stopRequested.value = true;
-        await this.closeRuntime(cwd);
+        await this.closeEntry(entry);
       },
       waitForExit: (timeoutMs) => waitWithTimeout(handle.settled, timeoutMs)
     };
   }
+  canResume(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const runtimeKey = options.runtimeKey ?? cwd;
+    const entry = this.runtimes.get(runtimeKey);
+    return entry !== void 0 && entry.cwd === cwd && entry.sessionId === options.sessionId && entry.provider === (options.provider ?? this.provider) && entry.model === (options.model ?? this.model) && entry.active === 0 && !entry.retired;
+  }
   /** Close every runtime subprocess (used on bridge shutdown). */
   async dispose() {
     this.disposed = true;
@@ -1532,7 +1543,7 @@ var SdkDshAdapter = class {
     const draining = [...this.draining];
     this.draining.clear();
     await Promise.allSettled(
-      [...entries, ...draining].map((entry) => entry.harness.close())
+      [...entries, ...draining].map((entry) => this.closeHarness(entry))
     );
   }
   createHarness(cwd, route) {
@@ -1549,57 +1560,59 @@ var SdkDshAdapter = class {
     });
   }
   /**
-   * Return the runtime entry for a cwd + model route, rebinding when the
-   * requested route differs from the harness's fixed route. The dsh SDK
-   * JSON-RPC protocol binds provider/model at session creation (initialize
-   * handshake), so a hot model/provider switch requires re-spawning that
-   * runtime. An in-use harness is NOT killed: it is retired and closed once
-   * its last in-flight run settles, so parallel tasks are never interrupted
-   * by a model switch.
+   * Return the runtime for one scope/workspace + native-session identity.
+   * A concurrent fresh session or route change retires the previous entry,
+   * which drains without being killed. This is required because rc.8 has no
+   * per-session cancel: each stop handle must own the process it closes.
    */
-  runtimeFor(cwd, route) {
+  runtimeFor(runtimeKey, cwd, route, sessionId) {
     if (this.disposed) {
       throw new Error("SdkDshAdapter is disposed");
     }
-    const existing = this.runtimes.get(cwd);
-    if (existing && existing.provider === route.provider && existing.model === route.model) {
+    const existing = this.runtimes.get(runtimeKey);
+    if (existing && existing.active === 0 && existing.cwd === cwd && existing.sessionId === sessionId && existing.provider === route.provider && existing.model === route.model) {
       return existing;
     }
     if (existing) {
-      this.runtimes.delete(cwd);
+      this.runtimes.delete(runtimeKey);
       if (existing.active > 0) {
         existing.retired = true;
         this.draining.add(existing);
       } else {
-        void existing.harness.close().catch(() => void 0);
+        void this.closeHarness(existing);
       }
     }
     const entry = {
       harness: withRetryableStart(this.harnessFactory(cwd, route)),
+      runtimeKey,
+      cwd,
+      sessionId,
       provider: route.provider,
       model: route.model,
       active: 0,
       retired: false
     };
-    this.runtimes.set(cwd, entry);
+    this.runtimes.set(runtimeKey, entry);
     return entry;
   }
   releaseEntry(entry) {
     entry.active = Math.max(0, entry.active - 1);
     if (entry.retired && entry.active === 0) {
       this.draining.delete(entry);
-      void entry.harness.close().catch(() => void 0);
+      void this.closeHarness(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;
+  async closeEntry(entry) {
+    if (this.runtimes.get(entry.runtimeKey) === entry) {
+      this.runtimes.delete(entry.runtimeKey);
     }
+    entry.retired = true;
+    this.draining.delete(entry);
+    await this.closeHarness(entry);
+  }
+  closeHarness(entry) {
+    entry.closing ??= entry.harness.close().catch(() => void 0);
+    return entry.closing;
   }
 };
 
@@ -6522,6 +6535,7 @@ var initialState = {
   idleTimeoutMinutes: void 0,
   scopeOwner: void 0,
   actionScope: void 0,
+  actionRunId: void 0,
   startedAtMs: void 0,
   lastActivityMs: void 0
 };
@@ -6688,6 +6702,7 @@ var MAX_VISIBLE_TOOL_CALLS = 40;
 var MAX_TOOL_NAME_LENGTH = 160;
 var MAX_OWNER_LENGTH = 160;
 var MAX_ACTION_SCOPE_LENGTH = 512;
+var MAX_ACTION_RUN_ID_LENGTH = 160;
 var MAX_FINAL_FALLBACK_LENGTH = 8e3;
 function boundedText(value, limit) {
   return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 1))}\u2026`;
@@ -6734,12 +6749,16 @@ function fallbackSummaryText(state, locale, maxTools) {
   if (state.finalDeliveryError) parts.push(zh ? "\u6700\u7EC8\u56DE\u7B54\u53D1\u9001\u5931\u8D25" : "Final answer delivery failed");
   return parts.join(" \xB7 ").slice(0, 500);
 }
-function stopButton(scope, locale) {
+function stopButton(scope, runId, locale) {
   return {
     tag: "button",
     text: { tag: "plain_text", content: locale === "zh_cn" ? "\u23F9 \u7EC8\u6B62" : "\u23F9 Stop" },
     type: "danger",
-    value: { cmd: "stop", ...scope ? { scope: boundedText(scope, MAX_ACTION_SCOPE_LENGTH) } : {} }
+    value: {
+      cmd: "stop",
+      ...scope ? { scope: boundedText(scope, MAX_ACTION_SCOPE_LENGTH) } : {},
+      ...runId ? { runId: boundedText(runId, MAX_ACTION_RUN_ID_LENGTH) } : {}
+    }
   };
 }
 function toolBlock(tool) {
@@ -6851,7 +6870,7 @@ function renderStandard(state, now, locale, maxTools) {
   if (fallback) elements.push(fallback);
   if (state.terminal === "running") {
     if (state.footer) elements.push(footerStatus(state.footer, state, now, locale));
-    elements.push(stopButton(state.actionScope, locale));
+    elements.push(stopButton(state.actionScope, state.actionRunId, locale));
   }
   return {
     schema: "2.0",
@@ -6883,7 +6902,7 @@ function renderCompact(state, now, locale, maxTools) {
     elements.push(footerStatus(state.footer, state, now, locale));
   }
   if (state.terminal === "running") {
-    elements.push(stopButton(state.actionScope, locale));
+    elements.push(stopButton(state.actionScope, state.actionRunId, locale));
   }
   return {
     schema: "2.0",
@@ -6919,7 +6938,7 @@ function renderDetailed(state, now, locale, maxTools) {
   if (fallback) elements.push(fallback);
   if (state.terminal === "running") {
     if (state.footer) elements.push(footerStatus(state.footer, state, now, locale));
-    elements.push(stopButton(state.actionScope, locale));
+    elements.push(stopButton(state.actionScope, state.actionRunId, locale));
   }
   return {
     schema: "2.0",
@@ -6957,7 +6976,7 @@ function renderLegacyVariant(state, now, locale, maxTools) {
   elements.push(compatibilityProcessSnapshot(state, locale, maxTools));
   if (state.terminal === "running") {
     if (state.footer) elements.push(footerStatus(state.footer, state, now, locale));
-    elements.push(stopButton(state.actionScope, locale));
+    elements.push(stopButton(state.actionScope, state.actionRunId, locale));
   } else if (state.terminal === "interrupted") {
     elements.push(noteMd(zh ? "_\u23F9 \u5DF2\u88AB\u4E2D\u65AD_" : "_\u23F9 Interrupted_"));
   } else if (state.terminal === "idle_timeout") {
@@ -7008,7 +7027,7 @@ function minimalRunCard(state, bilingualFallback) {
     body: {
       elements: [
         noteMd(locale === "zh_cn" ? "\u6267\u884C\u8BB0\u5F55\u8FC7\u957F\uFF0C\u8F83\u65E9\u7684\u8BE6\u60C5\u5DF2\u9690\u85CF\u3002" : "The execution history is too long; older details are hidden."),
-        ...state.terminal === "running" ? [stopButton(void 0, locale)] : []
+        ...state.terminal === "running" ? [stopButton(state.actionScope, state.actionRunId, locale)] : []
       ]
     }
   });
@@ -7283,8 +7302,16 @@ async function runAgentBatch(input) {
   const activeInWorkspace = input.activeRuns.countWorkspace(input.scope, requestedCwd);
   const workspace = input.workspaceManager ? await input.workspaceManager.ensure(input.scope, requestedCwd) : { cwd: requestedCwd };
   const cwd = workspace.cwd;
-  const sessionId = activeInWorkspace === 0 ? input.sessions.resumeFor(input.scope, requestedCwd) : void 0;
-  const resuming = sessionId !== void 0 && input.adapter.resumeCapable === true;
+  const runtimeKey = `${input.scope}\0${requestedCwd ?? ""}`;
+  const storedSessionId = activeInWorkspace === 0 ? input.sessions.resumeFor(input.scope, requestedCwd) : void 0;
+  const resuming = storedSessionId !== void 0 && input.adapter.resumeCapable === true && (input.adapter.canResume?.({
+    runtimeKey,
+    cwd,
+    sessionId: storedSessionId,
+    ...input.provider === void 0 ? {} : { provider: input.provider },
+    model: input.model
+  }) ?? true);
+  const sessionId = resuming ? storedSessionId : void 0;
   try {
     return terminalOutcome(await runAttempt(input, cwd, requestedCwd, sessionId, resuming, replyOptions));
   } catch (error) {
@@ -7341,6 +7368,7 @@ async function runAttempt(input, cwd, workspaceCwd, sessionId, resuming, replyOp
   const runId = randomUUID7();
   const run = input.adapter.run({
     runId,
+    runtimeKey: `${input.scope}\0${workspaceCwd ?? ""}`,
     prompt,
     cwd,
     sessionId,
@@ -7376,7 +7404,8 @@ async function runAttempt(input, cwd, workspaceCwd, sessionId, resuming, replyOp
     startedAtMs: now,
     lastActivityMs: now,
     scopeOwner: input.scopeOwner,
-    actionScope: input.scope
+    actionScope: input.scope,
+    actionRunId: runId
   };
   const stopRequested = { value: false };
   const timeoutMs = input.runPolicies?.get(input.scope) ?? input.runTimeoutMs ?? 0;
@@ -12835,7 +12864,12 @@ ${msg.content}`,
         }
       }
       if (value?.cmd === "stop") {
-        await deps.activeRuns.interrupt(scope);
+        const runId = typeof value.runId === "string" ? value.runId : void 0;
+        if (runId) {
+          await deps.activeRuns.interruptRun(scope, runId);
+        } else {
+          await deps.activeRuns.interrupt(scope);
+        }
         return;
       }
       if (value?.cmd === "execution-mode" && deps.executionModes) {