larkway 0.3.42 → 0.3.43

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.43**
 
 ---
 

package/README.zh.md

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

package/dist/cli/index.js

@@ -126104,24 +126104,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

@@ -119390,9 +119390,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 +119535,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 +119590,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 +119777,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 +122162,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();
@@ -122498,6 +122525,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 +122551,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 +122594,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 +122611,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);
@@ -122626,6 +122684,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 +123071,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 {
@@ -123114,6 +123198,7 @@ var BridgeHandler = class {
           const prompt = await renderPrompt({
             parsed,
             isNewThread: currentIsNewThread,
+            queuedFollowups,
             conventions: {
               worktreePath,
               runtime: conventions.runtime,
@@ -127039,24 +127124,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 +127172,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 +128452,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 +128487,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 +128512,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 +128576,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 +128608,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 +128658,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 +128813,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 +128907,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 +128974,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 +129052,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 +129672,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();
@@ -132357,7 +132624,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 +132640,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 +132658,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,

package/package.json

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