@modelzen/feishu-codex-bridge 0.3.9 → 0.3.11

package/dist/cli.js

@@ -1189,6 +1189,14 @@ ${rule}`);
 // src/bot/bridge.ts
 import { createLarkChannel, Domain } from "@larksuiteoapi/node-sdk";
 
+// src/agent/types.ts
+function isGoalTerminal(status) {
+  return status === "complete" || status === "budgetLimited" || status === "usageLimited" || status === "blocked";
+}
+function isGoalSuccess(status) {
+  return status === "complete";
+}
+
 // src/agent/codex-appserver/app-server-client.ts
 var AsyncQueue = class {
   items = [];
@@ -1252,7 +1260,11 @@ var AppServerClient = class {
     child.on("error", (err) => this.failAllPending(err));
     await this.request("initialize", {
       clientInfo: { name: this.opts.clientName ?? "feishu-codex-bridge", version: "0.0.1" },
-      capabilities: null
+      // experimentalApi opts into experimental JSON-RPC methods + fields — REQUIRED
+      // for the goal RPCs (thread/goal/set|get|clear). Verified against codex 0.139:
+      // without it, thread/goal/set is rejected. The `goals` feature itself is
+      // stable+on by default there, so no experimentalFeature/enablement/set needed.
+      capabilities: { experimentalApi: true, requestAttestation: false }
     });
     this.notify("initialized");
   }
@@ -1390,6 +1402,18 @@ function mapNotification(n) {
       return { type: "context_compacted" };
     case "turn/completed":
       return { type: "done", turnId: n.params.turn.id };
+    case "thread/goal/updated": {
+      const g = n.params.goal;
+      return {
+        type: "goal_update",
+        status: g.status,
+        objective: g.objective,
+        tokensUsed: g.tokensUsed,
+        timeUsedSeconds: g.timeUsedSeconds,
+        tokenBudget: g.tokenBudget
+      };
+    }
+    // thread/goal/cleared — we clear goals ourselves; nothing to surface.
     case "error":
       return { type: "error", message: n.params.error.message, willRetry: n.params.willRetry };
     default:
@@ -1553,6 +1577,64 @@ var CodexThread = class {
     }
     return { events: gen(), turnId: () => self.currentTurnId };
   }
+  runGoal(objective) {
+    const self = this;
+    this.currentTurnId = void 0;
+    async function* gen() {
+      await self.client.request("thread/goal/clear", { threadId: self.codexThreadId }).catch(() => void 0);
+      let setError;
+      const setFailed = new Promise((resolve7) => {
+        self.client.request("thread/goal/set", { threadId: self.codexThreadId, objective }).then(void 0, (err) => {
+          setError = err instanceof Error ? err : new Error(String(err));
+          log.fail("agent", setError, { phase: "thread/goal/set" });
+          resolve7("set-failed");
+        });
+      });
+      const stream2 = self.client.stream()[Symbol.asyncIterator]();
+      let armed = false;
+      let turnActive = false;
+      let goalDone = false;
+      while (true) {
+        const step = await Promise.race([stream2.next(), setFailed]);
+        if (step === "set-failed") {
+          yield { type: "error", message: setError?.message ?? "thread/goal/set \u8BF7\u6C42\u5931\u8D25", willRetry: false };
+          return;
+        }
+        if (step.done) return;
+        const ev = mapNotification(step.value);
+        if (!ev) continue;
+        if (ev.type === "turn_started") {
+          self.currentTurnId = ev.turnId;
+          armed = true;
+          turnActive = true;
+          yield ev;
+          continue;
+        }
+        if (ev.type === "done") {
+          turnActive = false;
+          yield ev;
+          if (goalDone) return;
+          continue;
+        }
+        if (ev.type === "goal_update") {
+          if (ev.objective !== objective) continue;
+          if (ev.status === "active" || ev.status === "paused") armed = true;
+          yield ev;
+          if (armed && isGoalTerminal(ev.status)) {
+            if (turnActive) goalDone = true;
+            else return;
+          }
+          continue;
+        }
+        yield ev;
+        if (ev.type === "error" && !ev.willRetry) return;
+      }
+    }
+    return { events: gen(), turnId: () => self.currentTurnId };
+  }
+  async clearGoal() {
+    await this.client.request("thread/goal/clear", { threadId: this.codexThreadId });
+  }
   async steer(input2, expectedTurnId) {
     await this.client.request("turn/steer", {
       threadId: this.codexThreadId,
@@ -2789,7 +2871,9 @@ function gaugeEl(state) {
   return state.usage ? runCardGauge(state.usage.used, state.usage.window) : null;
 }
 var RC = {
-  stop: "run.stop"
+  stop: "run.stop",
+  /** goal-only: clear the goal but let the in-flight turn finish (no auto-continue). */
+  endGoal: "goal.end"
 };
 var ANSWER_EID = "answer";
 var REASONING_MAX = 1500;
@@ -2819,7 +2903,21 @@ function renderRunning(state, rc) {
   const answer = textParts.join("\n\n");
   if (answer) elements.push(mdStream(answer, ANSWER_EID));
   if (state.footer) elements.push(footerStatus(state.footer));
-  if (rc.cardKey) elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")]));
+  if (rc.cardKey && rc.goalControls) {
+    if (rc.goalEnding) {
+      elements.push(noteMd("_\u{1F3AF} \u76EE\u6807\u5DF2\u89E3\u9664\uFF0C\u672C\u8F6E\u8F93\u51FA\u5B8C\u6210\u540E\u505C\u6B62_"));
+      elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")]));
+    } else {
+      elements.push(
+        actions([
+          button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger"),
+          button("\u{1F3AF} \u7ED3\u675F\u76EE\u6807", { a: RC.endGoal, m: rc.cardKey }, "default")
+        ])
+      );
+    }
+  } else if (rc.cardKey && !rc.hideStop) {
+    elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")]));
+  }
   const gauge = gaugeEl(state);
   if (gauge) elements.push(gauge);
   return elements;
@@ -2969,6 +3067,46 @@ function truncate4(s, n) {
   return s.length > n ? `${s.slice(0, n)}\u2026` : s;
 }
 
+// src/card/goal-card.ts
+function fmtTokens(n) {
+  return Math.max(0, Math.round(n)).toLocaleString("en-US");
+}
+function fmtDuration(seconds) {
+  const s = Math.max(0, Math.round(seconds));
+  if (s < 60) return `\u7EA6 ${s} \u79D2`;
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  if (m < 60) return rem ? `\u7EA6 ${m} \u5206 ${rem} \u79D2` : `\u7EA6 ${m} \u5206`;
+  const h = Math.floor(m / 60);
+  const mm = m % 60;
+  return mm ? `\u7EA6 ${h} \u65F6 ${mm} \u5206` : `\u7EA6 ${h} \u65F6`;
+}
+var ABNORMAL_REASON = {
+  budgetLimited: "Token \u9884\u7B97\u7528\u5C3D",
+  usageLimited: "\u8D26\u53F7\u7528\u91CF\u989D\u5EA6\u7528\u5C3D",
+  blocked: "\u88AB\u963B\u585E\uFF0C\u9700\u4EBA\u5DE5\u4ECB\u5165",
+  paused: "\u5DF2\u6682\u505C",
+  timeout: "\u8FD0\u884C\u8D85\u8FC7\u65F6\u957F\u4E0A\u9650\u88AB\u4E2D\u6B62",
+  error: "\u8FD0\u884C\u51FA\u9519"
+};
+function buildGoalDoneCard(d) {
+  const ok = isGoalSuccess(d.status);
+  const elements = [
+    md(d.objective.trim() || "\uFF08\u65E0\u76EE\u6807\u63CF\u8FF0\uFF09"),
+    hr(),
+    note(`\u7528\u91CF\u3000${fmtTokens(d.tokensUsed)} tokens`),
+    note(`\u8017\u65F6\u3000${fmtDuration(d.timeUsedSeconds)}`)
+  ];
+  if (!ok) {
+    const reason = d.errorMessage?.trim() || ABNORMAL_REASON[d.status] || `\u72B6\u6001\uFF1A${d.status}`;
+    elements.push(note(`\u539F\u56E0\u3000${reason}`));
+  }
+  return card(elements, {
+    header: ok ? { title: "\u{1F3AF} \u76EE\u6807\u5DF2\u5B8C\u6210", template: "green" } : { title: "\u{1F3AF} \u76EE\u6807\u5DF2\u4E2D\u6B62", template: "orange" },
+    summary: ok ? "\u76EE\u6807\u5DF2\u5B8C\u6210" : "\u76EE\u6807\u5DF2\u4E2D\u6B62"
+  });
+}
+
 // src/card/run-card-stream.ts
 var STREAM_THROTTLE_MS = 150;
 var RunCardStream = class {
@@ -6318,6 +6456,11 @@ function selectValue(formValue, name) {
 function asTier(v) {
   return v === "qa" || v === "write" || v === "full" ? v : void 0;
 }
+function parseGoalTrigger(text) {
+  if (!/(^|\s)\/goal(?=\s|$)/i.test(text)) return null;
+  const objective = text.replace(/(^|\s)\/goal(?=\s|$)/gi, " ").replace(/\s+/g, " ").trim();
+  return objective.length > 0 ? objective : null;
+}
 function createOrchestrator(channel, cfg, fallbackCwd) {
   const backend = createBackend();
   const sessions = /* @__PURE__ */ new Map();
@@ -6413,6 +6556,7 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     }
     const text = msg.content.trim();
     const cmd = parseCommand(text);
+    const goalObjective = parseGoalTrigger(text);
     if ((project?.kind ?? "multi") === "single") {
       if (cmd === "help") {
         await postHelpCard(msg, "single", false, project);
@@ -6435,6 +6579,11 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
         await postContextCard(msg, ts.sessionKey, false);
         return;
       }
+      if (goalObjective) {
+        void addReaction(msg.messageId, "OKR");
+        startReservedRun(msg, goalObjective, ts.sessionKey, true, project, ts, void 0, void 0, void 0, true);
+        return;
+      }
       handleTurn(msg, text, ts.sessionKey, true, project, ts);
       return;
     }
@@ -6456,6 +6605,11 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
         await postContextCard(msg, ts.sessionKey, true);
         return;
       }
+      if (goalObjective) {
+        void addReaction(msg.messageId, "OKR");
+        startReservedRun(msg, goalObjective, ts.sessionKey, false, project, ts, void 0, void 0, void 0, true);
+        return;
+      }
       handleTurn(msg, text, ts.sessionKey, false, project, ts);
       return;
     }
@@ -6475,6 +6629,11 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
       await channel.send(msg.chatId, { markdown: `\`/${cmd}\` \u9700\u8981\u5728\u8BDD\u9898\u91CC\u4F7F\u7528\uFF08\u5148 @\u6211 \u5F00\u4E2A\u8BDD\u9898\uFF09\u3002` }, { replyTo: msg.messageId }).catch(() => void 0);
       return;
     }
