@securecoms/agent-bridge 0.25.3 → 0.25.4

package/dist/bin.js

@@ -28838,6 +28838,70 @@ function pruneManagedMemory(home, identityId, hashes, deps = REAL_FS) {
 
 // src/bridge-agent.ts
 import { homedir as homedir2 } from "node:os";
+
+// src/status-gate.ts
+var STATUS_WORKING_DELAY_MS = 3e3;
+var StatusGate = class {
+  constructor(publish, opts = {}) {
+    this.publish = publish;
+    this.opts = opts;
+  }
+  entries = /* @__PURE__ */ new Map();
+  chains = /* @__PURE__ */ new Map();
+  /** The agent reported a status. Resolves once any publish it starts has settled. */
+  async report(channelId, state, detail) {
+    if (state === "working") {
+      this.holdWorking(channelId, detail);
+      return;
+    }
+    const entry = this.entries.get(channelId);
+    this.entries.delete(channelId);
+    if (entry?.timer) clearTimeout(entry.timer);
+    if (state === "idle" && entry && !entry.published) return;
+    await this.enqueue(channelId, state, detail);
+  }
+  /** A reply body is about to publish on the channel. */
+  replyStarted(channelId) {
+    const entry = this.entries.get(channelId);
+    if (!entry?.timer) return;
+    clearTimeout(entry.timer);
+    entry.timer = null;
+  }
+  /** Drop every pending "working" (bridge shutdown). */
+  close() {
+    for (const entry of this.entries.values()) if (entry.timer) clearTimeout(entry.timer);
+    this.entries.clear();
+  }
+  holdWorking(channelId, detail) {
+    const existing = this.entries.get(channelId);
+    if (existing && (existing.timer || existing.published)) return;
+    const entry = { timer: null, published: false };
+    this.entries.set(channelId, entry);
+    entry.timer = setTimeout(() => {
+      entry.timer = null;
+      if (this.entries.get(channelId) !== entry) return;
+      entry.published = true;
+      this.enqueue(channelId, "working", detail).catch(() => {
+      });
+    }, this.opts.delayMs ?? STATUS_WORKING_DELAY_MS);
+    entry.timer.unref?.();
+  }
+  /** Publishes in order per channel; rejects with the publish error. */
+  enqueue(channelId, state, detail) {
+    const prev = this.chains.get(channelId) ?? Promise.resolve();
+    const run = prev.then(() => this.publish(channelId, state, detail));
+    const settled = run.catch((err) => {
+      this.opts.onError?.(state, err);
+    });
+    this.chains.set(channelId, settled);
+    void settled.then(() => {
+      if (this.chains.get(channelId) === settled) this.chains.delete(channelId);
+    });
+    return run;
+  }
+};
+
+// src/bridge-agent.ts
 function logSendSupersededAdoption(kind) {
   switch (kind) {
     case "adopted":
@@ -29269,6 +29333,15 @@ var BridgeAgent = class _BridgeAgent {
    * either source wins; both read the same identity column.
    */
   lastOwnDisplayName;
+  /**
+   * Thinking-indicator gate (owner rule, 2026-10-01): the agent-facing status
+   * routes go through it, so a reply inside 3 s raises no "thinking..." strip.
+   * See status-gate.ts.
+   */
+  statusGate = new StatusGate(
+    (channelId, state, detail) => this.reportStatus(channelId, state, detail),
+    { onError: (state) => writeServiceLog("warn", "status.publish_failed", { working: state === "working", idle: state === "idle" }) }
+  );
   /**
    * Task 8 (owner-attested Reset Secure Session): per-channel STRUCTURAL owner
    * cache, fed by resolveAndPinOwner() on every roster refresh and consumed by
@@ -30800,6 +30873,7 @@ var BridgeAgent = class _BridgeAgent {
    */
   async publishBody(channelId, body, id, onEnvelope) {
     this.enforceBodyRateFloor(channelId, body);
+    this.statusGate.replyStarted(channelId);
     const joined = await this.reconcileJoin(channelId);
     if (!joined) throw new ChannelPendingError(channelId);
     const sendStart = performance.now();
@@ -31913,6 +31987,14 @@ var BridgeAgent = class _BridgeAgent {
     if (TRACE) writeServiceLog("debug", "identity.owner_pin_resolved");
     return { identityId: cached.identityId, publicKeyHex: pin.publicKeyHex };
   }
+  /**
+   * The agent-facing status entry (HTTP /v1/status, WS "status"): "working"
+   * is held 3 s and dropped if the turn ends or a reply starts first. See
+   * status-gate.ts. Resolves at once for "working".
+   */
+  async reportStatusGated(channelId, state, detail) {
+    await this.statusGate.report(channelId, state, detail);
+  }
   async reportStatus(channelId, state, detail) {
     const joined = await this.reconcileJoin(channelId);
     if (!joined) throw new ChannelPendingError(channelId);
@@ -33217,6 +33299,7 @@ var BridgeAgent = class _BridgeAgent {
   }
   async close() {
     this.closingDown = true;
+    this.statusGate.close();
     for (const t of this.pauseRecheckTimers.values()) clearTimeout(t);
     this.pauseRecheckTimers.clear();
     for (const t of this.supersedeRecheckTimers.values()) clearTimeout(t);
@@ -33563,7 +33646,7 @@ function createHttpServer(agent, opts) {
       if (method === "POST" && path === "/v1/status") {
         const parsed = statusSchema.safeParse(JSON.parse(await readBody(req, OTHER_CAP)));
         if (!parsed.success) return jsonError(res, "invalid_request", parsed.error.issues);
-        await agent.reportStatus(parsed.data.channel_id, parsed.data.state, parsed.data.detail);
+        await agent.reportStatusGated(parsed.data.channel_id, parsed.data.state, parsed.data.detail);
         return json(res, 200, { ok: true });
       }
       if (method === "POST" && path === "/v1/memory/record") {
@@ -33933,7 +34016,7 @@ async function handleInbound(sock, agent, data, inflight, flush, session) {
     }
     const detail = typeof m.detail === "string" ? m.detail : void 0;
     try {
-      await agent.reportStatus(m.channel_id, m.state, detail);
+      await agent.reportStatusGated(m.channel_id, m.state, detail);
       sendJson(sock, { type: "ok" });
     } catch (e) {
       if (e instanceof ChannelPendingError) {

package/dist/bridge-agent.d.ts

@@ -575,6 +575,12 @@ export declare class BridgeAgent {
      * either source wins; both read the same identity column.
      */
     private lastOwnDisplayName;
+    /**
+     * Thinking-indicator gate (owner rule, 2026-10-01): the agent-facing status
+     * routes go through it, so a reply inside 3 s raises no "thinking..." strip.
+     * See status-gate.ts.
+     */
+    private readonly statusGate;
     /**
      * Task 8 (owner-attested Reset Secure Session): per-channel STRUCTURAL owner
      * cache, fed by resolveAndPinOwner() on every roster refresh and consumed by
@@ -1819,6 +1825,12 @@ export declare class BridgeAgent {
      * never trusted on its own, it is always reconfirmed against the store.
      */
     private resolvePinnedOwnerHook;
+    /**
+     * The agent-facing status entry (HTTP /v1/status, WS "status"): "working"
+     * is held 3 s and dropped if the turn ends or a reply starts first. See
+     * status-gate.ts. Resolves at once for "working".
+     */
+    reportStatusGated(channelId: string, state: "idle" | "working" | "stalled" | "error", detail?: string): Promise<void>;
     reportStatus(channelId: string, state: "idle" | "working" | "stalled" | "error", detail?: string): Promise<void>;
     /** `runId` must exist and not have settled yet — settle() is terminal. */
     private requireActionRun;

package/dist/index.js

@@ -28687,6 +28687,70 @@ function pruneManagedMemory(home, identityId, hashes, deps = REAL_FS) {
 
 // src/bridge-agent.ts
 import { homedir as homedir2 } from "node:os";
+
+// src/status-gate.ts
+var STATUS_WORKING_DELAY_MS = 3e3;
+var StatusGate = class {
+  constructor(publish, opts = {}) {
+    this.publish = publish;
+    this.opts = opts;
+  }
+  entries = /* @__PURE__ */ new Map();
+  chains = /* @__PURE__ */ new Map();
+  /** The agent reported a status. Resolves once any publish it starts has settled. */
+  async report(channelId, state, detail) {
+    if (state === "working") {
+      this.holdWorking(channelId, detail);
+      return;
+    }
+    const entry = this.entries.get(channelId);
+    this.entries.delete(channelId);
+    if (entry?.timer) clearTimeout(entry.timer);
+    if (state === "idle" && entry && !entry.published) return;
+    await this.enqueue(channelId, state, detail);
+  }
+  /** A reply body is about to publish on the channel. */
+  replyStarted(channelId) {
+    const entry = this.entries.get(channelId);
+    if (!entry?.timer) return;
+    clearTimeout(entry.timer);
+    entry.timer = null;
+  }
+  /** Drop every pending "working" (bridge shutdown). */
+  close() {
+    for (const entry of this.entries.values()) if (entry.timer) clearTimeout(entry.timer);
+    this.entries.clear();
+  }
+  holdWorking(channelId, detail) {
+    const existing = this.entries.get(channelId);
+    if (existing && (existing.timer || existing.published)) return;
+    const entry = { timer: null, published: false };
+    this.entries.set(channelId, entry);
+    entry.timer = setTimeout(() => {
+      entry.timer = null;
+      if (this.entries.get(channelId) !== entry) return;
+      entry.published = true;
+      this.enqueue(channelId, "working", detail).catch(() => {
+      });
+    }, this.opts.delayMs ?? STATUS_WORKING_DELAY_MS);
+    entry.timer.unref?.();
+  }
+  /** Publishes in order per channel; rejects with the publish error. */
+  enqueue(channelId, state, detail) {
+    const prev = this.chains.get(channelId) ?? Promise.resolve();
+    const run = prev.then(() => this.publish(channelId, state, detail));
+    const settled = run.catch((err) => {
+      this.opts.onError?.(state, err);
+    });
+    this.chains.set(channelId, settled);
+    void settled.then(() => {
+      if (this.chains.get(channelId) === settled) this.chains.delete(channelId);
+    });
+    return run;
+  }
+};
+
+// src/bridge-agent.ts
 function logSendSupersededAdoption(kind) {
   switch (kind) {
     case "adopted":
@@ -29118,6 +29182,15 @@ var BridgeAgent = class _BridgeAgent {
    * either source wins; both read the same identity column.
    */
   lastOwnDisplayName;
+  /**
+   * Thinking-indicator gate (owner rule, 2026-10-01): the agent-facing status
+   * routes go through it, so a reply inside 3 s raises no "thinking..." strip.
+   * See status-gate.ts.
+   */
+  statusGate = new StatusGate(
+    (channelId, state, detail) => this.reportStatus(channelId, state, detail),
+    { onError: (state) => writeServiceLog2("warn", "status.publish_failed", { working: state === "working", idle: state === "idle" }) }
+  );
   /**
    * Task 8 (owner-attested Reset Secure Session): per-channel STRUCTURAL owner
    * cache, fed by resolveAndPinOwner() on every roster refresh and consumed by
@@ -30649,6 +30722,7 @@ var BridgeAgent = class _BridgeAgent {
    */
   async publishBody(channelId, body, id, onEnvelope) {
     this.enforceBodyRateFloor(channelId, body);
+    this.statusGate.replyStarted(channelId);
     const joined = await this.reconcileJoin(channelId);
     if (!joined) throw new ChannelPendingError(channelId);
     const sendStart = performance.now();
@@ -31762,6 +31836,14 @@ var BridgeAgent = class _BridgeAgent {
     if (TRACE) writeServiceLog2("debug", "identity.owner_pin_resolved");
     return { identityId: cached.identityId, publicKeyHex: pin.publicKeyHex };
   }
+  /**
+   * The agent-facing status entry (HTTP /v1/status, WS "status"): "working"
+   * is held 3 s and dropped if the turn ends or a reply starts first. See
+   * status-gate.ts. Resolves at once for "working".
+   */
+  async reportStatusGated(channelId, state, detail) {
+    await this.statusGate.report(channelId, state, detail);
+  }
   async reportStatus(channelId, state, detail) {
     const joined = await this.reconcileJoin(channelId);
     if (!joined) throw new ChannelPendingError(channelId);
@@ -33066,6 +33148,7 @@ var BridgeAgent = class _BridgeAgent {
   }
   async close() {
     this.closingDown = true;
+    this.statusGate.close();
     for (const t of this.pauseRecheckTimers.values()) clearTimeout(t);
     this.pauseRecheckTimers.clear();
     for (const t of this.supersedeRecheckTimers.values()) clearTimeout(t);
@@ -33519,7 +33602,7 @@ function createHttpServer(agent, opts) {
       if (method === "POST" && path === "/v1/status") {
         const parsed = statusSchema.safeParse(JSON.parse(await readBody(req, OTHER_CAP)));
         if (!parsed.success) return jsonError(res, "invalid_request", parsed.error.issues);
-        await agent.reportStatus(parsed.data.channel_id, parsed.data.state, parsed.data.detail);
+        await agent.reportStatusGated(parsed.data.channel_id, parsed.data.state, parsed.data.detail);
         return json(res, 200, { ok: true });
       }
       if (method === "POST" && path === "/v1/memory/record") {
@@ -33889,7 +33972,7 @@ async function handleInbound(sock, agent, data, inflight, flush, session) {
     }
     const detail = typeof m.detail === "string" ? m.detail : void 0;
     try {
-      await agent.reportStatus(m.channel_id, m.state, detail);
+      await agent.reportStatusGated(m.channel_id, m.state, detail);
       sendJson(sock, { type: "ok" });
     } catch (e) {
       if (e instanceof ChannelPendingError) {

package/dist/status-gate.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Thinking-indicator gate (owner rule, 2026-10-01): a reply that comes back
+ * within {@link STATUS_WORKING_DELAY_MS} shows no "thinking..." strip at all;
+ * a longer turn shows it.
+ *
+ * Every status is an MLS publish (about 4.4 s in prod) on the same per-tenant
+ * send path as the reply, so an eager "working" made quick replies wait behind
+ * it. The gate holds "working" for the delay and publishes it only if the turn
+ * is still running then:
+ *
+ *   - "idle" before the delay cancels the pending "working" and publishes
+ *     nothing (the strip was never shown, so there is nothing to clear);
+ *   - a reply starting to publish on the channel also cancels it, because
+ *     some runtimes (OpenClaw) send "idle" only after the reply publish has
+ *     settled, which would otherwise raise the strip under a visible answer;
+ *   - once "working" is published, "idle" is published after it, in order;
+ *   - "stalled" / "error" publish at once (after anything queued) and drop a
+ *     pending "working".
+ *
+ * Only the agent-facing status routes (HTTP /v1/status, WS "status") go
+ * through the gate. BridgeAgent.reportStatus itself still publishes at once.
+ */
+export declare const STATUS_WORKING_DELAY_MS = 3000;
+export type AgentStatusState = "idle" | "working" | "stalled" | "error";
+type Publish = (channelId: string, state: AgentStatusState, detail?: string) => Promise<void>;
+export declare class StatusGate {
+    private readonly publish;
+    private readonly opts;
+    private readonly entries;
+    private readonly chains;
+    constructor(publish: Publish, opts?: {
+        delayMs?: number;
+        onError?: (state: AgentStatusState, err: unknown) => void;
+    });
+    /** The agent reported a status. Resolves once any publish it starts has settled. */
+    report(channelId: string, state: AgentStatusState, detail?: string): Promise<void>;
+    /** A reply body is about to publish on the channel. */
+    replyStarted(channelId: string): void;
+    /** Drop every pending "working" (bridge shutdown). */
+    close(): void;
+    private holdWorking;
+    /** Publishes in order per channel; rejects with the publish error. */
+    private enqueue;
+}
+export {};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const BRIDGE_VERSION = "0.25.3";
+export declare const BRIDGE_VERSION = "0.25.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@securecoms/agent-bridge",
-  "version": "0.25.3",
+  "version": "0.25.4",
   "type": "module",
   "engines": {
     "node": ">=22.5.0"