larkway 0.3.42 → 0.3.44

package/README.md

@@ -8,7 +8,7 @@
 
 You @ the bot in a Feishu thread. It runs on your machine — reading your real codebase, executing commands, opening MRs — and posts the result back. You define what the agent knows and what it can do. Larkway just carries the messages.
 
-**Current release: v0.3.42**
+**Current release: v0.3.44**
 
 ---
 

package/README.zh.md

@@ -8,7 +8,7 @@
 
 你在飞书话题里 @ bot，它在你的机器上运行——读真实代码库、执行命令、开 MR——把结果贴回飞书。你定义 agent 知道什么、能做什么。Larkway 只负责传递消息。
 
-**当前版本：v0.3.42**
+**当前版本：v0.3.44**
 
 ---
 

package/dist/cli/index.js

@@ -112530,6 +112530,11 @@ var init_messageLookupClient = __esm({
           const cached = this.#cache.get(messageId);
           if (cached) return cached;
         }
+        const first = await this.#getOnce(messageId);
+        if (first) return first;
+        return this.#getOnce(messageId);
+      }
+      async #getOnce(messageId) {
         try {
           const channel = this.#resolveChannel();
           if (!channel) return void 0;
@@ -126104,24 +126109,37 @@ var BotConfigSchema = external_exports.object({
    */
   effort: external_exports.string().min(1).optional(),
   /**
-   * docs/larkway-perf-plan.md §4 — opt into a persistent warm process
-   * instead of the default one-shot cold-start-per-turn behavior. Takes
-   * effect for `backend: "codex"` (a single bot-level `codex app-server`
-   * process — src/codex/pool.ts CodexProcessPool) and `backend: "claude"`
-   * (one warm process per active thread — src/claude/pool.ts
-   * ClaudeProcessPool). Any other backend value is a no-op (main.ts only
-   * constructs a pool for these two; botLoader's advisory warn below flags
-   * the mismatch upfront). Byte-identical behavior when unset, matching
-   * every other perf-plan flag in this schema. `.optional()` (not
-   * `.default(false)`, deliberately — B1 fix): a `.default()` would make
-   * every future `larkway bot` yaml write-out include `warmProcess: false`
-   * even when nobody asked for it, and — because this schema is `.strict()`
-   * — would break loading that yaml back with an OLDER larkway build that
-   * predates this field. `undefined` and `false` are treated identically at
-   * both read sites (main.ts's `bot.warmProcess && …` and the advisory warn
-   * below).
+   * docs/larkway-perf-plan.md §4 — persistent warm process instead of a
+   * one-shot cold start per turn. Takes effect for `backend: "codex"` (a
+   * single bot-level `codex app-server` process — src/codex/pool.ts
+   * CodexProcessPool) and `backend: "claude"` (one warm process per active
+   * thread — src/claude/pool.ts ClaudeProcessPool). Any other backend value
+   * is a no-op (main.ts only constructs a pool for these two; botLoader's
+   * advisory warn below flags the mismatch upfront).
+   *
+   * 批D (warm-by-default):
+   * DEFAULT IS NOW ON for the two supported backends — `undefined` means
+   * `true` when backend is codex/claude (see {@link effectiveWarmProcess},
+   * the single source of that rule). Set `warmProcess: false` explicitly to
+   * opt a bot back out. `.optional()` (not `.default(true)`) is still
+   * deliberate: a `.default()` would make every future `larkway bot` yaml
+   * write-out bake the value in, and — because this schema is `.strict()` —
+   * would break loading that yaml back with an OLDER larkway build that
+   * predates this field.
    */
   warmProcess: external_exports.boolean().optional(),
+  /**
+   * 批D: pre-warm a BLANK agent process at bridge boot (and keep one on
+   * standby thereafter), so even the FIRST message of a NEW thread skips the
+   * cold start. Only meaningful when the warm pool is on (see
+   * `warmProcess`); default true. backend=claude: ClaudeProcessPool keeps
+   * one blank (no --resume) child matching the bot's static spawn signature,
+   * adopted by the first new-session turn and replenished after adoption.
+   * backend=codex: CodexProcessPool spawns its app-server eagerly at boot
+   * instead of on the first turn. Set false to keep warm pooling but skip
+   * the always-resident standby (saves ~300MB RSS per bot at idle).
+   */
+  prewarmProcess: external_exports.boolean().optional(),
   /**
    * Idle threshold (ms) before a warm process (see `warmProcess` above) with
    * no in-flight turn gets SIGTERM'd. Only meaningful when `warmProcess` is

package/dist/main.js

@@ -116684,6 +116684,11 @@ var ChannelMessageLookupClient = class {
       const cached = this.#cache.get(messageId);
       if (cached) return cached;
     }
+    const first = await this.#getOnce(messageId);
+    if (first) return first;
+    return this.#getOnce(messageId);
+  }
+  async #getOnce(messageId) {
     try {
       const channel = this.#resolveChannel();
       if (!channel) return void 0;
@@ -119225,12 +119230,18 @@ function renderTaskRootBlock(taskRoot) {
     `task_root_claimed: ${taskRoot.claimed ? "yes" : "no"}`
   ];
   if (taskRoot.claimed) {
-    lines.push(
-      "\u672C\u8BDD\u9898\u5DF2\u8BA4\u9886\u8FD9\u4E2A\u4EFB\u52A1\u3002\u7EF4\u62A4\u9762\u53EA\u6709\u4EFB\u52A1\u8BC4\u8BBA:\u4EC5\u5728\u4EA4\u4ED8/\u5931\u8D25/\u7B49\u62CD\u677F\u4E09\u7C7B\u91CC\u7A0B\u7891\u8282\u70B9\u53D1\u4EFB\u52A1\u8BC4\u8BBA(lark-cli task comments create);\u771F\u6B63\u4EA4\u4ED8\u7684\u90A3\u4E00\u8F6E\u5728 state.json \u7684 task_handle \u91CC\u58F0\u660E done: true,\u5E76\u53D1\u4E00\u6761\u300C\u5DF2\u4EA4\u4ED8,\u770B\u8FC7\u8BF7\u70B9\u5B8C\u6210\u300D\u8BC4\u8BBA\u3002\u4E0D\u8981\u4FEE\u6539\u4EFB\u52A1\u63CF\u8FF0\u3001\u4E0D\u8981\u52FE\u5B8C\u6210/reopen\u2014\u2014\u5B8C\u6210\u6C38\u8FDC\u7531\u4EBA\u5728\u4EFB\u52A1\u4E2D\u5FC3\u70B9\u3002"
-    );
+    if (taskRoot.justClaimed) {
+      lines.push(
+        `bridge \u5DF2\u81EA\u52A8\u8BA4\u9886\u8FD9\u4E2A\u4EFB\u52A1(\u673A\u68B0\u7ED1\u5B9A,\u4E0D\u9700\u8981\u4F60\u518D\u5199 state.json \u8BA4\u9886),\u4F46**\u8BA4\u9886\u8BC4\u8BBA\u8FD8\u6B20\u7740**\u3002\u672C\u8F6E\u8BF7:\u2460 \u5148\u8BFB\u4E00\u904D\u8BE5\u4EFB\u52A1\u7684\u73B0\u6709\u8BC4\u8BBA(lark-cli task comments list)\u2014\u2014\u5DF2\u6709**\u5176\u4ED6 agent** \u7684\u8BA4\u9886\u58F0\u660E\u8BF4\u660E\u5BF9\u65B9\u5DF2\u63A5\u624B,\u4E0D\u8981\u518D\u53D1\u8BA4\u9886\u8BC4\u8BBA(\u91CD\u590D\u8BC4\u8BBA=\u9A9A\u6270),\u914D\u5408\u5E72\u6D3B\u5373\u53EF;\u2461 \u8BC4\u8BBA\u533A\u6CA1\u6709\u522B\u4EBA\u8BA4\u9886 \u2192 \u53D1\u4E00\u6761**\u8BA4\u9886\u8BC4\u8BBA**(lark-cli task comments create):\u4E00\u53E5\u8BA4\u9886\u58F0\u660E${taskRoot.topicLink ? " + \u4E0A\u9762\u7684 topic_link(\u7528\u6237\u70B9\u5B83\u76F4\u8FBE\u672C\u8BDD\u9898\u2014\u2014\u4EFB\u52A1\u2192\u8BDD\u9898\u552F\u4E00\u56DE\u8DF3,\u522B\u7701\u7565)" : ""};\u2462 \u6B63\u5E38\u5E72\u6D3B(\u4EFB\u52A1\u6807\u9898/\u63CF\u8FF0\u5C31\u662F\u9700\u6C42)\u3002\u4E4B\u540E\u7EF4\u62A4\u9762\u53EA\u6709\u4EFB\u52A1\u8BC4\u8BBA(\u4EA4\u4ED8/\u5931\u8D25/\u7B49\u62CD\u677F\u624D\u53D1,\u8FC7\u7A0B\u788E\u788E\u5FF5\u4E0D\u53D1);\u771F\u6B63\u4EA4\u4ED8\u7684\u90A3\u4E00\u8F6E\u5728 state.json \u7684 task_handle \u91CC\u58F0\u660E done: true \u5E76\u53D1\u300C\u5DF2\u4EA4\u4ED8,\u770B\u8FC7\u8BF7\u70B9\u5B8C\u6210\u300D\u8BC4\u8BBA\u3002\u4E0D\u8981\u4FEE\u6539\u4EFB\u52A1\u63CF\u8FF0\u3001\u4E0D\u8981\u52FE\u5B8C\u6210/reopen\u2014\u2014\u5B8C\u6210\u6C38\u8FDC\u7531\u4EBA\u5728\u4EFB\u52A1\u4E2D\u5FC3\u70B9\u3002`
+      );
+    } else {
+      lines.push(
+        "\u672C\u8BDD\u9898\u5DF2\u8BA4\u9886\u8FD9\u4E2A\u4EFB\u52A1\u3002\u7EF4\u62A4\u9762\u53EA\u6709\u4EFB\u52A1\u8BC4\u8BBA:\u4EC5\u5728\u4EA4\u4ED8/\u5931\u8D25/\u7B49\u62CD\u677F\u4E09\u7C7B\u91CC\u7A0B\u7891\u8282\u70B9\u53D1\u4EFB\u52A1\u8BC4\u8BBA(lark-cli task comments create);\u771F\u6B63\u4EA4\u4ED8\u7684\u90A3\u4E00\u8F6E\u5728 state.json \u7684 task_handle \u91CC\u58F0\u660E done: true,\u5E76\u53D1\u4E00\u6761\u300C\u5DF2\u4EA4\u4ED8,\u770B\u8FC7\u8BF7\u70B9\u5B8C\u6210\u300D\u8BC4\u8BBA\u3002\u4E0D\u8981\u4FEE\u6539\u4EFB\u52A1\u63CF\u8FF0\u3001\u4E0D\u8981\u52FE\u5B8C\u6210/reopen\u2014\u2014\u5B8C\u6210\u6C38\u8FDC\u7531\u4EBA\u5728\u4EFB\u52A1\u4E2D\u5FC3\u70B9\u3002"
+      );
+    }
   } else {
     lines.push(
-      `\u672C\u8F6E\u8BF7\u987A\u5E26\u9759\u9ED8\u8BA4\u9886,\u5206\u4E24\u6B65:\u2460 \u5148\u8BFB\u4E00\u904D\u8BE5\u4EFB\u52A1\u7684\u73B0\u6709\u8BC4\u8BBA(lark-cli task comments list)\u2014\u2014\u5982\u679C\u5DF2\u6709**\u5176\u4ED6 agent** \u7684\u8BA4\u9886\u58F0\u660E,\u8BF4\u660E\u540C\u8BDD\u9898\u7684\u53E6\u4E00\u4E2A bot \u5DF2\u63A5\u624B,\u672C\u8F6E\u4E0D\u8BA4\u9886\u3001\u4E0D\u58F0\u5F20\u3001\u6B63\u5E38\u56DE\u7B54\u5373\u53EF(\u53CC @ \u7ADE\u6001\u62A4\u680F:\u91CD\u590D\u8BA4\u9886 = \u53CC\u4EFD\u7EF4\u62A4 + \u53CC\u4EFD\u5DE1\u68C0\u9A9A\u6270);\u2461 \u6CA1\u6709\u522B\u4EBA\u8BA4\u9886 \u2192 \u628A\u4E0A\u9762\u7684 task_guid \u5199\u5165 state.json \u7684 task_handle.guid,\u5E76\u53D1\u4E00\u6761\u8BA4\u9886\u8BC4\u8BBA(lark-cli task comments create),\u5185\u5BB9 = \u4E00\u53E5\u8BA4\u9886\u58F0\u660E${taskRoot.topicLink ? " + \u4E0A\u9762\u7684 topic_link(\u7528\u6237\u70B9\u5B83\u76F4\u8FBE\u672C\u8BDD\u9898)" : ""}\u3002\u4E4B\u540E\u7EF4\u62A4\u9762\u53EA\u6709\u4EFB\u52A1\u8BC4\u8BBA(\u4EA4\u4ED8/\u5931\u8D25/\u7B49\u62CD\u677F\u624D\u53D1,\u8FC7\u7A0B\u788E\u788E\u5FF5\u4E0D\u53D1);\u4E0D\u8981\u4FEE\u6539\u4EFB\u52A1\u63CF\u8FF0\u3001\u4E0D\u8981\u52FE\u5B8C\u6210\u2014\u2014\u5B8C\u6210\u6C38\u8FDC\u7531\u4EBA\u70B9\u3002`
+      `bridge \u672A\u80FD\u81EA\u52A8\u8BA4\u9886\u8FD9\u4E2A\u4EFB\u52A1\u2014\u2014\u6700\u5E38\u89C1\u7684\u539F\u56E0\u662F\u5B83\u5DF2\u88AB**\u53E6\u4E00\u4E2A\u8BDD\u9898\u6216\u53E6\u4E00\u4E2A agent** \u8BA4\u9886(\u673A\u68B0\u5B88\u536B\u62D2\u7EDD\u91CD\u590D\u8BA4\u9886),\u4E5F\u53EF\u80FD\u662F\u8BA4\u9886\u901A\u9053\u672A\u63A5\u5165\u3002\u672C\u8F6E\u8BF7:\u2460 \u5148\u8BFB\u4E00\u904D\u8BE5\u4EFB\u52A1\u7684\u73B0\u6709\u8BC4\u8BBA(lark-cli task comments list)\u2014\u2014\u5DF2\u6709\u5176\u4ED6 agent \u7684\u8BA4\u9886\u58F0\u660E \u2192 \u5BF9\u65B9\u5DF2\u63A5\u624B,\u4F60\u53EA\u662F\u88AB\u53EB\u6765\u534F\u4F5C:\u5E72\u597D\u88AB @ \u6765\u505A\u7684\u4E8B,\u4E0D\u8981\u8BA4\u9886\u3001\u4E0D\u8981\u91CD\u590D\u53D1\u8BA4\u9886\u8BC4\u8BBA;\u2461 \u8BC4\u8BBA\u533A\u6CA1\u6709\u4EFB\u4F55\u8BA4\u9886\u3001\u4E14\u4F60\u5224\u65AD\u8BE5\u7531\u4F60\u63A5\u624B \u2192 \u628A\u4E0A\u9762\u7684 task_guid \u5199\u5165 state.json \u7684 task_handle.guid,\u5E76\u53D1\u4E00\u6761\u8BA4\u9886\u8BC4\u8BBA(lark-cli task comments create),\u5185\u5BB9 = \u4E00\u53E5\u8BA4\u9886\u58F0\u660E${taskRoot.topicLink ? " + \u4E0A\u9762\u7684 topic_link(\u7528\u6237\u70B9\u5B83\u76F4\u8FBE\u672C\u8BDD\u9898)" : ""}\u3002\u4E4B\u540E\u7EF4\u62A4\u9762\u53EA\u6709\u4EFB\u52A1\u8BC4\u8BBA(\u4EA4\u4ED8/\u5931\u8D25/\u7B49\u62CD\u677F\u624D\u53D1,\u8FC7\u7A0B\u788E\u788E\u5FF5\u4E0D\u53D1);\u4E0D\u8981\u4FEE\u6539\u4EFB\u52A1\u63CF\u8FF0\u3001\u4E0D\u8981\u52FE\u5B8C\u6210\u2014\u2014\u5B8C\u6210\u6C38\u8FDC\u7531\u4EBA\u70B9\u3002`
     );
   }
   lines.push("</task-root>");
@@ -119390,9 +119401,20 @@ async function renderPrompt(input) {
     taskHandleClaimed = false,
     taskHandleCandidates = [],
     taskRoot,
-    mtimeFacts = []
+    mtimeFacts = [],
+    queuedFollowups = []
   } = input;
   const backend = input.backend ?? "claude";
+  const userMessageLines = [
+    "<user-message>",
+    `${parsed.senderOpenId}: ${parsed.text}`,
+    ...queuedFollowups.length > 0 ? [
+      "",
+      `(\u4EE5\u4E0B ${queuedFollowups.length} \u6761\u8FFD\u52A0\u6D88\u606F\u5728\u4E0A\u4E00\u8F6E\u5904\u7406\u671F\u95F4\u5230\u8FBE,\u5DF2\u5408\u5E76\u8FDB\u672C\u8F6E \u2014\u2014 \u6309\u987A\u5E8F\u4E00\u5E76\u5904\u7406,\u53EA\u9700\u4E00\u6B21\u7B54\u590D:)`,
+      ...queuedFollowups.map((f) => `${f.senderOpenId}: ${f.text}`)
+    ] : [],
+    "</user-message>"
+  ];
   const profileFlag = larkCliProfile ? ` --profile ${larkCliProfile}` : "";
   const attachmentKeys = parsed.attachments.map((a) => a.fileKey);
   const imageKeys = parsed.attachments.filter((a) => a.fileType === "image").map((a) => a.fileKey);
@@ -119524,9 +119546,7 @@ async function renderPrompt(input) {
       ...taskHandleBlock.length > 0 ? ["", ...taskHandleBlock] : [],
       ...taskRootBlock.length > 0 ? ["", ...taskRootBlock] : [],
       "",
-      "<user-message>",
-      `${parsed.senderOpenId}: ${parsed.text}`,
-      "</user-message>"
+      ...userMessageLines
     ].join("\n");
   }
   return [
@@ -119581,9 +119601,7 @@ async function renderPrompt(input) {
     ...taskHandleBlock.length > 0 ? ["", ...taskHandleBlock] : [],
     ...taskRootBlock.length > 0 ? ["", ...taskRootBlock] : [],
     "",
-    "<user-message>",
-    `${parsed.senderOpenId}: ${parsed.text}`,
-    "</user-message>"
+    ...userMessageLines
   ].join("\n");
 }
 
@@ -119770,6 +119788,12 @@ function renderTranscriptEntry(input) {
     "",
     indentBlock(parsed.text),
     "",
+    ...input.queuedFollowups && input.queuedFollowups.length > 0 ? [
+      "### Coalesced Follow-ups",
+      "",
+      ...input.queuedFollowups.flatMap((f) => [`- ${f.senderOpenId}:`, indentBlock(f.text)]),
+      ""
+    ] : [],
     "### Feishu Doc Links",
     "",
     ...renderList(parsed.feishuDocLinks),
@@ -122149,6 +122173,20 @@ async function isWorktreeGitHealthy(worktreePath) {
     child.on("error", () => resolve2(false));
   });
 }
+function canCoalesceFollowup(primary, candidate) {
+  if (primary.larkway_trigger_type != null || candidate.larkway_trigger_type != null) return false;
+  if (primary.reply_anchor_message_id != null || candidate.reply_anchor_message_id != null) return false;
+  const sessionKeyOf = (e) => typeof e.root_id === "string" && e.root_id ? e.root_id : e.message_id;
+  if (sessionKeyOf(primary) !== sessionKeyOf(candidate)) return false;
+  try {
+    const parsed = parseMessage(candidate);
+    if (parsed.attachments.length > 0) return false;
+    if (parsed.text.trim() === "") return false;
+  } catch {
+    return false;
+  }
+  return true;
+}
 var repoCloneLocks = /* @__PURE__ */ new Map();
 function ensureRepoClone(basePath, url, token, label) {
   const prev = repoCloneLocks.get(basePath) ?? Promise.resolve();
@@ -122420,6 +122458,15 @@ var BridgeHandler = class {
    * broken handoff and fire a spurious nudge. Read via getThreadReceivedAt().
    */
   threadReceivedAt = /* @__PURE__ */ new Map();
+  /**
+   * v4.2 (docs/task-handle.md §13 revision 5): per-thread OUTCOME of the most
+   * recent finished turn ("completed" | "failed"), recorded at finalize.
+   * StallDetector reads a PEER handler's map via getThreadLastOutcome to tell
+   * "the peer finished successfully" apart from "the peer crashed" — a failed
+   * finish must NOT resolve a handoff. In-memory like threadReceivedAt (empty
+   * after restart → detector falls back to its documented restart posture).
+   */
+  threadLastOutcome = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
@@ -122432,6 +122479,10 @@ var BridgeHandler = class {
    * — callers must apply their own startup quiet-period before treating that
    * as evidence of a truly broken handoff.
    */
+  /** v4.2 — see threadLastOutcome's field doc. */
+  getThreadLastOutcome(threadId) {
+    return this.threadLastOutcome.get(threadId);
+  }
   getThreadReceivedAt(threadId) {
     return this.threadReceivedAt.get(threadId);
   }
@@ -122498,6 +122549,7 @@ var BridgeHandler = class {
   async run(opts) {
     const signal = opts?.abortSignal;
     const threadQueues = /* @__PURE__ */ new Map();
+    const pendingByKey = /* @__PURE__ */ new Map();
     const MAX_CONCURRENT = 5;
     let running = 0;
     const waiters = [];
@@ -122523,12 +122575,33 @@ var BridgeHandler = class {
       this.threadReceivedAt.set(key, Date.now());
       const legacySessionKey = typeof event.root_id === "string" && event.root_id ? event.root_id : event.message_id;
       if (legacySessionKey !== key) this.threadReceivedAt.set(legacySessionKey, Date.now());
+      let pendingList = pendingByKey.get(key);
+      if (pendingList == null) {
+        pendingList = [];
+        pendingByKey.set(key, pendingList);
+      }
+      pendingList.push(event);
       const prev = threadQueues.get(key) ?? Promise.resolve();
-      const next = prev.then(() => acquire()).then(() => this.handleOne(event)).catch((err) => {
+      const next = prev.then(() => acquire()).then(() => {
+        const pending = pendingByKey.get(key);
+        const primary = pending?.shift();
+        if (primary == null) return;
+        const followups = [];
+        while (pending != null && pending.length > 0 && canCoalesceFollowup(primary, pending[0])) {
+          followups.push(pending.shift());
+        }
+        if (followups.length > 0) {
+          console.log(
+            `[bridge.handler] coalescing ${followups.length} queued follow-up message(s) into turn ${primary.message_id} on thread ${key}`
+          );
+        }
+        return this.handleOne(primary, followups);
+      }).catch((err) => {
         console.error(`[bridge.handler] unhandled error on thread ${key}:`, err);
       }).finally(() => {
         release();
         if (threadQueues.get(key) === next) threadQueues.delete(key);
+        if ((pendingByKey.get(key)?.length ?? 0) === 0) pendingByKey.delete(key);
         this.inFlightTurns.delete(next);
       });
       this.inFlightTurns.add(next);
@@ -122545,7 +122618,14 @@ var BridgeHandler = class {
   // ---------------------------------------------------------------------------
   // Private: single-event lifecycle
   // ---------------------------------------------------------------------------
-  async handleOne(event) {
+  /**
+   * @param followups 批D gated coalescing — same-session messages that queued
+   * up behind the previous turn and are merged into THIS one (see run()'s
+   * drain loop + canCoalesceFollowup). They contribute their text to the
+   * prompt and settle together with the primary; everything else about the
+   * turn (card, session, task probes) is driven by `event` alone.
+   */
+  async handleOne(event, followups = []) {
     const settleMessageId = event.message_id;
     let settled = false;
     let agentRunCompleted = false;
@@ -122555,8 +122635,10 @@ var BridgeHandler = class {
     const settle = (ok) => {
       if (settled) return;
       settled = true;
-      if (ok) this.deps.client.markHandled?.(settleMessageId);
-      else this.deps.client.markUnhandled?.(settleMessageId, { replay: !agentRunCompleted });
+      for (const id of [settleMessageId, ...followups.map((f) => f.message_id)]) {
+        if (ok) this.deps.client.markHandled?.(id);
+        else this.deps.client.markUnhandled?.(id, { replay: !agentRunCompleted });
+      }
     };
     try {
       const parsed = parseMessage(event);
@@ -122567,7 +122649,33 @@ var BridgeHandler = class {
       const eventStartedAt = Date.now();
       let taskRootInfo;
       let taskCardAnchorId;
+      let taskRootJustClaimed = false;
       let deferredTaskRootProbe;
+      const autoClaimTaskRoot = async (guid) => {
+        if (!this.deps.taskHandleClaim || !botId) return;
+        const alreadyThis = this.deps.taskHandleClaimGuidLookup?.(threadId) === guid;
+        if (alreadyThis) return;
+        if (this.deps.taskGuidClaimedByOtherBot?.(guid)) return;
+        try {
+          await this.deps.taskHandleClaim({
+            botId,
+            threadId,
+            chatId: parsed.chatId,
+            taskGuid: guid,
+            mode: "comment",
+            // Round-2 fix: the mechanical auto-claim must never REPLACE an
+            // existing different-guid claim on this thread (same charter as the
+            // v3 auto-bind guard) — only the agent's own re-declaration may.
+            onlyIfThreadUnclaimed: true,
+            // Round-2 fix: persist "claim comment still owed" so a first-turn
+            // crash after the claim doesn't lose the task→topic backlink.
+            claimCommentPending: true
+          });
+          taskRootJustClaimed = this.deps.taskHandleClaimGuidLookup ? this.deps.taskHandleClaimGuidLookup(threadId) === guid : true;
+        } catch (err) {
+          console.warn("[bridge.handler] task-root auto-claim failed (continuing):", err);
+        }
+      };
       {
         const realTopic = realTopicThreadId(parsed.raw.thread_id);
         const rootCandidate = (typeof parsed.raw.root_id === "string" && parsed.raw.root_id ? parsed.raw.root_id : void 0) ?? (typeof parsed.raw.parent_id === "string" && parsed.raw.parent_id ? parsed.raw.parent_id : void 0);
@@ -122588,6 +122696,7 @@ var BridgeHandler = class {
                 };
                 taskCardAnchorId = rootCandidate;
                 threadId = rootCandidate;
+                await autoClaimTaskRoot(todo.taskGuid);
               }
             }
           }
@@ -122626,6 +122735,27 @@ var BridgeHandler = class {
         reason: "\u5DF2\u8FDB\u5165 bridge\uFF0C\u51C6\u5907\u521B\u5EFA\u5904\u7406\u5361\u7247\u3002"
       });
       await this.deps.client.addProcessingReaction?.(messageId);
+      for (const f of followups) {
+        if (!this.deps.recordRuntimeEvent) break;
+        try {
+          await this.deps.recordRuntimeEvent({
+            id: f.message_id,
+            botId,
+            botName: this.deps.botConfig?.name,
+            messageId: f.message_id,
+            threadId,
+            chatId: parsed.chatId,
+            senderId: typeof f.sender_id === "string" ? f.sender_id : void 0,
+            triggerType,
+            status: "received",
+            receivedAt: new Date(eventStartedAt).toISOString(),
+            statusPath: ["\u5DF2\u6536\u5230", "\u5408\u5E76\u8FDB\u540C\u8F6E"],
+            reason: `\u6392\u961F\u671F\u95F4\u5230\u8FBE,\u5DF2\u5408\u5E76\u8FDB ${messageId} \u7684\u540C\u4E00\u8F6E\u5904\u7406\u3002`
+          });
+        } catch (err) {
+          console.warn("[bridge.handler] recordRuntimeEvent (coalesced followup) failed (continuing):", err);
+        }
+      }
       const invokeTaskHandleLifecycle = async (fields) => {
         if (!this.deps.taskHandleLifecycle || !botId) return;
         try {
@@ -122992,12 +123122,17 @@ var BridgeHandler = class {
             }
           }
         }
+        const queuedFollowups = followups.map((f) => {
+          const p = parseMessage(f);
+          return { senderOpenId: p.senderOpenId, text: p.text };
+        });
         if (isAgentWorkspace) {
           await ensureSessionArtifacts({
             sessionPath: worktreePath,
             parsed,
             isNewThread: existing === void 0,
-            larkCliProfile: this.deps.larkCliProfile
+            larkCliProfile: this.deps.larkCliProfile,
+            queuedFollowups
           });
         }
         try {
@@ -123101,6 +123236,7 @@ var BridgeHandler = class {
                   summary: todo.summaryText,
                   topicLink: rawThreadId ? buildTopicDeepLink(parsed.chatId, rawThreadId) : probeThreadId ? buildTopicDeepLink(parsed.chatId, probeThreadId) : void 0
                 };
+                await autoClaimTaskRoot(todo.taskGuid);
               }
             }
           }
@@ -123114,6 +123250,7 @@ var BridgeHandler = class {
           const prompt = await renderPrompt({
             parsed,
             isNewThread: currentIsNewThread,
+            queuedFollowups,
             conventions: {
               worktreePath,
               runtime: conventions.runtime,
@@ -123147,7 +123284,8 @@ var BridgeHandler = class {
               // Exact-guid comparison (see taskHandleClaimGuidLookup's doc);
               // falls back to the boolean lookup only when the precise one
               // isn't wired (older embedding code).
-              claimed: this.deps.taskHandleClaimGuidLookup ? this.deps.taskHandleClaimGuidLookup(threadId) === taskRootInfo.guid : this.deps.taskHandleClaimedLookup?.(threadId) ?? false
+              claimed: this.deps.taskHandleClaimGuidLookup ? this.deps.taskHandleClaimGuidLookup(threadId) === taskRootInfo.guid : this.deps.taskHandleClaimedLookup?.(threadId) ?? false,
+              justClaimed: taskRootJustClaimed || this.deps.taskHandleClaimCommentPending?.(threadId) || void 0
             } : void 0,
             mtimeFacts
           });
@@ -123332,6 +123470,7 @@ var BridgeHandler = class {
                 reason: failureReason
               });
             }
+            this.threadLastOutcome.set(threadId, success ? "completed" : "failed");
             const stuckResetAfter = resolveStuckSessionResetAfter();
             const prevStuckCount = currentExisting?.consecutiveStuckCount ?? 0;
             const nextStuckCount = cardKitTimeoutFailure ? prevStuckCount + 1 : success ? 0 : prevStuckCount;
@@ -123576,6 +123715,7 @@ var BridgeHandler = class {
         }
       } catch (err) {
         console.error("[bridge.handler] handleOne failed for thread", threadId, err);
+        this.threadLastOutcome.set(threadId, "failed");
         cotTurnOutcome = "error";
         if (cotPublisher) {
           void cotPublisher.finalize("error", { message: String(err) }).catch(() => {
@@ -127039,24 +127179,37 @@ var BotConfigSchema = external_exports.object({
    */
   effort: external_exports.string().min(1).optional(),
   /**
-   * docs/larkway-perf-plan.md §4 — opt into a persistent warm process
-   * instead of the default one-shot cold-start-per-turn behavior. Takes
-   * effect for `backend: "codex"` (a single bot-level `codex app-server`
-   * process — src/codex/pool.ts CodexProcessPool) and `backend: "claude"`
-   * (one warm process per active thread — src/claude/pool.ts
-   * ClaudeProcessPool). Any other backend value is a no-op (main.ts only
-   * constructs a pool for these two; botLoader's advisory warn below flags
-   * the mismatch upfront). Byte-identical behavior when unset, matching
-   * every other perf-plan flag in this schema. `.optional()` (not
-   * `.default(false)`, deliberately — B1 fix): a `.default()` would make
-   * every future `larkway bot` yaml write-out include `warmProcess: false`
-   * even when nobody asked for it, and — because this schema is `.strict()`
-   * — would break loading that yaml back with an OLDER larkway build that
-   * predates this field. `undefined` and `false` are treated identically at
-   * both read sites (main.ts's `bot.warmProcess && …` and the advisory warn
-   * below).
+   * docs/larkway-perf-plan.md §4 — persistent warm process instead of a
+   * one-shot cold start per turn. Takes effect for `backend: "codex"` (a
+   * single bot-level `codex app-server` process — src/codex/pool.ts
+   * CodexProcessPool) and `backend: "claude"` (one warm process per active
+   * thread — src/claude/pool.ts ClaudeProcessPool). Any other backend value
+   * is a no-op (main.ts only constructs a pool for these two; botLoader's
+   * advisory warn below flags the mismatch upfront).
+   *
+   * 批D (warm-by-default):
+   * DEFAULT IS NOW ON for the two supported backends — `undefined` means
+   * `true` when backend is codex/claude (see {@link effectiveWarmProcess},
+   * the single source of that rule). Set `warmProcess: false` explicitly to
+   * opt a bot back out. `.optional()` (not `.default(true)`) is still
+   * deliberate: a `.default()` would make every future `larkway bot` yaml
+   * write-out bake the value in, and — because this schema is `.strict()` —
+   * would break loading that yaml back with an OLDER larkway build that
+   * predates this field.
    */
   warmProcess: external_exports.boolean().optional(),
+  /**
+   * 批D: pre-warm a BLANK agent process at bridge boot (and keep one on
+   * standby thereafter), so even the FIRST message of a NEW thread skips the
+   * cold start. Only meaningful when the warm pool is on (see
+   * `warmProcess`); default true. backend=claude: ClaudeProcessPool keeps
+   * one blank (no --resume) child matching the bot's static spawn signature,
+   * adopted by the first new-session turn and replenished after adoption.
+   * backend=codex: CodexProcessPool spawns its app-server eagerly at boot
+   * instead of on the first turn. Set false to keep warm pooling but skip
+   * the always-resident standby (saves ~300MB RSS per bot at idle).
+   */
+  prewarmProcess: external_exports.boolean().optional(),
   /**
    * Idle threshold (ms) before a warm process (see `warmProcess` above) with
    * no in-flight turn gets SIGTERM'd. Only meaningful when `warmProcess` is
@@ -127074,6 +127227,13 @@ var BotConfigSchema = external_exports.object({
    */
   warmProcessMaxProcesses: external_exports.number().int().positive().optional()
 }).strict();
+function effectiveWarmProcess(bot) {
+  if (bot.backend !== "claude" && bot.backend !== "codex") return bot.warmProcess === true;
+  return bot.warmProcess !== false;
+}
+function effectivePrewarmProcess(bot) {
+  return effectiveWarmProcess(bot) && bot.prewarmProcess !== false;
+}
 async function loadBots(botsDir) {
   let entries;
   try {
@@ -128347,6 +128507,8 @@ var INTERRUPT_GRACE_MS = 3e3;
 var DEFAULT_TURN_TIMEOUT_MS = 15 * 60 * 1e3;
 var SHUTDOWN_EXIT_WAIT_MS = SIGKILL_GRACE_MS2 + 2e3;
 var STDERR_BUFFER_CAP_BYTES = 64 * 1024;
+var MAX_PREWARM_FAILURES = 3;
+var PREWARM_RESPAWN_BACKOFF_MS = 1e4;
 var ClaudeProcessPool = class {
   #botId;
   #botGitIdentity;
@@ -128380,6 +128542,15 @@ var ClaudeProcessPool = class {
    * -killed while that child still lives. Removed in `#onEntryExit`.
    */
   #dying = /* @__PURE__ */ new Set();
+  // -- 批D blank-standby prewarm state ----------------------------------------
+  /** Set by prewarm(); undefined = prewarm never requested (no blank maintenance). */
+  #prewarmProto;
+  /** Consecutive unprompted blank deaths (any age) — resets on a successful adoption. */
+  #prewarmFailures = 0;
+  /** True once the circuit breaker tripped (MAX_PREWARM_FAILURES) — prewarm off until bridge restart. */
+  #prewarmDisabled = false;
+  #prewarmRespawnTimer;
+  #nextBlankId = 1;
   constructor(opts) {
     this.#botId = opts.botId;
     this.#botGitIdentity = opts.botGitIdentity;
@@ -128396,6 +128567,23 @@ var ClaudeProcessPool = class {
   get pidsForTesting() {
     return [...this.#entries.values()].map((e) => e.child.pid).filter((pid) => pid != null);
   }
+  get blankProcessCountForTesting() {
+    return [...this.#entries.values()].filter((e) => e.blank).length;
+  }
+  /**
+   * 批D: start maintaining ONE blank standby child matching `proto`'s spawn
+   * signature — spawned now, adopted by the first new-session turn whose own
+   * options produce the same signature (see PoolEntry.spawnSignature), and
+   * replenished after each adoption. Call once at bridge boot (main.ts),
+   * only for bots whose cwd is static across threads (agent_workspace
+   * runtime); calling it again replaces the proto for future respawns but
+   * never kills an existing blank. No-op after shutdown() or once the
+   * circuit breaker has tripped.
+   */
+  prewarm(proto) {
+    this.#prewarmProto = proto;
+    this.#maybeSpawnBlank();
+  }
   run(opts) {
     const queue = new TurnEventQueue();
     const markPerf = createPerfMarker(opts.onPerfMarker);
@@ -128443,6 +128631,9 @@ var ClaudeProcessPool = class {
       }
     }
     let entry = this.#entries.get(key);
+    if (entry == null && opts.resumeSessionId == null) {
+      entry = this.#adoptBlankEntry(key, threadId, opts);
+    }
     if (entry == null) {
       if (this.#entries.size >= this.#maxProcesses) {
         const victim = this.#pickLruIdleVictim();
@@ -128472,6 +128663,10 @@ var ClaudeProcessPool = class {
       clearInterval(this.#idleSweepTimer);
       this.#idleSweepTimer = void 0;
     }
+    if (this.#prewarmRespawnTimer) {
+      clearTimeout(this.#prewarmRespawnTimer);
+      this.#prewarmRespawnTimer = void 0;
+    }
     const inFlight = [...this.#entries.values()].map((e) => e.current?.done.catch(() => void 0)).filter((p) => p != null);
     await Promise.race([
       Promise.all(inFlight),
@@ -128518,6 +128713,9 @@ var ClaudeProcessPool = class {
     return `${this.#botId}::${threadId}::${cwd}::${model}::${effort}`;
   }
   #pickLruIdleVictim() {
+    for (const entry of this.#entries.values()) {
+      if (entry.current == null && entry.blank) return entry;
+    }
     let victim;
     for (const entry of this.#entries.values()) {
       if (entry.current != null) continue;
@@ -128670,7 +128868,89 @@ var ClaudeProcessPool = class {
     if (state.interruptEscalateTimer) clearTimeout(state.interruptEscalateTimer);
   }
   // -- process lifecycle -------------------------------------------------------
-  #spawnEntry(key, threadId, opts) {
+  /**
+   * The spawn identity a set of run/prewarm options resolves to. Built from
+   * the SAME buildWarmCommand path #spawnEntry actually spawns with, so an
+   * adoption match is by construction a spawn-arg-identical process.
+   * `resumeSessionId` is deliberately dropped: adoption is only ever
+   * attempted for turns with no resume (run() guards), and the blank itself
+   * is spawned without one.
+   */
+  #spawnSignatureOf(opts) {
+    const [bin, args] = buildWarmCommand({
+      prompt: "",
+      cwd: opts.cwd,
+      model: opts.model,
+      effort: opts.effort,
+      permissionMode: opts.permissionMode,
+      agentBinPath: opts.agentBinPath
+    });
+    return JSON.stringify([bin, args, opts.cwd ?? null]);
+  }
+  /**
+   * 批D: find an idle blank whose spawn signature matches this turn's options
+   * and rekey it in place onto (key, threadId). Returns undefined when no
+   * blank matches — the caller falls through to a normal spawn. Schedules a
+   * replacement blank on success.
+   */
+  #adoptBlankEntry(key, threadId, opts) {
+    let blank;
+    for (const e of this.#entries.values()) {
+      if (e.blank && !e.destroyed && e.current == null) {
+        blank = e;
+        break;
+      }
+    }
+    if (blank == null) return void 0;
+    const wanted = this.#spawnSignatureOf(opts);
+    if (blank.spawnSignature !== wanted) {
+      console.warn(
+        `[claude-pool] blank standby exists but its spawn signature doesn't match this turn's options \u2014 not adopting (blank=${blank.spawnSignature} turn=${wanted}). Check the prewarm wiring in main.ts.`
+      );
+      return void 0;
+    }
+    this.#entries.delete(blank.key);
+    blank.key = key;
+    blank.threadId = threadId;
+    blank.blank = false;
+    blank.lastUsedAt = Date.now();
+    this.#entries.set(key, blank);
+    this.#rewritePidListBestEffort();
+    this.#prewarmFailures = 0;
+    console.warn(
+      `[claude-pool] blank standby pid=${blank.child.pid ?? "?"} adopted by thread=${threadId} \u2014 this turn skips the cold start entirely.`
+    );
+    queueMicrotask(() => this.#maybeSpawnBlank());
+    return blank;
+  }
+  /**
+   * Spawn the standby blank when prewarm is configured and conditions allow:
+   * at most one blank at a time, never past maxProcesses, never while
+   * shutting down, and never after the circuit breaker tripped.
+   */
+  #maybeSpawnBlank() {
+    if (this.#prewarmProto == null || this.#prewarmDisabled || this.#shuttingDown) return;
+    if (this.#prewarmRespawnTimer != null) return;
+    if (this.#entries.size >= this.#maxProcesses) return;
+    for (const e of this.#entries.values()) {
+      if (e.blank) return;
+    }
+    const proto = this.#prewarmProto;
+    const key = `__blank__::${this.#botId}::${this.#nextBlankId++}`;
+    const opts = {
+      prompt: "",
+      cwd: proto.cwd,
+      model: proto.model,
+      effort: proto.effort,
+      permissionMode: proto.permissionMode,
+      agentBinPath: proto.agentBinPath
+    };
+    const entry = this.#spawnEntry(key, key, opts, { blank: true });
+    console.warn(
+      `[claude-pool] pre-warmed blank standby pid=${entry.child.pid ?? "?"} for bot=${this.#botId} (signature=${entry.spawnSignature.slice(0, 120)}\u2026)`
+    );
+  }
+  #spawnEntry(key, threadId, opts, flags) {
     const [bin, args] = buildWarmCommand(opts);
     const env = buildEnv(this.#botGitIdentity, this.#gitlabToken);
     const child = spawn3(bin, args, {
@@ -128682,6 +128962,8 @@ var ClaudeProcessPool = class {
       key,
       threadId,
       cwd: opts.cwd,
+      blank: flags?.blank === true,
+      spawnSignature: this.#spawnSignatureOf(opts),
       child,
       spawnedAt: Date.now(),
       lastUsedAt: Date.now(),
@@ -128747,6 +129029,32 @@ var ClaudeProcessPool = class {
     this.#dying.delete(entry);
     this.#rewritePidListBestEffort();
     void this.#deleteRunnerPidFileIfMine(entry);
+    if (this.#prewarmProto != null && !this.#shuttingDown && !this.#prewarmDisabled) {
+      const unpromptedBlankDeath = entry.blank && !wasAlreadyMarkedDestroyed;
+      if (unpromptedBlankDeath) {
+        this.#prewarmFailures += 1;
+        if (this.#prewarmFailures >= MAX_PREWARM_FAILURES) {
+          this.#prewarmDisabled = true;
+          const stderr = Buffer.concat(entry.stderrChunks).toString("utf8").trim().slice(-2e3);
+          console.warn(
+            `[claude-pool] blank standby died unprompted ${this.#prewarmFailures} times in a row \u2014 disabling prewarm until the bridge restarts (warm pooling itself stays on; turns just spawn on demand).` + (stderr ? ` last stderr tail:
+${stderr}` : "")
+          );
+        } else {
+          const delay = PREWARM_RESPAWN_BACKOFF_MS * 2 ** (this.#prewarmFailures - 1);
+          console.warn(
+            `[claude-pool] blank standby pid=${entry.child.pid ?? "?"} died unprompted after ${Math.round((Date.now() - entry.spawnedAt) / 1e3)}s (${this.#prewarmFailures}/${MAX_PREWARM_FAILURES}) \u2014 respawning in ${delay}ms.`
+          );
+          this.#prewarmRespawnTimer = setTimeout(() => {
+            this.#prewarmRespawnTimer = void 0;
+            this.#maybeSpawnBlank();
+          }, delay);
+          this.#prewarmRespawnTimer.unref?.();
+        }
+      } else {
+        queueMicrotask(() => this.#maybeSpawnBlank());
+      }
+    }
     const state = entry.current;
     entry.current = void 0;
     if (state == null || state.settled) return;
@@ -128799,6 +129107,7 @@ ${stderr}` : "")
       const now = Date.now();
       for (const entry of [...this.#entries.values()]) {
         if (entry.current != null) continue;
+        if (entry.blank) continue;
         if (now - entry.lastUsedAt >= this.#idleMs) {
           this.#destroyEntry(entry, "idle timeout");
         }
@@ -129418,6 +129727,19 @@ var CodexProcessPool = class {
   get childPid() {
     return this.#child?.pid ?? void 0;
   }
+  /**
+   * 批D: spawn the app-server eagerly at bridge boot instead of lazily on the
+   * first turn, so even the bot's first message hits a running process.
+   * Idempotent; no-op while shutting down or after the spawn circuit breaker
+   * (#poolDisabled) tripped. Unlike ClaudeProcessPool's blank standby there
+   * is no post-idle-reap replenish here: after the 10-min idle reap the next
+   * turn re-spawns on demand exactly as before (the reap exists to bound the
+   * app-server's per-thread memory growth — auto-respawning would defeat it).
+   */
+  prewarm() {
+    if (this.#shuttingDown || this.#poolDisabled) return;
+    if (this.#child == null) this.#spawnChild();
+  }
   run(opts) {
     const turnKey = this.#nextTurnKey++;
     const queue = new TurnEventQueue();
@@ -130215,7 +130537,7 @@ function isStallNudgeState(value) {
 function isTaskHandleRecord(value) {
   if (typeof value !== "object" || value === null) return false;
   const v = value;
-  return typeof v["threadId"] === "string" && typeof v["taskGuid"] === "string" && typeof v["chatId"] === "string" && typeof v["claimedTs"] === "number" && (v["lastSeenCommentId"] === void 0 || typeof v["lastSeenCommentId"] === "string") && (v["lastTurnOutcome"] === void 0 || v["lastTurnOutcome"] === "completed" || v["lastTurnOutcome"] === "failed") && (v["stallNudge"] === void 0 || isStallNudgeState(v["stallNudge"])) && (v["stallSuppressUntilActivityAfter"] === void 0 || typeof v["stallSuppressUntilActivityAfter"] === "number") && (v["lastTurnMentions"] === void 0 || Array.isArray(v["lastTurnMentions"]) && v["lastTurnMentions"].every((m) => typeof m === "string")) && (v["lastTurnMentionsAt"] === void 0 || typeof v["lastTurnMentionsAt"] === "number") && (v["mode"] === void 0 || v["mode"] === "comment") && (v["doneDeclared"] === void 0 || typeof v["doneDeclared"] === "boolean");
+  return typeof v["threadId"] === "string" && typeof v["taskGuid"] === "string" && typeof v["chatId"] === "string" && typeof v["claimedTs"] === "number" && (v["lastSeenCommentId"] === void 0 || typeof v["lastSeenCommentId"] === "string") && (v["lastTurnOutcome"] === void 0 || v["lastTurnOutcome"] === "completed" || v["lastTurnOutcome"] === "failed") && (v["stallNudge"] === void 0 || isStallNudgeState(v["stallNudge"])) && (v["stallSuppressUntilActivityAfter"] === void 0 || typeof v["stallSuppressUntilActivityAfter"] === "number") && (v["lastTurnMentions"] === void 0 || Array.isArray(v["lastTurnMentions"]) && v["lastTurnMentions"].every((m) => typeof m === "string")) && (v["lastTurnMentionsAt"] === void 0 || typeof v["lastTurnMentionsAt"] === "number") && (v["mode"] === void 0 || v["mode"] === "comment") && (v["doneDeclared"] === void 0 || typeof v["doneDeclared"] === "boolean") && (v["claimCommentPending"] === void 0 || typeof v["claimCommentPending"] === "boolean");
 }
 var TaskHandleStore = class _TaskHandleStore {
   #filePath;
@@ -130431,7 +130753,8 @@ var TaskHandleStore = class _TaskHandleStore {
         taskGuid: input.taskGuid,
         chatId: input.chatId,
         claimedTs: Date.now(),
-        ...input.mode ? { mode: input.mode } : {}
+        ...input.mode ? { mode: input.mode } : {},
+        ...input.claimCommentPending ? { claimCommentPending: true } : {}
       };
     });
     return { claimed, reason };
@@ -130911,7 +131234,11 @@ async function applyTaskHandleWriteback(patch, deps) {
               // Agent declared delivery — its own "已交付" comment is the
               // user-facing artifact; bridge just stops patrolling the
               // "delivered, human hasn't ticked complete yet" window.
-              ...patch.agentDeclaredDone === true ? { doneDeclared: true } : {}
+              ...patch.agentDeclaredDone === true ? { doneDeclared: true } : {},
+              // v4.2 round-2: a successfully completed turn ran under a
+              // <task-root> that instructed the claim comment — consider
+              // the backlink posted; only crashed turns keep it owed.
+              claimCommentPending: void 0
             } : current
           );
           break;
@@ -131560,10 +131887,11 @@ var CandidateAlertStore = class _CandidateAlertStore {
 // src/tasklist/stallDetector.ts
 var DEFAULT_INTERVAL_MS3 = 6e4;
 var DEFAULT_JITTER_MS3 = 1e4;
-var DEFAULT_STALL_THRESHOLD_MS = 24 * 60 * 6e4;
+var DEFAULT_STALL_THRESHOLD_MS = 60 * 6e4;
 var DEFAULT_STALL_FAST_THRESHOLD_MS = 30 * 6e4;
 var DEFAULT_STALL_HANDOFF_THRESHOLD_MS = 5 * 6e4;
-var DEFAULT_NUDGE_COOLDOWN_MS = 24 * 60 * 6e4;
+var DEFAULT_NUDGE_COOLDOWN_MS = 60 * 6e4;
+var DUE_NUDGE_COOLDOWN_FLOOR_MS = 24 * 60 * 6e4;
 var DEFAULT_ESCALATE_AFTER_NUDGES = 2;
 var DEFAULT_PENDING_CONFIRM_TIMEOUT_MS = 30 * 6e4;
 var DEFAULT_HANDOFF_STARTUP_QUIET_MS = 6 * 6e4;
@@ -131742,7 +132070,7 @@ var StallDetector = class {
     const { ms: threshold, reason } = this.#effectiveThreshold(record, threadId);
     if (!nudge || nudge.count === 0) {
       if (now - lastActiveTs < threshold) return;
-      if (reason === "due" && !justClearedPendingTimeout && nudge?.lastNudgeSentAt !== void 0 && now - nudge.lastNudgeSentAt < this.#nudgeCooldownMs) {
+      if (reason === "due" && !justClearedPendingTimeout && nudge?.lastNudgeSentAt !== void 0 && now - nudge.lastNudgeSentAt < this.#cooldownFor(reason)) {
         return;
       }
       await this.#sendNudge(threadId);
@@ -131767,7 +132095,7 @@ var StallDetector = class {
       });
       return;
     }
-    if (now - nudge.lastNudgeSentAt < this.#nudgeCooldownMs) return;
+    if (now - nudge.lastNudgeSentAt < this.#cooldownFor(reason)) return;
     if (nudge.count >= this.#escalateAfterNudges) {
       await this.#escalate(threadId);
     } else {
@@ -131806,6 +132134,10 @@ var StallDetector = class {
    * until gap-fill has had a chance to redeliver anything in flight across
    * a restart.
    */
+  /** Cooldown for a given tier — the due tier keeps a 24h floor (see DUE_NUDGE_COOLDOWN_FLOOR_MS). An explicit operator nudgeCooldownMs LONGER than the floor still wins. */
+  #cooldownFor(reason) {
+    return reason === "due" ? Math.max(this.#nudgeCooldownMs, DUE_NUDGE_COOLDOWN_FLOOR_MS) : this.#nudgeCooldownMs;
+  }
   #effectiveThreshold(record, threadId) {
     const base = record.lastTurnOutcome === "failed" ? { ms: this.#stallFastThresholdMs, reason: "failed" } : { ms: this.#stallThresholdMs, reason: "normal" };
     const dueMs = this.#deps.getTaskDueMs?.(record.taskGuid);
@@ -131819,6 +132151,14 @@ var StallDetector = class {
     const now = Date.now();
     let brokenFloorMs;
     for (const peerBotId of record.lastTurnMentions) {
+      {
+        const peerOutcome = this.#deps.getPeerLastTurnOutcome?.(peerBotId, threadId);
+        const peerEndedAt = this.#deps.getPeerLastActiveTs?.(peerBotId, threadId);
+        if (peerOutcome === "failed" && peerEndedAt !== void 0 && peerEndedAt > mentionAt) {
+          brokenFloorMs = this.#stallHandoffThresholdMs;
+          break;
+        }
+      }
       const receivedAt = this.#deps.getPeerReceivedAt(peerBotId, threadId);
       if (receivedAt === void 0 || receivedAt <= mentionAt) {
         const completedAt2 = this.#deps.getPeerLastActiveTs?.(peerBotId, threadId);
@@ -132102,6 +132442,7 @@ async function runV2Mode({
   const { basename } = path19;
   const instances = [];
   const handlersByBotId = /* @__PURE__ */ new Map();
+  const allTaskHandleStores = [];
   const tasklistPollersByGuid = /* @__PURE__ */ new Map();
   const tasklistGuidGroups = /* @__PURE__ */ new Map();
   for (const bot of healthyBots) {
@@ -132195,6 +132536,8 @@ async function runV2Mode({
     let taskHandleClaim;
     let taskHandleClaimedLookup;
     let taskHandleClaimGuidLookup;
+    let taskGuidClaimedByOtherBot;
+    let taskHandleClaimCommentPending;
     let taskHandleCandidatesLookup;
     let taskCommentPoller;
     let stallDetector;
@@ -132224,6 +132567,7 @@ async function runV2Mode({
           effectiveTaskHandleTasklistGuid = guid;
         }
         const taskHandleStore = await TaskHandleStore.load(resolveTaskHandlesPath(bot.id));
+        allTaskHandleStores.push({ botId: bot.id, store: taskHandleStore });
         taskHandleLifecycle = (patch) => applyTaskHandleWriteback(patch, { store: taskHandleStore, client: taskListClient });
         taskHandleClaim = async (patch) => {
           const result = await taskHandleStore.claim(patch);
@@ -132235,6 +132579,8 @@ async function runV2Mode({
         };
         taskHandleClaimedLookup = (threadId) => taskHandleStore.get(threadId) !== void 0;
         taskHandleClaimGuidLookup = (threadId) => taskHandleStore.get(threadId)?.taskGuid;
+        taskGuidClaimedByOtherBot = (guid2) => allTaskHandleStores.some((e) => e.botId !== bot.id && e.store.list().some((r) => r.taskGuid === guid2));
+        taskHandleClaimCommentPending = (threadId) => taskHandleStore.get(threadId)?.claimCommentPending === true;
         if (guid) {
           const group = tasklistGuidGroups.get(guid) ?? { client: taskListClient, clientOwnerBotId: bot.id, bots: [] };
           group.bots.push({ botId: bot.id, sessionStore, taskHandleStore });
@@ -132297,6 +132643,9 @@ async function runV2Mode({
               // window — "did their turn genuinely finish", not "did it start
               // or get queued". See stallDetector.ts's module doc revision 3.
               getPeerLastActiveTs: (peerBotId, threadId) => handlersByBotId.get(peerBotId)?.getThreadLastActiveTs(threadId),
+              // v4.2 revision 5: the peer's most recent finished-turn OUTCOME —
+              // a failed finish must not resolve a handoff (see stallDetector.ts).
+              getPeerLastTurnOutcome: (peerBotId, threadId) => handlersByBotId.get(peerBotId)?.getThreadLastOutcome(threadId),
               // v3.3 due-date stall detection (docs/task-handle.md §14): free
               // read of TasklistPoller's own per-guid `due` observation — same
               // "populated after, read lazily" closure trick as
@@ -132357,7 +132706,8 @@ async function runV2Mode({
     let codexPool;
     let claudePool;
     let runnerKey;
-    if (bot.warmProcess && bot.backend === "codex") {
+    const warmProcessOn = effectiveWarmProcess(bot);
+    if (warmProcessOn && bot.backend === "codex") {
       const pidFilePath = path19.join(botDir, "warm-codex.pid");
       try {
         await reapOrphanedWarmProcess(pidFilePath);
@@ -132372,7 +132722,8 @@ async function runV2Mode({
       });
       runnerKey = `codex-pool:${bot.id}`;
       registerRunner(runnerKey, () => codexPool);
-    } else if (bot.warmProcess && bot.backend === "claude") {
+      if (effectivePrewarmProcess(bot)) codexPool.prewarm();
+    } else if (warmProcessOn && bot.backend === "claude") {
       const pidListFilePath = path19.join(botDir, "warm-claude.pids.json");
       try {
         await reapOrphanedWarmClaudeProcesses(pidListFilePath);
@@ -132389,6 +132740,18 @@ async function runV2Mode({
       });
       runnerKey = `claude-pool:${bot.id}`;
       registerRunner(runnerKey, () => claudePool);
+      if (effectivePrewarmProcess(bot) && bot.runtime === "agent_workspace" && agentWorkspacePath) {
+        claudePool.prewarm({
+          cwd: agentWorkspacePath,
+          model: bot.model,
+          effort: bot.effort,
+          // Mirrors handler.ts's own default ("bypassPermissions" when
+          // config.json leaves permissions.mode unset). If these two ever
+          // drift the blank's signature just stops matching — fail-safe, and
+          // the pool logs the mismatch on every missed adoption.
+          permissionMode: configJson.permissions.mode ?? "bypassPermissions"
+        });
+      }
     }
     const handler = new BridgeHandler({
       client,
@@ -132445,6 +132808,8 @@ async function runV2Mode({
       taskHandleClaim,
       taskHandleClaimedLookup,
       taskHandleClaimGuidLookup,
+      taskGuidClaimedByOtherBot,
+      taskHandleClaimCommentPending,
       taskHandleCandidatesLookup
     });
     handlersByBotId.set(bot.id, handler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkway",
-  "version": "0.3.42",
+  "version": "0.3.44",
   "description": "Thin bridge: Feishu thread to local Claude Code CLI",
   "license": "MIT",
   "author": "Chuck Wu (chuckwu0)",