+    if (goalObjective) {
+      void addReaction(msg.messageId, "OKR");
+      startTopicDirectly(msg, goalObjective, project, true);
+      return;
+    }
     startTopicDirectly(msg, text, project);
   };
   function parseCommand(text) {
@@ -6486,7 +6645,8 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     if (!(project.noMention ?? defaultNoMention(project))) return false;
     if (msg.mentionAll || msg.mentions.some((m) => !m.isBot)) return false;
     if ((project.kind ?? "multi") === "single") return true;
-    return Boolean(msg.threadId) || parseCommand(msg.content.trim()) !== null;
+    const content = msg.content.trim();
+    return Boolean(msg.threadId) || parseCommand(content) !== null || parseGoalTrigger(content) !== null;
   }
   async function denyAdminCommand(msg, cmd) {
     await channel.send(msg.chatId, { markdown: `\u26A0\uFE0F \`/${cmd}\` \u4EC5 bot \u7BA1\u7406\u5458\u53EF\u7528\u3002` }, { replyTo: msg.messageId }).catch(() => void 0);
@@ -6558,9 +6718,13 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     }
     startReservedRun(msg, text, sessionKey, flat, project, perm);
   }
-  function startReservedRun(msg, text, sessionKey, flat, project, perm, preloadedImages, preIngested, summaryText2) {
+  function startReservedRun(msg, text, sessionKey, flat, project, perm, preloadedImages, preIngested, summaryText2, goal) {
     const existing = active.get(sessionKey);
     if (existing) {
+      if (goal) {
+        void channel.send(msg.chatId, { markdown: "\u5F53\u524D\u4F1A\u8BDD\u6709\u4EFB\u52A1\u5728\u8DD1\uFF0C\u8BF7\u7B49\u5B83\u7ED3\u675F\u540E\u518D\u53D1 `/goal`\u3002" }, { replyTo: msg.messageId, replyInThread: !flat }).catch(() => void 0);
+        return;
+      }
       existing.queue.push({ text, images: preloadedImages });
       log.info("intake", "queued", { depth: existing.queue.length });
       return;
@@ -6568,7 +6732,7 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     const reserved = { queue: [], requesterOpenId: msg.senderId };
     active.set(sessionKey, reserved);
     void withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
-      const reaction = runReaction(msg.messageId, !sema.hasFree());
+      const reaction = goal ? void 0 : runReaction(msg.messageId, !sema.hasFree());
       try {
         const images = preloadedImages ?? (messageHasImages(msg) ? await collectInboundImages(channel, msg) : void 0);
         let firstText = preIngested ? text : await ingestContext(msg, text);
@@ -6599,7 +6763,7 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
             updatedAt: Date.now()
           });
         }
-        if (msg.threadId && (codexEmpty || prior?.lastSeenAt !== void 0)) {
+        if (!goal && msg.threadId && (codexEmpty || prior?.lastSeenAt !== void 0)) {
           const history = await fetchThreadContext(channel, msg.threadId, {
             sinceTime: codexEmpty ? 0 : prior?.lastSeenAt ?? 0,
             excludeMessageId: msg.messageId
@@ -6608,23 +6772,22 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
         }
         if (!neverSeen) void patchSession(sessionKey, { lastSeenAt: msg.createTime }).catch(() => void 0);
         reserved.thread = thread;
-        await launchRun(
-          {
-            chatId: msg.chatId,
-            replyTo: msg.messageId,
-            replyInThread: !flat,
-            flat,
-            thread,
-            firstText,
-            images,
-            knownThreadId: sessionKey,
-            requesterOpenId: msg.senderId
-          },
-          reaction
-        );
+        const launchOpts = {
+          chatId: msg.chatId,
+          replyTo: msg.messageId,
+          replyInThread: !flat,
+          flat,
+          thread,
+          firstText,
+          images,
+          knownThreadId: sessionKey,
+          requesterOpenId: msg.senderId
+        };
+        if (goal) await launchGoalRun(launchOpts);
+        else await launchRun(launchOpts, reaction);
       } catch (err) {
         active.delete(sessionKey);
-        reaction.done();
+        reaction?.done();
         log.fail("intake", err);
         await channel.send(msg.chatId, { markdown: `\u274C ${err instanceof Error ? err.message : String(err)}` }, { replyTo: msg.messageId, replyInThread: !flat }).catch(() => void 0);
       }
@@ -6676,9 +6839,9 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     }
     if (closed) log.info("console", "tier-evict", { chatId, closed });
   }
-  function startTopicDirectly(msg, text, project) {
+  function startTopicDirectly(msg, text, project, goal) {
     void withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
-      const reaction = runReaction(msg.messageId, !sema.hasFree());
+      const reaction = goal ? void 0 : runReaction(msg.messageId, !sema.hasFree());
       const cwd = project?.cwd ?? fallbackCwd;
       const perm = turnPerm(project, msg.senderId);
       if (project) void refreshBranch(channel, project).catch(() => void 0);
@@ -6687,33 +6850,36 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
       try {
         thread = await backend.startThread({ cwd, model, effort, mode: perm.mode, network: perm.network, autoCompact: perm.autoCompact });
       } catch (err) {
-        reaction.done();
+        reaction?.done();
         log.fail("card", err, { phase: "start-topic" });
         await channel.send(msg.chatId, { markdown: `\u274C \u542F\u52A8\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}` }, { replyTo: msg.messageId }).catch(() => void 0);
         return;
       }
       const images = messageHasImages(msg) ? await collectInboundImages(channel, msg) : void 0;
       const firstText = await ingestContext(msg, text) || "\u4F60\u597D\uFF0C\u6211\u4EEC\u5F00\u59CB\u5427\u3002";
-      log.info("card", "start", { project: project?.name ?? "(unregistered)", model, effort, images: images?.length ?? 0 });
-      await launchRun(
-        {
-          chatId: msg.chatId,
-          replyTo: msg.messageId,
-          replyInThread: true,
-          thread,
-          firstText,
-          images,
-          model,
-          effort,
-          cwd,
-          summary: stripFileTokens(text).slice(0, 80) || "(\u7A7A)",
-          requesterOpenId: msg.senderId,
-          roleSuffix: perm.roleSuffix
-        },
-        reaction,
-        () => reaction.done()
-        // topic created → ✅ DONE (don't wait for the reply)
-      );
+      log.info("card", "start", { project: project?.name ?? "(unregistered)", model, effort, images: images?.length ?? 0, goal: Boolean(goal) });
+      const launchOpts = {
+        chatId: msg.chatId,
+        replyTo: msg.messageId,
+        replyInThread: true,
+        thread,
+        firstText,
+        images,
+        model,
+        effort,
+        cwd,
+        summary: stripFileTokens(text).slice(0, 80) || "(\u7A7A)",
+        requesterOpenId: msg.senderId,
+        roleSuffix: perm.roleSuffix
+      };
+      if (goal) await launchGoalRun(launchOpts);
+      else
+        await launchRun(
+          launchOpts,
+          reaction,
+          () => reaction?.done()
+          // topic created → ✅ DONE (don't wait for the reply)
+        );
     }).catch((err) => log.fail("intake", err));
   }
   async function postResumeCard(msg) {
@@ -6840,6 +7006,7 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
   }
   const dispatcher = new CardDispatcher(channel, cfg);
   const PENDING_TTL_MS = 30 * 6e4;
