larkway 0.3.34 → 0.3.36

package/dist/main.js

@@ -24969,13 +24969,13 @@ var require_lib2 = __commonJS({
       Domain[Domain["Lark"] = 1] = "Lark";
     })(exports.Domain || (exports.Domain = {}));
     exports.LoggerLevel = void 0;
-    (function(LoggerLevel) {
-      LoggerLevel[LoggerLevel["fatal"] = 0] = "fatal";
-      LoggerLevel[LoggerLevel["error"] = 1] = "error";
-      LoggerLevel[LoggerLevel["warn"] = 2] = "warn";
-      LoggerLevel[LoggerLevel["info"] = 3] = "info";
-      LoggerLevel[LoggerLevel["debug"] = 4] = "debug";
-      LoggerLevel[LoggerLevel["trace"] = 5] = "trace";
+    (function(LoggerLevel2) {
+      LoggerLevel2[LoggerLevel2["fatal"] = 0] = "fatal";
+      LoggerLevel2[LoggerLevel2["error"] = 1] = "error";
+      LoggerLevel2[LoggerLevel2["warn"] = 2] = "warn";
+      LoggerLevel2[LoggerLevel2["info"] = 3] = "info";
+      LoggerLevel2[LoggerLevel2["debug"] = 4] = "debug";
+      LoggerLevel2[LoggerLevel2["trace"] = 5] = "trace";
     })(exports.LoggerLevel || (exports.LoggerLevel = {}));
     var CEventType = /* @__PURE__ */ Symbol("event-type");
     var CTenantKey = /* @__PURE__ */ Symbol("tenant-key");
@@ -108498,7 +108498,7 @@ var require_lib2 = __commonJS({
         return this.impl.run(producer);
       }
     };
-    var DEFAULT_THROTTLE_MS = 100;
+    var DEFAULT_THROTTLE_MS2 = 100;
     var DEFAULT_THROTTLE_CHARS = 50;
     var CardStreamControllerImpl = class {
       constructor(sender, to, idType, opts, initial) {
@@ -108512,7 +108512,7 @@ var require_lib2 = __commonJS({
         this._current = initial;
         const cfg = sender.config;
         this.throttle = new Throttle({
-          ms: (_a = cfg.streamThrottleMs) !== null && _a !== void 0 ? _a : DEFAULT_THROTTLE_MS,
+          ms: (_a = cfg.streamThrottleMs) !== null && _a !== void 0 ? _a : DEFAULT_THROTTLE_MS2,
           chars: (_b = cfg.streamThrottleChars) !== null && _b !== void 0 ? _b : DEFAULT_THROTTLE_CHARS
         }, () => this.patch());
       }
@@ -116537,6 +116537,119 @@ var ChannelPostClient = class {
   }
 };
 
+// src/lark/channelCotClient.ts
+var COT_REQUEST_TIMEOUT_MS = 8e3;
+async function withTimeout(p, ms, label) {
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`[channel.cot] ${label} timed out after ${ms}ms`)),
+      ms
+    );
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([p, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function assertOk(res, label) {
+  if (res.code !== void 0 && res.code !== 0) {
+    throw new Error(
+      `[channel.cot] ${label} failed: code=${res.code} msg=${res.msg ?? "<no msg>"}`
+    );
+  }
+}
+var ChannelCotClient = class {
+  resolveChannel;
+  constructor(opts) {
+    this.resolveChannel = opts.resolveChannel;
+  }
+  channel() {
+    const ch = this.resolveChannel();
+    if (!ch) {
+      throw new Error("[channel.cot] outbound called before the Channel SDK connected");
+    }
+    return ch;
+  }
+  /** Every COT call goes through here, so all get the same hard timeout. */
+  request(opts) {
+    return withTimeout(
+      this.channel().rawClient.request(opts),
+      COT_REQUEST_TIMEOUT_MS,
+      `${opts.method} ${opts.url}`
+    );
+  }
+  async create(target) {
+    const receiveIdType = target.threadId ? "thread_id" : "chat_id";
+    const receiveId = target.threadId ?? target.chatId;
+    const res = await this.request({
+      url: "/open-apis/im/v1/message_cot",
+      method: "POST",
+      params: { receive_id_type: receiveIdType },
+      data: {
+        receive_id: receiveId,
+        // origin_message_id only anchors non-thread bubbles; harmless if set,
+        // but omitted for topic threads where the thread id already anchors.
+        ...!target.threadId && target.originMessageId ? { origin_message_id: target.originMessageId } : {}
+      }
+    });
+    assertOk(res, "create");
+    const cotId = stringField(res.data, "cot_id");
+    const messageId = stringField(res.data, "message_id");
+    if (!cotId || !messageId) {
+      throw new Error(
+        `[channel.cot] create returned no cot_id/message_id (${JSON.stringify(res.data ?? {}).slice(0, 200)})`
+      );
+    }
+    return { cotId, messageId };
+  }
+  async update(ref, events) {
+    if (events.length === 0) return;
+    const res = await this.request({
+      url: "/open-apis/im/v1/message_cot",
+      method: "PUT",
+      data: { cot_id: ref.cotId, message_id: ref.messageId, events: [...events] }
+    });
+    assertOk(res, "update");
+  }
+  async complete(ref, reason) {
+    const res = await this.request({
+      url: `/open-apis/im/v1/message_cot/complete/${encodeURIComponent(ref.cotId)}`,
+      method: "POST",
+      params: { message_id: ref.messageId, reason }
+    });
+    assertOk(res, "complete");
+  }
+  async resolveThreadId(messageId) {
+    try {
+      const res = await this.request({
+        url: `/open-apis/im/v1/messages/${encodeURIComponent(messageId)}`,
+        method: "GET"
+      });
+      if (res.code !== void 0 && res.code !== 0) return void 0;
+      const items = res.data?.["items"];
+      if (!Array.isArray(items)) return void 0;
+      for (const item of items) {
+        if (item && typeof item === "object") {
+          const threadId = item["thread_id"];
+          if (typeof threadId === "string" && threadId.startsWith("omt_")) {
+            return threadId;
+          }
+        }
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    }
+  }
+};
+function stringField(data, key) {
+  const value = data?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+
 // src/lark/channelClient.ts
 var execFile = promisify(execFileCallback);
 var LEARNED_CHATS_LIMIT = 100;
@@ -116589,13 +116702,13 @@ function arrayField(obj, key) {
   const value = obj[key];
   return Array.isArray(value) ? value : null;
 }
-function stringField(obj, key) {
+function stringField2(obj, key) {
   if (!obj || typeof obj !== "object") return void 0;
   const value = obj[key];
   return typeof value === "string" ? value : void 0;
 }
 function nonEmptyStringField(obj, key) {
-  const value = stringField(obj, key);
+  const value = stringField2(obj, key);
   return value && value.length > 0 ? value : void 0;
 }
 function parseLarkCliMessages(stdout) {
@@ -116809,6 +116922,8 @@ var ChannelClient = class {
   cardKitClient = null;
   /** Lazily built and only requested by main.ts when post outbound gates are configured. */
   postClient = null;
+  /** Lazily built COT (思维链) client; only requested when a bot enables cot != off. */
+  cotClient = null;
   constructor(opts) {
     if (!opts.appId || !opts.appSecret) {
       throw new Error(
@@ -117074,6 +117189,22 @@ var ChannelClient = class {
     }
     return this.cardKitClient;
   }
+  /**
+   * Return an OutboundCotClient bound to this client's channel handle.
+   *
+   * main.ts only calls this when the bot's `cot` config is not "off". The COT
+   * bubble uses the SDK's generic rawClient.request() (tenant token auto-
+   * injected via the same token manager as every other outbound call), so it
+   * adds no auth surface. Resolves the live channel lazily at call time.
+   */
+  outboundCotClient() {
+    if (!this.cotClient) {
+      this.cotClient = new ChannelCotClient({
+        resolveChannel: () => this.channel
+      });
+    }
+    return this.cotClient;
+  }
   /**
    * Return an OutboundPostClient bound to this client's channel handle.
    *
@@ -117377,7 +117508,7 @@ var ChannelClient = class {
         const chats = parseLarkCliMessages(stdout) ?? [];
         fetched += chats.length;
         for (const raw of chats) {
-          const chatId = stringField(raw, "chat_id");
+          const chatId = stringField2(raw, "chat_id");
           if (!chatId?.startsWith("oc_")) continue;
           discoveredChatIds.add(chatId);
           const before = this.recentlySeenChatIds.size;
@@ -117391,7 +117522,7 @@ var ChannelClient = class {
         const hasMore = Boolean(
           (data && typeof data === "object" && data["has_more"]) ?? (parsed && typeof parsed === "object" && parsed["has_more"])
         );
-        pageToken = stringField(data, "page_token") ?? stringField(parsed, "page_token") ?? "";
+        pageToken = stringField2(data, "page_token") ?? stringField2(parsed, "page_token") ?? "";
         if (!hasMore || !pageToken) break;
       }
       if (newlyLearned > 0) {
@@ -118517,7 +118648,7 @@ function senderOpenIdOf(senderId) {
 import fs from "node:fs/promises";
 
 // src/agent/triggerFacts.ts
-function stringField2(value) {
+function stringField3(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function mentionType(raw) {
@@ -118535,9 +118666,9 @@ function mentionType(raw) {
 }
 function deriveTriggerFacts(parsed, isNewThread, larkCliProfile) {
   const raw = parsed.raw;
-  const feishuRootId = stringField2(raw["root_id"]);
-  const feishuThreadId = stringField2(raw["thread_id"]);
-  const chatType = stringField2(raw["chat_type"]) ?? "unknown";
+  const feishuRootId = stringField3(raw["root_id"]);
+  const feishuThreadId = stringField3(raw["thread_id"]);
+  const chatType = stringField3(raw["chat_type"]) ?? "unknown";
   const triggerType = raw["larkway_trigger_type"] === "card_action" ? "card_action" : feishuRootId || !isNewThread ? "topic_continuation" : "top_level_mention";
   const profileFlag = larkCliProfile ? ` --profile ${larkCliProfile}` : "";
   return {
@@ -118546,7 +118677,7 @@ function deriveTriggerFacts(parsed, isNewThread, larkCliProfile) {
     chatType,
     feishuThreadId,
     feishuRootId,
-    createTime: stringField2(raw["create_time"]) ?? parsed.raw.create_time,
+    createTime: stringField3(raw["create_time"]) ?? parsed.raw.create_time,
     rawMessagePointer: `lark-cli api GET /open-apis/im/v1/messages/${parsed.messageId}${profileFlag} --as bot`
   };
 }
@@ -120458,6 +120589,8 @@ async function deleteCardKitFile(worktreePath) {
 var CARDKIT_FINAL_ELEMENT_ID = "final_md";
 var CARDKIT_FOOTER_ELEMENT_ID = "footer_md";
 var CARDKIT_CHOICES_ELEMENT_ID = "choices_slot";
+var CARDKIT_COT_PANEL_ELEMENT_ID = "cot_panel";
+var CARDKIT_COT_INNER_ELEMENT_ID = "cot_inner_md";
 var MAX_CARD_BYTES = 30 * 1024;
 var FINAL_BUDGET_CHARS = 22e3;
 var CHOICE_MARKERS2 = ["A", "B", "C", "D", "E"];
@@ -120472,6 +120605,15 @@ function markdown(content, elementId) {
 function buildCardKitAnswerElement(content = "") {
   return markdown(content, CARDKIT_FINAL_ELEMENT_ID);
 }
+function buildCotPanelElement(opts) {
+  return {
+    tag: "collapsible_panel",
+    element_id: CARDKIT_COT_PANEL_ELEMENT_ID,
+    expanded: opts.expanded,
+    header: { title: { tag: "markdown", content: opts.title } },
+    elements: [markdown(opts.content || "\u2026", CARDKIT_COT_INNER_ELEMENT_ID)]
+  };
+}
 function safeAtMention(target) {
   const id = target.user_id.trim();
   if (!/^[A-Za-z0-9_:-]+$/.test(id)) return "";
@@ -120570,7 +120712,17 @@ function finalMarkdown(opts) {
   return truncateChars([mentionLine, body].filter(Boolean).join("\n\n") || "\u5B8C\u6210\u3002", FINAL_BUDGET_CHARS, "\n\n_\u5185\u5BB9\u8FC7\u957F,\u5DF2\u622A\u65AD\u3002_");
 }
 function buildCardKitFinalCard(opts) {
-  const elements = [buildCardKitAnswerElement(finalMarkdown(opts))];
+  const elements = [];
+  if (opts.cotPanel) {
+    elements.push(
+      buildCotPanelElement({
+        expanded: false,
+        title: opts.cotPanel.title,
+        content: opts.cotPanel.content
+      })
+    );
+  }
+  elements.push(buildCardKitAnswerElement(finalMarkdown(opts)));
   const images = [];
   if (opts.contentBlocks?.length) {
     for (const block of opts.contentBlocks) {
@@ -120607,6 +120759,9 @@ function buildCardKitFinalMarkdown(opts) {
 var DEFAULT_PATCH_INTERVAL_MS = 250;
 var DEFAULT_MAX_PROGRESS_UPDATES = 240;
 var BACKOFF_LADDER_MS = [250, 1e3, 2e3, 5e3];
+var COT_PANEL_BUDGET_CHARS = 4e3;
+var COT_TOOL_ARGS_MAX = 200;
+var COT_TOOL_RESULT_MAX = 1200;
 function idempotencyKey(facts) {
   return deriveCardKitUuid(
     ["reply", facts.botId, facts.threadId, facts.triggerMessageId].join("\0")
@@ -120643,6 +120798,37 @@ function summarizeError(err) {
 function toolStatusText(toolUseCount) {
   return toolUseCount > 0 ? `\u52AA\u529B\u56DE\u7B54\u4E2D... \xB7 \u5DF2\u7528 ${toolUseCount} \u4E2A\u5DE5\u5177` : "\u52AA\u529B\u56DE\u7B54\u4E2D...";
 }
+function clip(value, max) {
+  const text = String(value ?? "");
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function cotBriefToolTitle(name) {
+  return String(name ?? "tool");
+}
+function cotExtractToolResultText(raw) {
+  if (typeof raw !== "object" || raw === null) return "";
+  const message = raw["message"];
+  if (typeof message !== "object" || message === null) return "";
+  const content = message["content"];
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const item of content) {
+    if (typeof item !== "object" || item === null) continue;
+    const block = item;
+    if (block["type"] !== "tool_result") continue;
+    const inner = block["content"];
+    if (typeof inner === "string") parts.push(inner);
+    else if (Array.isArray(inner)) {
+      for (const piece of inner) {
+        if (typeof piece === "object" && piece !== null) {
+          const text = piece["text"];
+          if (typeof text === "string") parts.push(text);
+        }
+      }
+    }
+  }
+  return parts.join("\n").trim();
+}
 var LiveCardKitProgressHandle = class {
   cardId;
   messageId;
@@ -120660,6 +120846,23 @@ var LiveCardKitProgressHandle = class {
   immediatePatchStarted = false;
   metrics = initialLiveMetrics();
   sequence = 0;
+  // COT-in-card (方案 B) state. All no-ops when cotDetail is undefined.
+  cotDetail;
+  onCotPanelCreated;
+  cotBuffer = "";
+  cotTruncated = false;
+  cotPanelCreated = false;
+  cotPendingPatch = null;
+  cotSawThinkingDelta = false;
+  cotToolIndex = 0;
+  cotPendingTools = [];
+  cotErrored = false;
+  // Panel formatting state: keep a tool line and following reasoning on
+  // separate lines, and collapse consecutive same-name tool calls into a count.
+  cotAfterTool = false;
+  cotLastToolName;
+  cotLastToolCount = 0;
+  cotLastToolLineStart = -1;
   constructor(opts) {
     this.cardKitClient = opts.cardKitClient;
     this.cardId = opts.cardId;
@@ -120667,6 +120870,8 @@ var LiveCardKitProgressHandle = class {
     this.idempotencyKey = opts.idempotencyKey;
     this.patchIntervalMs = opts.patchIntervalMs;
     this.maxProgressUpdates = opts.maxProgressUpdates;
+    this.cotDetail = opts.cot?.detail;
+    this.onCotPanelCreated = opts.onCotPanelCreated;
     this.onSequenceCommitted = opts.onSequenceCommitted;
     this.onLiveMetricsChanged = opts.onLiveMetricsChanged;
   }
@@ -120678,6 +120883,7 @@ var LiveCardKitProgressHandle = class {
   }
   handle(event) {
     if (this.closed) return;
+    if (this.cotDetail) this.handleCot(event);
     if (event.type === "tool_use") {
       this.recordToolUse();
       this.patchStatus(toolStatusText(this.metrics.toolUseCount));
@@ -120696,6 +120902,11 @@ var LiveCardKitProgressHandle = class {
     }
   }
   async drain() {
+    if (this.cotPendingPatch) {
+      clearTimeout(this.cotPendingPatch);
+      this.cotPendingPatch = null;
+      await this.cotPatch();
+    }
     if (this.pendingPatch) {
       clearTimeout(this.pendingPatch);
       this.pendingPatch = null;
@@ -120706,6 +120917,7 @@ var LiveCardKitProgressHandle = class {
   async finalize(opts) {
     await this.drain();
     this.closed = true;
+    const finalOpts = { ...opts, cotPanel: this.cotPanelForFinalCard() };
     const finalMarkdown2 = buildCardKitFinalMarkdown(opts);
     if (finalMarkdown2 !== this.answerBuffer) {
       await this.withAnswerElement(finalMarkdown2);
@@ -120723,7 +120935,7 @@ var LiveCardKitProgressHandle = class {
       this.answerBuffer = finalMarkdown2;
     }
     await this.next(
-      (sequence) => this.cardKitClient.updateCardEntity(this.cardId, buildCardKitFinalCard(opts), {
+      (sequence) => this.cardKitClient.updateCardEntity(this.cardId, buildCardKitFinalCard(finalOpts), {
         sequence,
         uuid: sequenceUuid(this.cardId, "final-card", sequence)
       })
@@ -120750,6 +120962,149 @@ var LiveCardKitProgressHandle = class {
       clearTimeout(this.pendingPatch);
       this.pendingPatch = null;
     }
+    if (this.cotPendingPatch) {
+      clearTimeout(this.cotPendingPatch);
+      this.cotPendingPatch = null;
+    }
+  }
+  /** Mark the reasoning panel's turn as errored so its settled title reflects it. */
+  markCotError() {
+    this.cotErrored = true;
+  }
+  // ── COT-in-card (方案 B) ────────────────────────────────────────────────
+  //
+  // Reasoning + tool activity stream into a collapsible_panel that is created
+  // LAZILY on the first such event (a thinking-free short turn shows no panel),
+  // inserted above the answer, then collapsed + retitled inside the final card
+  // (buildCardKitFinalCard, not a separate PATCH — the full-card rebuild would
+  // clobber a PATCH). Every step is best-effort: a panel failure never touches
+  // the answer stream.
+  handleCot(event) {
+    switch (event.type) {
+      case "thinking_delta":
+        this.cotSawThinkingDelta = true;
+        this.cotAppendReasoning(event.text);
+        break;
+      case "thinking_snapshot":
+        if (this.cotSawThinkingDelta) break;
+        this.cotAppendReasoning(event.text);
+        break;
+      case "tool_use":
+        this.cotAppendToolUse(event.toolName, event.toolInput);
+        break;
+      case "tool_result":
+        this.cotAppendToolResult(event.raw);
+        break;
+      default:
+        break;
+    }
+  }
+  cotAppendReasoning(text) {
+    if (this.cotAfterTool) {
+      this.cotAppend("\n");
+      this.cotAfterTool = false;
+    }
+    this.cotLastToolName = void 0;
+    this.cotAppend(text);
+  }
+  cotAppendToolUse(toolName, toolInput) {
+    this.cotPendingTools.push(`tool-${++this.cotToolIndex}`);
+    const name = cotBriefToolTitle(toolName);
+    if (this.cotDetail === "brief" && name === this.cotLastToolName && this.cotLastToolLineStart >= 0 && !this.cotTruncated) {
+      this.cotLastToolCount += 1;
+      this.cotBuffer = this.cotBuffer.slice(0, this.cotLastToolLineStart);
+      this.cotAppend(`
+
+\u{1F527} ${name} \xD7${this.cotLastToolCount}`);
+      this.cotAfterTool = true;
+      return;
+    }
+    this.cotLastToolLineStart = this.cotBuffer.length;
+    this.cotLastToolName = name;
+    this.cotLastToolCount = 1;
+    let line = `
+
+\u{1F527} ${name}`;
+    if (this.cotDetail === "detailed" && toolInput !== void 0 && toolInput !== null) {
+      line += `
+\`\`\`
+${clip(JSON.stringify(toolInput), COT_TOOL_ARGS_MAX)}
+\`\`\``;
+    }
+    this.cotAppend(line);
+    this.cotAfterTool = true;
+  }
+  cotAppendToolResult(raw) {
+    this.cotPendingTools.shift();
+    if (this.cotDetail !== "detailed") return;
+    const text = cotExtractToolResultText(raw);
+    if (!text) return;
+    this.cotAppend(`
+> ${clip(text, COT_TOOL_RESULT_MAX).replace(/\n/g, "\n> ")}`);
+    this.cotAfterTool = true;
+    this.cotLastToolName = void 0;
+  }
+  /** Append to the panel buffer under the hard char budget, then schedule a patch. */
+  cotAppend(text) {
+    if (this.closed || this.cotTruncated) return;
+    const remaining = COT_PANEL_BUDGET_CHARS - this.cotBuffer.length;
+    if (text.length >= remaining) {
+      this.cotBuffer += text.slice(0, Math.max(0, remaining)) + "\n\n_\u2026\u601D\u8003\u5185\u5BB9\u8F83\u957F\uFF0C\u540E\u7EED\u7701\u7565_";
+      this.cotTruncated = true;
+    } else {
+      this.cotBuffer += text;
+    }
+    this.cotSchedulePatch();
+  }
+  cotSchedulePatch() {
+    if (this.cotPendingPatch || this.closed) return;
+    this.cotPendingPatch = setTimeout(() => {
+      this.cotPendingPatch = null;
+      void this.cotPatch();
+    }, this.patchIntervalMs);
+    this.cotPendingPatch.unref?.();
+  }
+  async cotPatch() {
+    if (this.closed || !this.cotBuffer) return;
+    this.inFlight = this.inFlight.then(() => this.cotEnsurePanel()).then(
+      () => this.next(
+        (sequence) => this.cardKitClient.streamElementContent(
+          this.cardId,
+          CARDKIT_COT_INNER_ELEMENT_ID,
+          this.cotBuffer,
+          { sequence, uuid: sequenceUuid(this.cardId, "cot-inner", sequence) }
+        )
+      )
+    ).catch((err) => {
+      console.warn("[cardkit_progress] COT panel patch failed (continuing):", err);
+    });
+    await this.inFlight;
+  }
+  /** Lazily insert the expanded reasoning panel, once, above the answer/footer. */
+  async cotEnsurePanel() {
+    if (this.cotPanelCreated) return;
+    this.cotPanelCreated = true;
+    const target = this.answerElementCreated ? CARDKIT_FINAL_ELEMENT_ID : CARDKIT_FOOTER_ELEMENT_ID;
+    await this.next(
+      (sequence) => this.cardKitClient.createElements(
+        this.cardId,
+        [buildCotPanelElement({ expanded: true, title: "\u601D\u8003\u4E2D\u2026", content: this.cotBuffer || "\u2026" })],
+        {
+          sequence,
+          uuid: sequenceUuid(this.cardId, "cot-panel", sequence),
+          type: "insert_before",
+          targetElementId: target
+        }
+      )
+    );
+    this.onCotPanelCreated?.(CARDKIT_COT_PANEL_ELEMENT_ID);
+  }
+  cotPanelForFinalCard() {
+    if (!this.cotPanelCreated) return void 0;
+    return {
+      title: this.cotErrored ? "\u601D\u8003\u8FC7\u7A0B\uFF08\u672C\u8F6E\u51FA\u9519\uFF09" : "\u601D\u8003\u8FC7\u7A0B",
+      content: this.cotBuffer
+    };
   }
   recordAnswerEvent(type2) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -120922,6 +121277,8 @@ async function createCardKitProgressHandle(opts) {
     idempotencyKey: key,
     patchIntervalMs: opts.patchIntervalMs ?? DEFAULT_PATCH_INTERVAL_MS,
     maxProgressUpdates: opts.maxProgressUpdates ?? DEFAULT_MAX_PROGRESS_UPDATES,
+    cot: opts.cot,
+    onCotPanelCreated: opts.onCotPanelCreated,
     onSequenceCommitted: opts.onSequenceCommitted,
     onLiveMetricsChanged: opts.onLiveMetricsChanged
   });
@@ -120986,6 +121343,369 @@ async function finalizeExistingCardKitCard(opts) {
   return sequence;
 }
 
+// src/bridge/cotProgress.ts
+var DEFAULT_THROTTLE_MS = 600;
+var COT_TOOL_RESULT_MAX2 = 1200;
+var COT_TEXT_MAX = 1200;
+var COT_INPUT_PREVIEW_MAX = 200;
+async function resolveCotTargets(client, hint) {
+  const chatFallback = {
+    chatId: hint.chatId,
+    threadId: void 0,
+    originMessageId: hint.originMessageId
+  };
+  const threadAttempt = (threadId) => ({
+    chatId: hint.chatId,
+    threadId,
+    // origin is omitted on the wire for the thread channel (see
+    // ChannelCotClient.create), so keeping it here is harmless.
+    originMessageId: hint.originMessageId
+  });
+  if (hint.threadId && hint.threadId.startsWith("omt_")) {
+    return [threadAttempt(hint.threadId), chatFallback];
+  }
+  if (hint.threadId && hint.originMessageId) {
+    const omt = await client.resolveThreadId(hint.originMessageId);
+    if (omt && omt.startsWith("omt_")) {
+      return [threadAttempt(omt), chatFallback];
+    }
+  }
+  return [chatFallback];
+}
+function truncate(value, max) {
+  const text = String(value ?? "");
+  return text.length > max ? `${text.slice(0, max)}...` : text;
+}
+function summarizeError2(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.replace(/\s+/g, " ").trim().slice(0, 240) || "unknown error";
+}
+function makeEvent(eventType, content) {
+  return { event_type: eventType, content: JSON.stringify(content), timestamp: Date.now() };
+}
+function payloadSummary(events) {
+  return `payload=[${events.map((e) => `${e.event_type}:${e.content.length}`).join(",")}]`;
+}
+function briefToolTitle(name, input) {
+  if (input && typeof input === "object") {
+    const record = input;
+    const command = record["command"] ?? record["cmd"];
+    if (typeof command === "string" && command.trim()) {
+      return `${name}: ${truncate(command.trim(), 80)}`;
+    }
+    const filePath = record["file_path"] ?? record["path"] ?? record["notebook_path"];
+    if (typeof filePath === "string" && filePath.trim()) {
+      return `${name}: ${truncate(filePath.trim(), 80)}`;
+    }
+  }
+  return name;
+}
+function extractToolResultText(raw) {
+  if (typeof raw !== "object" || raw === null) return "";
+  const message = raw["message"];
+  if (typeof message !== "object" || message === null) return "";
+  const content = message["content"];
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const item of content) {
+    if (typeof item !== "object" || item === null) continue;
+    const block = item;
+    if (block["type"] !== "tool_result") continue;
+    const inner = block["content"];
+    if (typeof inner === "string") {
+      parts.push(inner);
+    } else if (Array.isArray(inner)) {
+      for (const piece of inner) {
+        if (typeof piece === "object" && piece !== null) {
+          const text = piece["text"];
+          if (typeof text === "string") parts.push(text);
+        }
+      }
+    }
+  }
+  return parts.join("\n").trim();
+}
+var LiveCotProgressHandle = class {
+  cotClient;
+  detail;
+  runId;
+  scope;
+  throttleMs;
+  reasoningMessageId;
+  ref;
+  _disabled = false;
+  closed = false;
+  buffer = [];
+  timer;
+  flushing;
+  reasoningOpen = false;
+  sawThinkingDelta = false;
+  toolIndex = 0;
+  /** FIFO of tool_use awaiting a tool_result — larkway events carry no id. */
+  pendingTools = [];
+  constructor(opts) {
+    this.cotClient = opts.cotClient;
+    this.detail = opts.detail;
+    this.runId = opts.runId;
+    this.scope = opts.scope;
+    this.throttleMs = opts.throttleMs;
+    this.reasoningMessageId = `reasoning-${opts.runId}`;
+  }
+  get disabled() {
+    return this._disabled;
+  }
+  async start(target, inputPreview) {
+    try {
+      const attempts = await resolveCotTargets(this.cotClient, target);
+      this.ref = await this.createWithFallback(attempts);
+      if (!this.ref) {
+        this._disabled = true;
+        return;
+      }
+      this.enqueue("RUN_STARTED", {
+        threadId: this.scope,
+        runId: this.runId,
+        input: { query: truncate(inputPreview, COT_INPUT_PREVIEW_MAX) }
+      });
+    } catch (err) {
+      this._disabled = true;
+      console.warn("[cot_progress] create failed; COT disabled for this run:", summarizeError2(err));
+    }
+  }
+  /**
+   * Try each create target in order, returning the first that succeeds. A
+   * failed attempt with a next one queued (i.e. the thread channel, which our
+   * tenant currently rejects) logs an info line and degrades to the next
+   * (chat-level) channel — NOT a disable. Only when the last attempt fails do
+   * we give up (caller disables). Never throws.
+   */
+  async createWithFallback(attempts) {
+    for (let i = 0; i < attempts.length; i++) {
+      const attempt = attempts[i];
+      try {
+        const ref = await this.cotClient.create(attempt);
+        console.info(
+          "[cot_progress] created",
+          `cotId=${ref.cotId}`,
+          `channel=${attempt.threadId ? "thread" : "chat_id"}`,
+          `messageId=${ref.messageId}`,
+          // origin decides in-topic vs group-top anchoring (see handler) — log it
+          // so a future anchoring failure is diagnosable from the create line.
+          `origin=${attempt.originMessageId ?? "none"}`
+        );
+        return ref;
+      } catch (err) {
+        if (i < attempts.length - 1) {
+          console.info(
+            "[cot_progress] thread channel rejected, falling back to chat-level bubble:",
+            summarizeError2(err)
+          );
+        } else {
+          console.warn(
+            "[cot_progress] create failed on all channels; COT disabled for this run:",
+            summarizeError2(err)
+          );
+        }
+      }
+    }
+    return void 0;
+  }
+  handle(event) {
+    if (this._disabled || this.closed || !this.ref) return;
+    switch (event.type) {
+      case "thinking_delta":
+        this.sawThinkingDelta = true;
+        this.openReasoning();
+        this.enqueue("REASONING_MESSAGE_CONTENT", {
+          messageId: this.reasoningMessageId,
+          delta: truncate(event.text, COT_TEXT_MAX)
+        });
+        break;
+      case "thinking_snapshot":
+        if (this.sawThinkingDelta) break;
+        this.openReasoning();
+        this.enqueue("REASONING_MESSAGE_CONTENT", {
+          messageId: this.reasoningMessageId,
+          delta: truncate(event.text, COT_TEXT_MAX)
+        });
+        break;
+      case "tool_use":
+        this.onToolUse(event.toolName, event.toolInput);
+        break;
+      case "tool_result":
+        this.onToolResult(event.raw);
+        break;
+      default:
+        break;
+    }
+  }
+  onToolUse(toolName, toolInput) {
+    this.closeReasoning();
+    const toolCallId = `tool-${this.runId}-${++this.toolIndex}`;
+    this.pendingTools.push({ id: toolCallId, name: toolName, input: toolInput });
+    this.enqueue("TOOL_CALL_START", {
+      toolCallId,
+      toolCallName: toolName,
+      title: briefToolTitle(toolName, toolInput)
+    });
+    if (this.detail === "detailed" && toolInput !== void 0 && toolInput !== null) {
+      this.enqueue("TOOL_CALL_ARGS", {
+        toolCallId,
+        delta: truncate(JSON.stringify(toolInput), COT_TEXT_MAX)
+      });
+    }
+    this.enqueue("TOOL_CALL_END", { toolCallId });
+  }
+  onToolResult(raw) {
+    const pending = this.pendingTools.shift();
+    if (this.detail !== "detailed") return;
+    const toolCallId = pending?.id ?? `tool-${this.runId}-${this.toolIndex}`;
+    const text = extractToolResultText(raw);
+    this.enqueue("TOOL_CALL_RESULT", {
+      toolCallId,
+      content: text ? truncate(text, COT_TOOL_RESULT_MAX2) : "\u5DE5\u5177\u8C03\u7528\u5DF2\u5B8C\u6210"
+    });
+  }
+  openReasoning() {
+    if (this.reasoningOpen) return;
+    this.reasoningOpen = true;
+    this.enqueue("REASONING_START", { messageId: this.reasoningMessageId });
+    this.enqueue("REASONING_MESSAGE_START", {
+      messageId: this.reasoningMessageId,
+      role: "reasoning"
+    });
+  }
+  closeReasoning() {
+    if (!this.reasoningOpen) return;
+    this.reasoningOpen = false;
+    this.enqueue("REASONING_MESSAGE_END", { messageId: this.reasoningMessageId });
+    this.enqueue("REASONING_END", { messageId: this.reasoningMessageId });
+  }
+  /**
+   * Terminal-state invariant: once a bubble exists (ref set), finalize ALWAYS
+   * best-effort tears it down — even if a mid-run PUT already disabled us. A
+   * "half-way self-disable" must never equal "bubble orphaned forever in
+   * 思考中" (the real-machine Round B bug: a mid-stream PUT 400 disabled the
+   * handle, and the old `if (_disabled) return` guards then skipped BOTH
+   * RUN_FINISHED and complete). We stop accepting new stream events, then drive
+   * teardown directly, each step independently try/caught:
+   *   (1) flush the backlog — only while still healthy (a disabled handle
+   *       abandons the backlog and jumps straight to the terminal PUT);
+   *   (2) a MINIMAL, balanced terminal PUT (close any open reasoning block +
+   *       RUN_FINISHED/RUN_ERROR) sent DIRECTLY, bypassing the _disabled gate;
+   *   (3) complete.
+   * Any step failing warns and continues — the bubble must leave 思考中.
+   */
+  async finalize(reason, opts) {
+    if (this.closed || !this.ref) {
+      this.closed = true;
+      return;
+    }
+    this.closed = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    const ref = this.ref;
+    if (!this._disabled) {
+      try {
+        await this.flush();
+      } catch {
+      }
+    }
+    const terminal = this.buildTerminalEvents(reason, opts);
+    try {
+      await this.cotClient.update(ref, terminal);
+    } catch (err) {
+      console.warn(
+        "[cot_progress] terminal update failed (continuing to complete):",
+        summarizeError2(err),
+        payloadSummary(terminal)
+      );
+    }
+    try {
+      await this.cotClient.complete(ref, reason);
+      console.info("[cot_progress] completed", `cotId=${ref.cotId}`, `reason=${reason}`);
+    } catch (err) {
+      console.warn("[cot_progress] complete failed (continuing):", summarizeError2(err));
+    }
+  }
+  /**
+   * The minimal terminal event batch: close any still-open reasoning block so
+   * REASONING_MESSAGE/REASONING START/END stay balanced, then the run's
+   * terminal marker. Tool calls need no closing here — onToolUse always emits
+   * TOOL_CALL_END synchronously alongside START. Built directly (not via the
+   * _disabled-gated enqueue) so it survives a mid-run disable.
+   */
+  buildTerminalEvents(reason, opts) {
+    const events = [];
+    if (this.reasoningOpen) {
+      this.reasoningOpen = false;
+      events.push(makeEvent("REASONING_MESSAGE_END", { messageId: this.reasoningMessageId }));
+      events.push(makeEvent("REASONING_END", { messageId: this.reasoningMessageId }));
+    }
+    if (reason === "error") {
+      events.push(makeEvent("RUN_ERROR", { message: truncate(opts?.message ?? "run failed", COT_TEXT_MAX) }));
+    } else {
+      events.push(makeEvent("RUN_FINISHED", { threadId: this.scope, runId: this.runId, status: "done" }));
+    }
+    return events;
+  }
+  close() {
+    this.closed = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+  }
+  enqueue(eventType, content) {
+    if (this._disabled || !this.ref) return;
+    this.buffer.push(makeEvent(eventType, content));
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    if (this.timer || this.flushing || this._disabled) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.flush();
+    }, this.throttleMs);
+    this.timer.unref?.();
+  }
+  async flush() {
+    if (this._disabled || !this.ref) return;
+    if (this.flushing) {
+      await this.flushing;
+      if (this.buffer.length > 0 && !this._disabled) await this.flush();
+      return;
+    }
+    const events = this.buffer.splice(0);
+    if (events.length === 0) return;
+    this.flushing = this.cotClient.update(this.ref, events).catch((err) => {
+      this._disabled = true;
+      console.warn(
+        "[cot_progress] update failed; COT disabled for this run:",
+        summarizeError2(err),
+        payloadSummary(events)
+      );
+    }).finally(() => {
+      this.flushing = void 0;
+      if (this.buffer.length > 0 && !this._disabled) this.scheduleFlush();
+    });
+    await this.flushing;
+  }
+};
+async function createCotProgressHandle(opts) {
+  const handle = new LiveCotProgressHandle({
+    cotClient: opts.cotClient,
+    detail: opts.detail,
+    runId: opts.runId,
+    scope: opts.scope,
+    throttleMs: opts.throttleMs ?? DEFAULT_THROTTLE_MS
+  });
+  await handle.start(opts.target, opts.inputPreview);
+  return handle;
+}
+
 // src/lark/postContent.ts
 function assertSafeUserId(userId) {
   if (!/^[A-Za-z0-9_:-]+$/.test(userId)) {
@@ -121065,6 +121785,7 @@ function derivePostIdempotencyKey(input) {
 // src/bridge/handler.ts
 var DEFAULT_CARDKIT_RESPONSE_SURFACE_TIMEOUT_MS = 20 * 60 * 1e3;
 var DEFAULT_CARDKIT_IDLE_TIMEOUT_MS = 3 * 60 * 1e3;
+var COT_BUBBLE_CREATE_BUDGET_MS = 3e3;
 function summarizeMentionPolicyRules(rules) {
   const counts = /* @__PURE__ */ new Map();
   for (const rule of rules) {
@@ -121474,6 +122195,9 @@ var BridgeHandler = class {
   async handleOne(event) {
     const settleMessageId = event.message_id;
     let settled = false;
+    let cotPublisher;
+    let bubbleCreate;
+    let cotTurnOutcome = "done";
     const settle = (ok) => {
       if (settled) return;
       settled = true;
@@ -121604,6 +122328,43 @@ var BridgeHandler = class {
             console.warn("[bridge.handler] write CardKit live metrics failed:", err);
           });
         };
+        const cotDetail = this.deps.botConfig?.cot ?? "brief";
+        const cotSurface = this.deps.botConfig?.cotSurface ?? "bubble";
+        const cotCardOption = cotDetail !== "off" && cotSurface === "card" ? { detail: cotDetail } : void 0;
+        const createCotBubble = async (originMessageId) => {
+          if (!(this.deps.cotClient && cotDetail !== "off" && cotSurface === "bubble")) return;
+          if (bubbleCreate) return;
+          bubbleCreate = createCotProgressHandle({
+            cotClient: this.deps.cotClient,
+            detail: cotDetail,
+            runId: messageId,
+            scope: threadId,
+            inputPreview: parsed.text,
+            target: {
+              chatId: parsed.chatId,
+              threadId: typeof parsed.raw.thread_id === "string" && parsed.raw.thread_id ? parsed.raw.thread_id : void 0,
+              originMessageId
+            }
+          });
+          const raced = await Promise.race([
+            bubbleCreate.then((handle) => ({ ready: true, handle })),
+            new Promise((resolve2) => {
+              const t = setTimeout(
+                () => resolve2({ ready: false }),
+                this.deps.cotBubbleCreateBudgetMs ?? COT_BUBBLE_CREATE_BUDGET_MS
+              );
+              t.unref?.();
+            })
+          ]);
+          if (raced.ready) {
+            cotPublisher = raced.handle;
+          } else {
+            void bubbleCreate.then((handle) => {
+              cotPublisher = handle;
+            });
+          }
+        };
+        if (!isNewThread) await createCotBubble(messageId);
         const createCardKitPlaceholder = async () => {
           if (!card && cardKitAvailable && this.deps.cardKitClient) {
             try {
@@ -121617,6 +122378,19 @@ var BridgeHandler = class {
                   triggerMessageId: messageId
                 },
                 initialStatusText: "\u52AA\u529B\u56DE\u7B54\u4E2D...",
+                cot: cotCardOption,
+                onCotPanelCreated: (elementId) => {
+                  void updateCardKitRecord({
+                    elements: {
+                      ...cardKitRecord?.elements ?? {
+                        footer: { elementId: "footer_md" },
+                        final: { elementId: "final_md" }
+                      },
+                      thinking: { elementId }
+                    }
+                  }).catch(() => {
+                  });
+                },
                 onSequenceCommitted: async (sequence) => {
                   await updateCardKitRecord({ status: "streaming", sequence });
                 },
@@ -121887,6 +122661,10 @@ var BridgeHandler = class {
             console.warn("[bridge.handler] mtime fact computation failed (continuing):", err);
           }
         }
+        if (isNewThread) {
+          const anchorMessageId = cardKitProgress?.messageId ?? card?.messageId ?? messageId;
+          await createCotBubble(anchorMessageId);
+        }
         let currentExisting = existing;
         let attempt = 0;
         while (true) {
@@ -122021,6 +122799,7 @@ var BridgeHandler = class {
               }
               if (cardKitProgress) cardKitProgress.handle(ev);
               else if (card) card.handle(ev);
+              if (cotPublisher) cotPublisher.handle(ev);
               if (ev.type === "system_init") {
                 sessionId = ev.sessionId;
               }
@@ -122035,6 +122814,14 @@ var BridgeHandler = class {
               clearInterval(idleWatchdog);
               idleWatchdog = void 0;
             }
+            cotTurnOutcome = interruptedByIdle ? "error" : "done";
+            if (cotPublisher) {
+              void cotPublisher.finalize(
+                interruptedByIdle ? "error" : "done",
+                interruptedByIdle ? { message: "idle timeout" } : void 0
+              ).catch(() => {
+              });
+            }
             if (isAgentWorkspace && result.pooled === true) {
               const sessionPidFile = path10.join(worktreePath, ".larkway", "runner.pid");
               await pidFileWriteSettled;
@@ -122193,6 +122980,7 @@ var BridgeHandler = class {
                 });
               }
               try {
+                if (!success) cardKitProgress.markCotError();
                 await cardKitProgress.finalize({
                   title: baseCardPayload.titleOverride,
                   finalText: baseCardPayload.finalText,
@@ -122341,6 +123129,11 @@ var BridgeHandler = class {
         }
       } catch (err) {
         console.error("[bridge.handler] handleOne failed for thread", threadId, err);
+        cotTurnOutcome = "error";
+        if (cotPublisher) {
+          void cotPublisher.finalize("error", { message: String(err) }).catch(() => {
+          });
+        }
         await this.deps.client.removeProcessingReaction?.(messageId);
         await recordEvent({
           status: "failed",
@@ -122374,6 +123167,7 @@ var BridgeHandler = class {
         };
         if (!card && cardKitProgress) {
           try {
+            cardKitProgress.markCotError();
             await cardKitProgress.finalize({
               finalText: hardFailureText
             });
@@ -122416,6 +123210,11 @@ var BridgeHandler = class {
         }
       }
     } finally {
+      cotPublisher?.close();
+      if (bubbleCreate) {
+        void bubbleCreate.then((handle) => handle.finalize(cotTurnOutcome).catch(() => {
+        }));
+      }
       settle(false);
     }
   }
@@ -125095,9 +125894,9 @@ function writeScalar(state, string, level, iskey, inblock) {
 }
 function blockHeader(string, indentPerLevel) {
   var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : "";
-  var clip = string[string.length - 1] === "\n";
-  var keep = clip && (string[string.length - 2] === "\n" || string === "\n");
-  var chomp = keep ? "+" : clip ? "" : "-";
+  var clip2 = string[string.length - 1] === "\n";
+  var keep = clip2 && (string[string.length - 2] === "\n" || string === "\n");
+  var chomp = keep ? "+" : clip2 ? "" : "-";
   return indentIndicator + chomp + "\n";
 }
 function dropEndingNewline(string) {
@@ -125742,6 +126541,31 @@ var BotConfigSchema = external_exports.object({
    * @default "claude"
    */
   backend: external_exports.string().min(1).default("claude"),
+  /**
+   * COT (思维链) 气泡:把 agent 的 thinking 思考过程 + 工具调用摘要实时推到飞书
+   * 原生的可折叠思维链气泡(与最终答案卡片互不干扰,最终答案永远只走卡片)。
+   *
+   * - "off":完全不调用 message_cot API(零网络、零副作用)。
+   * - "brief"(默认):思考过程 + 工具名摘要。
+   * - "detailed":额外推工具入参(TOOL_CALL_ARGS)与截断后的工具结果。
+   *
+   * message_cot 是无公开文档的 API —— 任何一步失败都会在本次会话内自动降级、
+   * 只记 warn,绝不影响卡片和最终答案(见 src/bridge/cotProgress.ts)。
+   */
+  cot: external_exports.enum(["off", "brief", "detailed"]).default("brief"),
+  /**
+   * COT 展示形态。`cot` 管密度(off/brief/detailed),这个管落点:
+   * - "bubble"(默认):走飞书原生 message_cot 思维链气泡(src/bridge/cotProgress.ts)——
+   *   客户端原生渲染(工具图标列表 + 可折叠头),真机体验最好。已知限制:话题内
+   *   锚定不可用(气泡落群顶层,本租户 thread 通道判死),收尾 bug 已在 main 修复。
+   * - "card":思考过程内嵌进答案卡片里的 collapsible_panel(懒创建、答案上方)。
+   *   ⚠️ 实验选项 —— 2026-07-05 真机实测:飞书客户端**不渲染 collapsible_panel 的
+   *   折叠交互**(API 全 code=0,但面板被拍平成普通文本、无折叠箭头、终态也不可折叠;
+   *   CardKit 无 GET 读回、只能真机人眼验)。故 card 形态目前仅作纯文本内嵌展示用,
+   *   体验不如气泡,不建议作默认。见 memory feishu-message-cot-api。
+   * cot="off" 时本字段无意义(两种形态都不产出)。
+   */
+  cotSurface: external_exports.enum(["card", "bubble"]).default("bubble"),
   /**
    * 话题 ↔ 飞书任务句柄(docs/task-handle.md,v2)。省略此字段不代表关闭,但也
    * 不会触发任何自动建清单——main.ts 在 startup 时只做只读解析(yaml 里的
@@ -126772,6 +127596,9 @@ function* parseLinesMulti(line, answerExtractor = new AnswerChannelExtractor())
         if (block["type"] === "text" && typeof block["text"] === "string") {
           yield* answerExtractor.ingestGrowingSnapshot(block["text"], obj);
           emitted = true;
+        } else if (block["type"] === "thinking" && typeof block["thinking"] === "string") {
+          yield { type: "thinking_snapshot", text: block["thinking"], raw: obj };
+          emitted = true;
         } else if (block["type"] === "tool_use") {
           yield {
             type: "tool_use",
@@ -126799,6 +127626,10 @@ function* parseLinesMulti(line, answerExtractor = new AnswerChannelExtractor())
           yield* answerExtractor.ingestDelta(deltaRecord["text"], obj);
           return;
         }
+        if (streamEvent["type"] === "content_block_delta" && deltaRecord["type"] === "thinking_delta" && typeof deltaRecord["thinking"] === "string") {
+          yield { type: "thinking_delta", text: deltaRecord["thinking"], raw: obj };
+          return;
+        }
       }
     }
     yield { type: "raw", raw: obj };
@@ -127727,7 +128558,10 @@ function buildCodexEnv(botGitIdentity, gitlabToken) {
 }
 function buildCodexCommand(opts, codexBinPath = "codex") {
   void opts;
-  return [codexBinPath, ["app-server", "--stdio"]];
+  return [
+    codexBinPath,
+    ["-c", "model_reasoning_summary=detailed", "app-server", "--stdio"]
+  ];
 }
 function codexThreadSandboxMode(mode) {
   return mode === "ask" ? "read-only" : "danger-full-access";
@@ -127777,6 +128611,16 @@ var CodexAppServerLineParser = class {
       yield* this.answerExtractor.ingestDelta(delta, obj);
       return;
     }
+    if (method === "item/reasoning/summaryTextDelta") {
+      const delta = typeof params?.["delta"] === "string" ? params["delta"] : "";
+      if (delta) yield { type: "thinking_delta", text: delta, raw: obj };
+      return;
+    }
+    if (method === "item/reasoning/summaryPartAdded") {
+      const summaryIndex = typeof params?.["summaryIndex"] === "number" ? params["summaryIndex"] : 0;
+      if (summaryIndex > 0) yield { type: "thinking_delta", text: "\n\n", raw: obj };
+      return;
+    }
     if (method === "item/started") {
       const item = asRecord(params?.["item"]);
       if (item?.["type"] === "commandExecution" && typeof item["command"] === "string") {
@@ -127800,11 +128644,20 @@ var CodexAppServerLineParser = class {
         yield* this.answerExtractor.ingestSnapshot(item["text"], obj);
         return;
       }
+      if (item?.["type"] === "reasoning") {
+        const summary = reasoningSummaryText(item["summary"]);
+        if (summary) yield { type: "thinking_snapshot", text: summary, raw: obj };
+        return;
+      }
       return;
     }
     yield { type: "raw", raw: obj };
   }
 };
+function reasoningSummaryText(summary) {
+  if (!Array.isArray(summary)) return "";
+  return summary.filter((s) => typeof s === "string" && s.length > 0).join("\n\n");
+}
 function asRecord(value) {
   return typeof value === "object" && value !== null ? value : void 0;
 }
@@ -129186,7 +130039,7 @@ function isTaskRequestTimeoutError(err) {
   if (err instanceof TaskApiError && err.cause instanceof TaskRequestTimeoutError) return true;
   return false;
 }
-function withTimeout(promise, ms, label) {
+function withTimeout2(promise, ms, label) {
   let timer;
   const timeout = new Promise((_, reject) => {
     timer = setTimeout(() => reject(new TaskRequestTimeoutError(`${label} timed out after ${ms}ms`)), ms);
@@ -129203,7 +130056,7 @@ var TaskListClient = class {
   }
   /** Single choke point for every outbound call — applies the timeout race uniformly. */
   #request(config, label) {
-    return withTimeout(this.#requester.request(config), this.#timeoutMs, label);
+    return withTimeout2(this.#requester.request(config), this.#timeoutMs, label);
   }
   async getTask(taskGuid) {
     let resp;
@@ -129521,13 +130374,13 @@ function mergeDescriptionSnapshot(original, input) {
   return `${humanPart}${sep}${block}`;
 }
 var FAILURE_COMMENT_MAX_LEN = 500;
-function truncate(text, max) {
+function truncate2(text, max) {
   if (text.length <= max) return text;
   return `${text.slice(0, max)}\u2026(\u622A\u65AD)`;
 }
 function renderFailureComment(failureReason) {
   return `\u26A0\uFE0F \u672C\u8F6E\u6267\u884C\u5931\u8D25
-${truncate(failureReason ?? "\u672A\u77E5\u539F\u56E0", FAILURE_COMMENT_MAX_LEN)}`;
+${truncate2(failureReason ?? "\u672A\u77E5\u539F\u56E0", FAILURE_COMMENT_MAX_LEN)}`;
 }
 async function applyTaskHandleWriteback(patch, deps) {
   try {
@@ -129782,7 +130635,8 @@ function renderCandidateUnboundAlertComment() {
   return "\u26A0\uFE0F \u6B64\u4EFB\u52A1\u672A\u80FD\u81EA\u52A8\u5173\u8054\u5230\u4EFB\u4F55\u8BDD\u9898:\u8BF7\u68C0\u67E5\u4EFB\u52A1\u6807\u9898\u662F\u5426\u4E0E\u8BDD\u9898\u6839\u6D88\u606F\u4E00\u81F4,\u6216\u5728\u5BF9\u5E94\u8BDD\u9898\u91CC @ \u4E00\u6B21 agent \u8BA9\u5B83\u8BA4\u9886\u8FD9\u4E2A\u4EFB\u52A1\u3002";
 }
 function normalizeForExactMatch(text) {
-  return text.replace(/\s+/g, " ").trim();
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return collapsed.replace(/^(?:@\S+\s+)+/, "").trim();
 }
 function isBridgeTouched(description) {
   return typeof description === "string" && description.includes(STATUS_SNAPSHOT_MARKER);
@@ -130804,6 +131658,7 @@ async function runV2Mode({
     const cardKitClient = shouldProvideResponseSurfaceCardKitClient(
       bot.response_surface_prototype
     ) ? client.outboundCardKitClient() : void 0;
+    const cotClient = bot.cot !== "off" && bot.cotSurface === "bubble" ? client.outboundCotClient() : void 0;
     let effectiveTaskHandleTasklistGuid;
     let taskHandleLifecycle;
     let taskHandleClaim;
@@ -130814,7 +131669,11 @@ async function runV2Mode({
     {
       const guid = bot.taskHandle?.tasklistGuid ?? await readTeamTasklistGuid(resolveTaskTeamRegistryPath());
       if (guid) {
-        const taskSdkClient = new import_node_sdk2.Client({ appId: bot.app_id, appSecret });
+        const taskSdkClient = new import_node_sdk2.Client({
+          appId: bot.app_id,
+          appSecret,
+          loggerLevel: import_node_sdk2.LoggerLevel.fatal
+        });
         const taskRequester = {
           request: (config2) => taskSdkClient.request(config2)
         };
@@ -131021,9 +131880,12 @@ async function runV2Mode({
         response_surface_prototype: bot.response_surface_prototype,
         taskHandle: effectiveTaskHandleTasklistGuid ? { tasklistGuid: effectiveTaskHandleTasklistGuid } : void 0,
         model: bot.model,
-        effort: bot.effort
+        effort: bot.effort,
+        cot: bot.cot,
+        cotSurface: bot.cotSurface
       },
       cardKitClient,
+      cotClient,
       postClient,
       gitlabToken: effectiveGitlabToken,
       agentMemory: bot.agent_memory,