dsh-lark-bot 0.19.3 → 0.19.4

package/dist/cli.js

@@ -2779,6 +2779,18 @@ function patchYamlFor(options) {
     "",
     "- id: hmr",
     "  disabled: true",
+    "",
+    // Model-invocable channel skill: expose the dsh-lark-bot operations guide
+    // to THIS agent session's skill catalog — the one the `skill` tool reads.
+    // The bridge engine registers the same skill on its own cordis context
+    // (plugin.ts), but that context is never the one the model reads. This row
+    // ensures the skill also lands on the agent runtime's context so that
+    // `skill("dsh-lark-bot")` resolves in a live SDK session. It is kept
+    // outside the bridgeTools gate because it needs no callback endpoint and
+    // is also useful to the guardian's core-only safe profile.
+    "- insert:",
+    "    - id: lark-skill",
+    `      name: '${own.name}/skill'`,
     ""
   ];
   if (bridgeTools) {
@@ -7314,7 +7326,11 @@ function processElements(state, locale, maxTools) {
 function thinkingPanel(state, locale, maxTools) {
   return {
     tag: "collapsible_panel",
-    expanded: state.terminal === "running",
+    // Default to collapsed: the top-level compatibility snapshot already shows
+    // the latest status and current tools, so keep the detailed per-tool list
+    // collapsed to avoid two overlapping expanded surfaces. (Both sections are
+    // retained for now.)
+    expanded: false,
     header: {
       title: { tag: "plain_text", content: `\u2699\uFE0F ${locale === "zh_cn" ? "\u6267\u884C\u8FC7\u7A0B" : "Execution"} \xB7 ${summaryText(state, locale)}` },
       icon: { tag: "standard_icon", token: "down-small-ccm_outlined" },
@@ -8000,6 +8016,15 @@ async function runAttempt(input, cwd, workspaceCwd, sessionId, resuming, replyOp
           log.warn("run-flow", "card-update-failed", { scope: input.scope, error });
         }
       };
+      const unregisterReanchor = input.runCardAnchors?.register(input.chatId, async () => {
+        if (state.terminal !== "running") return;
+        try {
+          await controller.update(renderer(state, density, Date.now()));
+          if (typeof controller.reanchor === "function") await controller.reanchor();
+        } catch (error) {
+          log.warn("run-flow", "card-reanchor-failed", { scope: input.scope, error });
+        }
+      });
       const showResumeRecovery = async (error) => {
         if (classifySessionError(errorMessage(error)) === void 0) throw error;
         resumeFailure = errorMessage(error);
@@ -8173,6 +8198,7 @@ async function runAttempt(input, cwd, workspaceCwd, sessionId, resuming, replyOp
         unsubscribeQuestion?.();
         unsubscribePlan?.();
         unsubscribeApproval?.();
+        unregisterReanchor?.();
       }
     };
     let producerStarted = false;
@@ -11904,6 +11930,41 @@ var ResilientCardStreamController = class {
       });
     }
   }
+  /**
+   * Recall the current card and re-create it as the newest top-level message in
+   * the chat, rebinding the controller to the fresh message id. Because Feishu
+   * cannot reorder an existing message, this is the only way to keep an
+   * in-progress process card visible at the tail while interim agent bubbles are
+   * appended below. Best-effort: if the recall fails the card is left where it
+   * is (no duplicate is created); if the controller is closed or failed the id
+   * is left unchanged.
+   */
+  async reanchor() {
+    if (this.closed || this.failed) return this.messageId;
+    if (this.inFlight !== void 0) await this.inFlight;
+    if (this.timer !== void 0) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    const card = this.latest;
+    if (card === void 0) return this.messageId;
+    try {
+      await this.channel.recallMessage(this.messageId);
+    } catch (error) {
+      log.warn("lark-card-stream", "reanchor-recall-failed", {
+        messageId: this.messageId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return this.messageId;
+    }
+    const sent = await this.channel.send(this.chatId, { card }, {});
+    if (!sent.messageId) throw new Error("Feishu card re-anchor returned no message_id");
+    this.messageId = sent.messageId;
+    this.latest = card;
+    this.dirty = false;
+    this.failed = false;
+    return this.messageId;
+  }
 };
 function adaptLarkChannel(channel) {
   const base = {
@@ -14147,6 +14208,63 @@ function wizardContextFor(event, deps, channel, scope) {
   };
 }
 
+// src/bridge/run-card-anchors.ts
+var RunCardAnchors = class {
+  byChatId = /* @__PURE__ */ new Map();
+  /**
+   * Register a re-anchor callback for a chat. Returns a disposer; safe to call
+   * more than once (idempotent).
+   */
+  register(chatId, reanchor) {
+    const set = this.byChatId.get(chatId) ?? /* @__PURE__ */ new Set();
+    set.add(reanchor);
+    this.byChatId.set(chatId, set);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      set.delete(reanchor);
+      if (set.size === 0) this.byChatId.delete(chatId);
+    };
+  }
+  /** Notify that a new bubble was delivered to the chat. */
+  async bubbleSent(chatId) {
+    const set = this.byChatId.get(chatId);
+    if (!set || set.size === 0) return;
+    await Promise.allSettled([...set].map((reanchor) => reanchor()));
+  }
+};
+function attachRunCardAnchors(channel, anchors) {
+  const notify = (chatId) => {
+    void anchors.bubbleSent(chatId).catch((error) => {
+      log.warn("run-card-anchors", "bubble-sent-failed", {
+        chatId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  };
+  return {
+    ...channel,
+    async sendMarkdown(chatId, markdown2, options) {
+      const result = await channel.sendMarkdown(chatId, markdown2, options);
+      notify(chatId);
+      return result;
+    },
+    async sendCard(chatId, card, options) {
+      if (typeof channel.sendCard !== "function") return void 0;
+      const result = await channel.sendCard(chatId, card, options);
+      notify(chatId);
+      return result;
+    },
+    async sendFile(chatId, fileName, content, options) {
+      if (typeof channel.sendFile !== "function") return void 0;
+      const result = await channel.sendFile(chatId, fileName, content, options);
+      notify(chatId);
+      return result;
+    }
+  };
+}
+
 // src/notify/server.ts
 import { createServer } from "http";
 import { randomBytes as randomBytes2 } from "crypto";
@@ -17662,6 +17780,7 @@ async function startBridgeEngine(options) {
   const questions = new QuestionRegistry();
   const plans = new PlanApprovalRegistry();
   const densityStore = new DensityStore();
+  const runCardAnchors = new RunCardAnchors();
   const models = new ModelStore();
   const wizardStore = new WizardStore();
   const dshConfig = new DshProviderManager({ env: process.env });
@@ -17892,6 +18011,7 @@ async function startBridgeEngine(options) {
           plans,
           densityStore,
           channel: streaming,
+          runCardAnchors,
           defaultWorkspace,
           replyTo: first.messageId,
           deliverFinalReply: (replyScope, chatId, markdown2, options2) => replyDispatcher.deliver(replyScope, chatId, markdown2, options2),
@@ -18094,7 +18214,7 @@ async function startBridgeEngine(options) {
       error: "channel does not expose getBotIdentity"
     });
   }
-  streaming = adaptLarkChannel(bridge.channel);
+  streaming = attachRunCardAnchors(adaptLarkChannel(bridge.channel), runCardAnchors);
   larkChannel = bridge.channel;
   const deliverUpdateResult = async () => {
     await updateHandoff.deliverResult(async (state) => {