+  const GOAL_IDLE_MS = 30 * 6e4;
   const CARD_SETTLE_MS = 500;
   const settleUpdate = (msgId, c, fallbackChatId) => {
     const armedAt = Date.now();
@@ -6921,6 +7088,12 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     if (!st || !runOwnerOrAdmin(evt, st.requesterOpenId)) return;
     st.interrupt?.();
     log.info("card", "action", { actionId: "run.stop", stopped: Boolean(st.interrupt) });
+  }).on(RC.endGoal, ({ evt, value }) => {
+    const key = typeof value.m === "string" ? value.m : evt.messageId;
+    const st = runsByCard.get(key);
+    if (!st || !runOwnerOrAdmin(evt, st.requesterOpenId)) return;
+    st.endGoal?.();
+    log.info("card", "action", { actionId: "goal.end", ended: Boolean(st.endGoal) });
   });
   const dmAdmin = (openId) => isAdmin(cfg, openId ?? "");
   const patch = (evt, c) => settleUpdate(evt.messageId, c, evt.chatId);
@@ -7633,6 +7806,214 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
       release();
     }
   }
+  async function launchGoalRun(opts) {
+    const objective = opts.firstText;
+    const release = await sema.acquire();
+    let activeKey = opts.knownThreadId ?? `pending:${opts.replyTo}`;
+    let topicThreadId = opts.knownThreadId;
+    const state = active.get(activeKey) ?? { queue: [], requesterOpenId: opts.requesterOpenId };
+    state.thread = opts.thread;
+    if (opts.requesterOpenId) state.requesterOpenId = opts.requesterOpenId;
+    active.set(activeKey, state);
+    if (opts.knownThreadId) sessions.set(opts.knownThreadId, opts.thread);
+    const persist = async (threadId) => {
+      await upsertSession({
+        threadId,
+        chatId: opts.chatId,
+        cwd: opts.cwd ?? fallbackCwd,
+        codexThreadId: opts.thread.codexThreadId,
+        model: opts.model,
+        effort: opts.effort,
+        summary: opts.summary ?? objective.slice(0, 80),
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      }).catch(() => void 0);
+    };
+    let cur = null;
+    let replyTo = opts.replyTo;
+    let replyInThread = opts.flat ? false : opts.replyInThread ?? Boolean(opts.knownThreadId);
+    const adoptThreadId = async (messageId, card2) => {
+      if (activeKey.startsWith("pending:")) {
+        const tid = await getThreadId(channel, messageId);
+        if (tid) {
+          const key = opts.roleSuffix ? `${tid}#${opts.roleSuffix}` : tid;
+          active.delete(activeKey);
+          active.set(key, state);
+          sessions.set(key, opts.thread);
+          activeKey = key;
+          topicThreadId = key;
+          card2.threadId = key;
+          await persist(key);
+        }
+      } else {
+        topicThreadId = activeKey;
+        card2.threadId = activeKey;
+      }
+    };
+    const promoteCard = (msgId, card2) => {
+      if (!topicThreadId) return;
+      const prev = lastRunCard.get(topicThreadId);
+      if (prev && prev !== msgId) {
+        const prevState = runCards.get(prev);
+        const prevStream = runStreams.get(prev);
+        if (prevState && prevStream) void prevStream.updateCard(channel, buildRunCardPlain(prevState));
+        runCards.delete(prev);
+        runStreams.delete(prev);
+      }
+      lastRunCard.set(topicThreadId, msgId);
+      runCards.set(msgId, card2);
+    };
+    const finalizeCard = async (ctx) => {
+      if (!ctx || !ctx.stream || !ctx.cardMsgId) return;
+      await ctx.stream.drain();
+      ctx.render.finalize();
+      ctx.rc.rs = ctx.render.snapshot();
+      await ctx.stream.updateCard(channel, buildRunCard(ctx.rc));
+      runsByCard.delete(ctx.cardMsgId);
+      promoteCard(ctx.cardMsgId, ctx.rc);
+    };
+    const startTurn = () => {
+      const render = new RunRender();
+      render.showTools = getShowToolCalls(cfg);
+      const rc = { rs: render.snapshot(), requesterOpenId: opts.requesterOpenId, showTools: render.showTools, goalControls: true };
+      return { render, rc, stream: null, cardMsgId: null };
+    };
+    const ensureCard = async (ctx) => {
+      if (ctx.stream) return;
+      const stream2 = new RunCardStream();
+      const cardMsgId = await stream2.create(channel, opts.chatId, buildRunCard(ctx.rc), { replyTo, replyInThread });
+      ctx.rc.cardKey = cardMsgId;
+      ctx.stream = stream2;
+      ctx.cardMsgId = cardMsgId;
+      runsByCard.set(cardMsgId, state);
+      runStreams.set(cardMsgId, stream2);
+      await adoptThreadId(cardMsgId, ctx.rc);
+      replyTo = cardMsgId;
+      replyInThread = !opts.flat;
+    };
+    let lastStatus = "active";
+    let goalTokens = 0;
+    let goalSeconds = 0;
+    let goalErrorMsg;
+    let interrupted = false;
+    let goalEnded = false;
+    let idledOut = false;
+    let resolveStop;
+    let resolveEnd;
+    const stopSignal = new Promise((res) => {
+      resolveStop = res;
+    });
+    const endSignal = new Promise((res) => {
+      resolveEnd = res;
+    });
+    try {
+      const run = opts.thread.runGoal(objective);
+      state.run = run;
+      state.interrupt = () => {
+        if (interrupted) return;
+        interrupted = true;
+        void opts.thread.clearGoal().catch(() => void 0);
+        resolveStop();
+      };
+      state.endGoal = () => {
+        if (goalEnded || interrupted) return;
+        goalEnded = true;
+        void opts.thread.clearGoal().catch(() => void 0);
+        if (cur) {
+          cur.rc.goalEnding = true;
+          if (cur.stream) {
+            cur.rc.rs = cur.render.snapshot();
+            cur.stream.streamCoalesced(channel, buildRunCard(cur.rc), ANSWER_EID);
+          }
+        } else {
+          resolveEnd();
+        }
+      };
+      const stop = Promise.race([stopSignal, endSignal]);
+      const guarded = withIdleTimeout(run.events, GOAL_IDLE_MS, () => {
+        idledOut = true;
+      }, stop);
+      for await (const ev of guarded) {
+        if (ev.type === "goal_update") {
+          lastStatus = ev.status;
+          goalTokens = ev.tokensUsed;
+          goalSeconds = ev.timeUsedSeconds;
+          continue;
+        }
+        if (ev.type === "context_usage") {
+          if (topicThreadId) lastUsage.set(topicThreadId, { used: ev.usedTokens, window: ev.contextWindow });
+          if (cur) {
+            cur.render.apply(ev);
+            cur.rc.rs = cur.render.snapshot();
+          }
+          continue;
+        }
+        if (ev.type === "context_compacted") {
+          void sendManagedCard(channel, opts.chatId, buildAutoCompactCard(), cur?.cardMsgId ?? void 0, !opts.flat).catch(
+            (err) => log.fail("card", err, { phase: "auto-compact-notice" })
+          );
+          continue;
+        }
+        if (ev.type === "turn_started") {
+          await finalizeCard(cur);
+          cur = startTurn();
+          continue;
+        }
+        if (ev.type === "done") {
+          if (cur) {
+            cur.render.apply(ev);
+            await finalizeCard(cur);
+            cur = null;
+          }
+          if (goalEnded) break;
+          continue;
+        }
+        if (ev.type === "error") {
+          goalErrorMsg = ev.message;
+          if (!cur) continue;
+        }
+        if (!cur) cur = startTurn();
+        cur.render.apply(ev);
+        if (ev.type === "thinking" || ev.type === "thinking_delta") {
+          if (cur.stream) {
+            cur.rc.rs = cur.render.snapshot();
+            cur.stream.streamCoalesced(channel, buildRunCard(cur.rc), ANSWER_EID);
+          }
+          continue;
+        }
+        await ensureCard(cur);
+        cur.rc.rs = cur.render.snapshot();
+        cur.stream.streamCoalesced(channel, buildRunCard(cur.rc), ANSWER_EID);
+      }
+      if (interrupted && cur) cur.render.interrupt();
+      await finalizeCard(cur);
+      cur = null;
+      await opts.thread.clearGoal().catch(() => void 0);
+      if (!interrupted && !goalEnded) {
+        const status = idledOut ? "timeout" : goalErrorMsg && !isGoalTerminal(lastStatus) ? "error" : lastStatus;
+        await sendManagedCard(
+          channel,
+          opts.chatId,
+          buildGoalDoneCard({ objective, status, tokensUsed: goalTokens, timeUsedSeconds: goalSeconds, errorMessage: goalErrorMsg }),
+          replyTo,
+          !opts.flat
+        ).catch((err) => log.fail("card", err, { phase: "goal-done" }));
+        log.info("card", "goal-final", { status, tokens: goalTokens, seconds: goalSeconds });
+      } else {
+        log.info("card", "goal-final", { status: interrupted ? "interrupted" : "ended", tokens: goalTokens, seconds: goalSeconds });
+      }
+      if (topicThreadId) await patchSession(topicThreadId, { updatedAt: Date.now() }).catch(() => void 0);
+    } catch (err) {
+      log.fail("intake", err);
+      await channel.send(opts.chatId, { markdown: `\u274C ${err instanceof Error ? err.message : String(err)}` }, { replyTo: opts.replyTo, replyInThread: !opts.flat }).catch(() => void 0);
+    } finally {
+      active.delete(activeKey);
+      if (cur?.cardMsgId) runsByCard.delete(cur.cardMsgId);
+      void opts.thread.close().catch(() => void 0);
+      if (topicThreadId) sessions.delete(topicThreadId);
+      release();
+    }
+  }
   const onComment = async (evt) => {
     await withTrace({ chatId: "comment" }, async () => {
       log.info("comment", "enter", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelzen/feishu-codex-bridge",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "Bridge Feishu/Lark messenger with local Codex via app-server (project=group, thread=session)",
   "type": "module",
   "bin": {