@securecoms/agent-bridge 0.25.0 → 0.25.2

package/connectors/openclaw/openclaw-entry.js

@@ -129,6 +129,38 @@ export function chatTypeFor(authorization) {
   return audience === "owner_dm" || audience === "other_human_dm" ? "direct" : "group";
 }
 
+// ---------------------------------------------------------------------------
+// Content-free diagnostic lines (#910). Same discipline as the bridge's
+// writeServiceLog (src/service-log.ts, and the literal-event lint in
+// src/service-log.test.ts): the caller passes a LITERAL template and typed
+// fields, and every substituted value must be a finite number or a bare
+// identifier token (a status state, an error class name). Anything else —
+// free text, an error message, an id with dashes, a URL — renders as
+// "invalid", so no message content or identifier can reach the log through
+// these lines even if a caller passes one by mistake.
+// ---------------------------------------------------------------------------
+
+const SAFE_TOKEN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+
+function _safeField(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return String(Math.round(v));
+  if (typeof v === "string" && SAFE_TOKEN.test(v)) return v;
+  return "invalid";
+}
+
+/** Render `template`, replacing each `{key}` with the sanitized `fields[key]`. */
+export function formatSafeLine(template, fields) {
+  return String(template).replace(/\{(\w+)\}/g, (_, key) => _safeField(fields?.[key]));
+}
+
+/** An error's class name without reading its message or stack (never throws). */
+function _errorClass(err) {
+  try {
+    if (err && typeof err === "object" && typeof err.name === "string" && SAFE_TOKEN.test(err.name)) return err.name;
+  } catch { /* hostile getter */ }
+  return typeof err === "object" && err !== null ? "Error" : "Thrown";
+}
+
 // ---------------------------------------------------------------------------
 // Account / identity / connection-file resolution.
 // ---------------------------------------------------------------------------
@@ -265,6 +297,9 @@ export class LoopbackChannel {
     // reconnect backoff, so a failing turn is retried with growing delay
     // instead of a ~250 ms redelivery loop.
     this._failStreak = 0;
+    // Per-channel status reporter state (see reportStatus): channelId ->
+    // { desired, sent, inFlight }.
+    this._status = new Map();
   }
 
   _setState(s) {
@@ -561,21 +596,74 @@ export class LoopbackChannel {
   }
 
   // Report agent operational status to the daemon (POST /v1/status). Drives the
-  // web "Thinking…" indicator (J1). Best-effort and FIRE-AND-FORGET: callers do
-  // NOT await it, so the status round-trip adds no latency to the turn. On this
-  // deployment an MLS publish (which /v1/status performs) costs ~4.4s, so any
-  // await here would add seconds before the reply — the exact lag we hit. No
-  // AbortSignal timeout either: a 2s cap fired before the ~4.4s publish landed,
-  // so the "working" status never published and the strip never showed. Let the
-  // background fetch run to completion; it swallows its own errors.
-  async reportStatus(channelId, state) {
+  // web "… is thinking…" strip (J1, #910). A port of the runtime's reporter
+  // (packages/connect-agent-runtime/src/status-reporter.ts, #911):
+  //
+  //   * FIRE-AND-FORGET. Synchronous, returns nothing, never throws. The bridge
+  //     answers /v1/status only after an MLS publish (~4.4s in prod), so no
+  //     turn may await it. No AbortSignal timeout: a 2s cap once fired before
+  //     the publish landed, so "working" never published.
+  //
+  //   * ORDERED PER CHANNEL. The web keeps the latest status. Two concurrent
+  //     POSTs are two concurrent publishes on the bridge, so a turn's "idle"
+  //     could land with or before its "working" and the strip never showed.
+  //     So each channel has at most ONE POST in flight; a state set meanwhile
+  //     becomes the channel's desired state and is sent when that POST
+  //     settles. Only the latest desired state is kept, and a state equal to
+  //     the last one sent is not re-sent, so the final state published for a
+  //     channel is always the last one set.
+  //
+  //   * LOGGED, CONTENT-FREE. Each outcome is one line with the state and a
+  //     duration, HTTP code or error class — never the channel id, the body
+  //     or an error message.
+  reportStatus(channelId, state) {
+    let entry = this._status.get(channelId);
+    if (!entry) {
+      entry = { desired: state, sent: null, inFlight: false };
+      this._status.set(channelId, entry);
+    }
+    entry.desired = state;
+    if (entry.inFlight) return;
+    entry.inFlight = true;
+    void this._drainStatus(channelId, entry);
+  }
+
+  async _drainStatus(channelId, entry) {
+    while (entry.desired !== entry.sent) {
+      const state = entry.desired;
+      // Marked sent before the POST: a failed POST is not retried (the next
+      // state change will publish the truth anyway).
+      entry.sent = state;
+      await this._postStatus(channelId, state);
+    }
+    entry.inFlight = false;
+    // Bounded by channels with a change still to publish.
+    if (this._status.get(channelId) === entry) this._status.delete(channelId);
+  }
+
+  async _postStatus(channelId, state) {
+    const t0 = Date.now();
     try {
-      await fetch(`${this.bridgeUrl}/v1/status`, {
+      // bridgeUrl/token read per POST: a reconnect can move the port or rotate the token.
+      const r = await fetch(`${this.bridgeUrl}/v1/status`, {
         method: "POST",
         headers: { "content-type": "application/json", authorization: `Bearer ${this.token}` },
         body: JSON.stringify({ channel_id: channelId, state }),
       });
-    } catch { /* best-effort: never break a turn on a status POST */ }
+      if (r.ok) this._logSafe("[securecoms] status {state} ok ms={ms}", { state, ms: Date.now() - t0 });
+      else this._logSafe("[securecoms] status {state} failed http={http}", { state, http: r.status });
+      // Release the connection; the body carries nothing we need.
+      try { await r.body?.cancel?.(); } catch { /* ignore */ }
+    } catch (err) {
+      // Best-effort presence: a status failure never reaches the turn.
+      this._logSafe("[securecoms] status {state} failed error={cls}", { state, cls: _errorClass(err) });
+    }
+  }
+
+  /** One content-free line (see formatSafeLine). A logger failure never propagates. */
+  _logSafe(template, fields) {
+    const sink = this.log;
+    try { sink(formatSafeLine(template, fields)); } catch { /* never break a turn on logging */ }
   }
 
   async stop() {
@@ -671,33 +759,63 @@ async function _handleInbound({ text, metadata, channel, account, cfg }) {
     onRecordError: (err) => core.error?.(`[SecureComs] session record failed: ${String(err)}`),
   });
 
-  // J1 activity indicator: flip the agent to "working" for the duration of the
-  // reply turn (the LLM dispatch, the bulk of "thinking") and back to "idle"
-  // when it finishes OR throws. FIRE-AND-FORGET (not awaited): the status
-  // publish costs ~4.4s on this deployment, so awaiting it added that latency
-  // before the reply and after the turn. Ordering stays correct without the
-  // await because "working" is issued before a multi-second dispatch, giving it
-  // a large head-start over the reply's own publish — the ping→pong race that
-  // motivated awaiting doesn't occur when the reply itself takes seconds to
-  // publish. The web client clears the strip on the later "idle".
+  // J1 activity indicator (#910): "working" for the reply turn, "idle" when it
+  // is over — including when dispatch throws. Both go through the channel's
+  // per-channel reporter (LoopbackChannel.reportStatus): synchronous, never
+  // awaited, never throws, and ordered, so "idle" can never land before
+  // "working".
+  //
+  // "Over" means dispatch returned AND no deliver is still publishing a reply
+  // block: if the dispatcher returns while a deliver it started is pending,
+  // "idle" waits for the last one to settle (success or failure) so the strip
+  // does not clear before the reply is out. The turn itself does not wait for
+  // that — ack/redelivery behavior is unchanged.
   channel.reportStatus(conv, "working");
+  const pendingDeliveries = new Set();
+  let deliveredBlocks = 0;
+  const dispatchStarted = Date.now();
   try {
     await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
       ctx: ctxPayload,
       cfg,
       dispatcherOptions: {
-        deliver: async (payload) => {
-          // Drop chain-of-thought / reasoning blocks; only send finalized text.
-          if (payload?.kind === "thinking" || payload?.kind === "reasoning") return;
-          const t = (payload?.text ?? "").trim();
-          if (t) await channel.send(conv, t, metadata.messageId);
+        deliver: (payload) => {
+          const p = (async () => {
+            // Drop chain-of-thought / reasoning blocks; only send finalized text.
+            if (payload?.kind === "thinking" || payload?.kind === "reasoning") return;
+            const t = (payload?.text ?? "").trim();
+            if (t) {
+              await channel.send(conv, t, metadata.messageId);
+              deliveredBlocks++;
+            }
+          })();
+          pendingDeliveries.add(p);
+          const done = () => { pendingDeliveries.delete(p); };
+          p.then(done, done);
+          // The dispatcher still sees this block's own outcome (and error).
+          return p;
         },
         onError: (err, info) => core.error?.(`[SecureComs] ${info?.kind ?? "reply"} error: ${String(err)}`),
       },
       replyOptions: {},
     });
   } finally {
-    channel.reportStatus(conv, "idle");
+    // One line per turn, content-free: tells whether dispatch returns before
+    // its reply blocks are delivered (delivered_blocks=0 with pending > 0).
+    channel._logSafe("[securecoms] turn dispatch_ms={ms} delivered_blocks={k} pending_deliveries={p}", {
+      ms: Date.now() - dispatchStarted,
+      k: deliveredBlocks,
+      p: pendingDeliveries.size,
+    });
+    if (pendingDeliveries.size === 0) {
+      channel.reportStatus(conv, "idle");
+    } else {
+      void (async () => {
+        // A deliver may start another while we wait; drain until none is left.
+        while (pendingDeliveries.size > 0) await Promise.allSettled([...pendingDeliveries]);
+        channel.reportStatus(conv, "idle");
+      })();
+    }
   }
 }
 

package/connectors/openclaw/openclaw-entry.status.test.ts

@@ -0,0 +1,432 @@
+// packages/connect-agent-bridge/connectors/openclaw/openclaw-entry.status.test.ts
+//
+// #910 part 2: the web "… is thinking…" strip never showed for the OpenClaw
+// connector. A direct working -> idle POST to the bridge showed it, so the loss
+// was inside this plugin: reportStatus swallowed every error unlogged, and the
+// turn fired `working` and `idle` as two concurrent, unordered POSTs (each an
+// MLS publish on the bridge), so `idle` could land with or before `working`.
+//
+// These tests pin the port of the runtime's per-channel status reporter
+// (packages/connect-agent-runtime/src/status-reporter.ts, #911):
+//   - one status POST in flight per channel, latest desired state wins, an
+//     equal state is never re-sent, so `idle` can never overtake `working`;
+//   - outcomes are logged content-free (`ok ms=` / `failed http=|error=`);
+//   - a status POST never delays or fails the turn;
+//   - `idle` waits until dispatch returned AND every deliver has settled;
+//   - one `turn dispatch_ms=… delivered_blocks=…` line per turn.
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildConnectionFile, writeConnectionFile } from "../../src/service/connection-file.js";
+
+const BOUND_ID = "agent-identity";
+const OWNER_ID = "owner-human";
+const PORT = 7097;
+const TOKEN_VALUE = "status-test-token";
+const ORIGINAL_CONN_FILE_ENV = process.env.SECURECOMS_CONNECTION_FILE;
+
+const ownerAuth = { version: 1, audience: "owner_dm", sender_membership: "active", tool_grants: [] };
+
+function waitFor(predicate: () => boolean, timeout = 3000): Promise<void> {
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    const check = () => {
+      if (predicate()) return resolve();
+      if (Date.now() - start > timeout) return reject(new Error("waitFor: condition never became true"));
+      setTimeout(check, 5);
+    };
+    check();
+  });
+}
+
+const tick = (ms = 20) => new Promise((r) => setTimeout(r, ms));
+
+type Deferred<T> = { promise: Promise<T>; resolve: (v: T) => void; reject: (e: unknown) => void };
+function deferred<T>(): Deferred<T> {
+  let resolve!: (v: T) => void;
+  let reject!: (e: unknown) => void;
+  const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+const okRes = () => ({ ok: true, status: 200, json: async () => ({ ok: true }) });
+
+/**
+ * A controllable /v1/status endpoint: every POST is recorded and parked until
+ * the test settles it, so completion order is under the test's control.
+ */
+function makeStatusEndpoint() {
+  const posts: Array<{ state: string; channel: string; settle: Deferred<unknown> }> = [];
+  const completed: string[] = [];
+  let inFlight = 0;
+  let maxInFlight = 0;
+  const handle = (init?: RequestInit) => {
+    const body = JSON.parse(String(init?.body));
+    const settle = deferred<unknown>();
+    posts.push({ state: body.state, channel: body.channel_id, settle });
+    inFlight++;
+    maxInFlight = Math.max(maxInFlight, inFlight);
+    return settle.promise.finally(() => {
+      inFlight--;
+      completed.push(body.state);
+    });
+  };
+  return {
+    posts,
+    completed,
+    handle,
+    get maxInFlight() { return maxInFlight; },
+  };
+}
+
+async function loadModule(home: string) {
+  vi.resetModules();
+  vi.doMock("node:os", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("node:os")>();
+    return { ...actual, homedir: () => home };
+  });
+  return await import("./openclaw-entry.js");
+}
+
+function makeFakeWebSocket() {
+  const instances: any[] = [];
+  class FakeWebSocket {
+    url: string;
+    sent: Array<Record<string, unknown>> = [];
+    closed = false;
+    listeners: Record<string, Array<(ev?: unknown) => void>> = {};
+    constructor(url: string) { this.url = url; instances.push(this); }
+    addEventListener(type: string, cb: (ev?: unknown) => void) { (this.listeners[type] ??= []).push(cb); }
+    send(data: string) { this.sent.push(JSON.parse(data)); }
+    close() { if (this.closed) return; this.closed = true; this._emit("close"); }
+    _emit(type: string, ev?: unknown) { for (const cb of this.listeners[type] ?? []) cb(ev ?? {}); }
+  }
+  return { FakeWebSocket, instances };
+}
+
+function makeRuntime() {
+  let dispatchImpl: (args: any) => Promise<void> = async () => {};
+  const runtime = {
+    channel: {
+      routing: { resolveAgentRoute: () => ({ agentId: "main", sessionKey: "agent:main:main" }) },
+      session: {
+        resolveStorePath: () => "/tmp/openclaw-store-unused",
+        readSessionUpdatedAt: () => undefined,
+        recordInboundSession: async () => {},
+      },
+      reply: {
+        resolveEnvelopeFormatOptions: () => ({}),
+        formatAgentEnvelope: (args: any) => `ENV:${args.body}`,
+        finalizeInboundContext: (ctx: any) => ctx,
+        dispatchReplyWithBufferedBlockDispatcher: async (args: any) => { await dispatchImpl(args); },
+      },
+    },
+    error: () => {},
+  };
+  return { runtime, setDispatch(fn: (args: any) => Promise<void>) { dispatchImpl = fn; } };
+}
+
+describe("openclaw-entry — per-channel status reporter (#910)", () => {
+  let home: string;
+  let logs: string[];
+  let controller: AbortController;
+  let statusImpl: (init?: RequestInit) => Promise<unknown>;
+  let sendImpl: (body: Record<string, unknown>) => Promise<unknown>;
+  let statusPosts: string[];
+  let sends: Array<Record<string, unknown>>;
+
+  beforeEach(() => {
+    home = mkdtempSync(join(tmpdir(), "sc-status-"));
+    const tokenFile = join(home, "bridge-token");
+    writeFileSync(tokenFile, TOKEN_VALUE, { mode: 0o600 });
+    writeConnectionFile(home, buildConnectionFile({
+      identityId: BOUND_ID,
+      port: PORT,
+      tokenFile,
+      slug: "status-test",
+      label: "Status Test",
+      instanceId: "status-test-instance",
+      now: new Date().toISOString(),
+    }));
+    process.env.SECURECOMS_CONNECTION_FILE = join(home, ".securecoms", "connections", `${BOUND_ID}.json`);
+    logs = [];
+    statusPosts = [];
+    sends = [];
+    statusImpl = async () => okRes();
+    sendImpl = async () => ({ ok: true, status: 200, json: async () => ({ message_id: "reply-1" }) });
+    vi.stubGlobal("fetch", vi.fn(async (url: string, init?: RequestInit) => {
+      const u = String(url);
+      if (u.endsWith("/healthz")) return { ok: true, json: async () => ({ identity_id: BOUND_ID, joined_channels: 1 }) };
+      if (u.includes("/v1/reply-receipt")) return { ok: true, status: 200, json: async () => ({ found: false }) };
+      if (u.endsWith("/v1/send")) {
+        const body = JSON.parse(String(init?.body));
+        sends.push(body);
+        return sendImpl(body);
+      }
+      if (u.endsWith("/v1/status")) {
+        statusPosts.push(JSON.parse(String(init?.body)).state);
+        return statusImpl(init);
+      }
+      throw new Error(`unexpected fetch: ${u}`);
+    }));
+    controller = new AbortController();
+  });
+
+  afterEach(() => {
+    controller.abort();
+    vi.unstubAllGlobals();
+    vi.unmock("node:os");
+    if (ORIGINAL_CONN_FILE_ENV === undefined) delete process.env.SECURECOMS_CONNECTION_FILE;
+    else process.env.SECURECOMS_CONNECTION_FILE = ORIGINAL_CONN_FILE_ENV;
+    vi.resetModules();
+  });
+
+  async function newChannel() {
+    const mod = await loadModule(home);
+    const channel = new mod.LoopbackChannel({ boundIdentity: BOUND_ID, log: (m: string) => logs.push(String(m)) });
+    channel.bridgeUrl = `http://127.0.0.1:${PORT}`;
+    channel.token = TOKEN_VALUE;
+    return channel;
+  }
+
+  async function startTurnHarness(runtime: unknown) {
+    const mod = await loadModule(home);
+    let plugin: any;
+    mod.default.register({ runtime, registerChannel: ({ plugin: p }: { plugin: unknown }) => { plugin = p; } });
+    const { FakeWebSocket, instances } = makeFakeWebSocket();
+    vi.stubGlobal("WebSocket", FakeWebSocket);
+    const account = plugin.config.resolveAccount({}, "default");
+    void plugin.gateway.startAccount({
+      account,
+      cfg: {},
+      log: (m: string) => logs.push(String(m)),
+      abortSignal: controller.signal,
+    });
+    await waitFor(() => instances.length >= 1);
+    instances[0]._emit("open");
+    const ws = instances[0];
+    const deliverFrame = (messageId: string, channelId = "dm-1") =>
+      ws._emit("message", { data: JSON.stringify({
+        type: "message", ts: 1_700_000_000_000, channel_id: channelId, message_id: messageId,
+        sender_id: OWNER_ID, text: "hello", authorization: ownerAuth,
+      }) });
+    const acks = () => ws.sent.filter((f: any) => f.type === "ack").map((f: any) => f.message_id);
+    return { deliverFrame, acks };
+  }
+
+  // ------------------------------------------------ reporter (unit) ----
+
+  it("working is sent before idle and idle never overtakes it, even when the POSTs would complete out of order", async () => {
+    const ep = makeStatusEndpoint();
+    statusImpl = ep.handle;
+    const channel = await newChannel();
+
+    channel.reportStatus("dm-1", "working");
+    channel.reportStatus("dm-1", "idle");
+    await tick();
+    // Only `working` is on the wire; `idle` is held until it settles.
+    expect(ep.posts.map((p) => p.state)).toEqual(["working"]);
+
+    ep.posts[0].settle.resolve(okRes());
+    await waitFor(() => ep.posts.length === 2);
+    expect(ep.posts.map((p) => p.state)).toEqual(["working", "idle"]);
+    ep.posts[1].settle.resolve(okRes());
+    await waitFor(() => ep.completed.length === 2);
+    expect(ep.completed).toEqual(["working", "idle"]);
+    expect(ep.maxInFlight).toBe(1);
+  });
+
+  it("two quick turns on one channel publish working then idle once (latest wins, equal state not re-sent)", async () => {
+    const ep = makeStatusEndpoint();
+    statusImpl = ep.handle;
+    const channel = await newChannel();
+
+    channel.reportStatus("dm-1", "working");
+    channel.reportStatus("dm-1", "idle");
+    channel.reportStatus("dm-1", "working");
+    channel.reportStatus("dm-1", "idle");
+    await tick();
+    ep.posts[0].settle.resolve(okRes());
+    await waitFor(() => ep.posts.length === 2);
+    ep.posts[1].settle.resolve(okRes());
+    await tick();
+    expect(ep.posts.map((p) => p.state)).toEqual(["working", "idle"]);
+    expect(ep.maxInFlight).toBe(1);
+  });
+
+  it("channels are independent: a slow POST on one channel does not hold another channel's status", async () => {
+    const ep = makeStatusEndpoint();
+    statusImpl = ep.handle;
+    const channel = await newChannel();
+    channel.reportStatus("dm-1", "working");
+    channel.reportStatus("dm-2", "working");
+    await tick();
+    expect(ep.posts.map((p) => `${p.channel}:${p.state}`).sort()).toEqual(["dm-1:working", "dm-2:working"]);
+  });
+
+  it("reportStatus returns synchronously and never throws, even when fetch throws synchronously", async () => {
+    const channel = await newChannel();
+    statusImpl = () => { throw new TypeError("fetch failed"); };
+    expect(() => channel.reportStatus("dm-1", "working")).not.toThrow();
+    expect(channel.reportStatus("dm-1", "idle")).toBeUndefined();
+    await waitFor(() => logs.some((m) => m.includes("status idle failed")));
+  });
+
+  it("logs a non-2xx status POST as failed with the HTTP code, and a success as ok with its duration", async () => {
+    const channel = await newChannel();
+    statusImpl = async () => ({ ok: false, status: 503, json: async () => ({}) });
+    channel.reportStatus("dm-1", "working");
+    await waitFor(() => logs.some((m) => m.includes("[securecoms] status working failed")));
+    expect(logs).toContain("[securecoms] status working failed http=503");
+
+    statusImpl = async () => okRes();
+    channel.reportStatus("dm-1", "idle");
+    await waitFor(() => logs.some((m) => m.includes("[securecoms] status idle ok")));
+    expect(logs.find((m) => m.includes("status idle ok"))).toMatch(/^\[securecoms\] status idle ok ms=\d+$/);
+  });
+
+  it("logs a rejected status POST as failed with the error class only (no message, no ids)", async () => {
+    const channel = await newChannel();
+    statusImpl = async () => { throw new TypeError("connect ECONNREFUSED 127.0.0.1:7097 dm-1 secret"); };
+    channel.reportStatus("dm-1", "working");
+    await waitFor(() => logs.some((m) => m.includes("status working failed")));
+    expect(logs).toContain("[securecoms] status working failed error=TypeError");
+    expect(logs.join("\n")).not.toContain("dm-1");
+    expect(logs.join("\n")).not.toContain("ECONNREFUSED");
+  });
+
+  it("formatSafeLine renders only finite numbers and bare identifier tokens; anything else is 'invalid'", async () => {
+    const mod = await loadModule(home);
+    const t = "[securecoms] x a={a} b={b} c={c} d={d} e={e} f={f}";
+    expect(mod.formatSafeLine(t, {
+      a: 12.4, b: "working", c: "hello world", d: "dm-1", e: Number.NaN, f: undefined,
+    })).toBe("[securecoms] x a=12 b=working c=invalid d=invalid e=invalid f=invalid");
+    expect(mod.formatSafeLine("{m}", { m: "HEAD-private-message-TAIL" })).toBe("invalid");
+  });
+
+  it("a hostile error (throwing name getter) is logged as a generic class, never breaking the reporter", async () => {
+    const channel = await newChannel();
+    const hostile = Object.create(Error.prototype, { name: { get: () => { throw new Error("getter read"); } } });
+    statusImpl = async () => { throw hostile; };
+    channel.reportStatus("dm-1", "working");
+    await waitFor(() => logs.includes("[securecoms] status working failed error=Error"));
+  });
+
+  it("a failed POST is not retried, and the next state is still sent after it", async () => {
+    const channel = await newChannel();
+    let n = 0;
+    statusImpl = async () => { n++; if (n === 1) throw new Error("boom"); return okRes(); };
+    channel.reportStatus("dm-1", "working");
+    channel.reportStatus("dm-1", "idle");
+    await waitFor(() => statusPosts.length === 2);
+    await tick();
+    expect(statusPosts).toEqual(["working", "idle"]);
+  });
+
+  // ------------------------------------------------ turn (integration) ----
+
+  it("a never-resolving status POST does not delay the turn: the reply is sent and the message acked", async () => {
+    statusImpl = () => new Promise(() => {});
+    const rt = makeRuntime();
+    rt.setDispatch(async (args) => { await args.dispatcherOptions.deliver({ text: "pong" }); });
+    const h = await startTurnHarness(rt.runtime);
+    h.deliverFrame("m-hang");
+    await waitFor(() => h.acks().includes("m-hang"));
+    expect(sends.map((s) => s.text)).toEqual(["pong"]);
+    expect(statusPosts).toEqual(["working"]); // idle is queued behind the hung POST, never concurrent
+  });
+
+  it("a failing status POST is logged and the turn is unaffected (reply sent, acked, idle still attempted)", async () => {
+    statusImpl = async () => ({ ok: false, status: 500, json: async () => ({}) });
+    const rt = makeRuntime();
+    rt.setDispatch(async (args) => { await args.dispatcherOptions.deliver({ text: "pong" }); });
+    const h = await startTurnHarness(rt.runtime);
+    h.deliverFrame("m-500");
+    await waitFor(() => h.acks().includes("m-500"));
+    await waitFor(() => statusPosts.length === 2);
+    expect(sends.map((s) => s.text)).toEqual(["pong"]);
+    expect(statusPosts).toEqual(["working", "idle"]);
+    await waitFor(() => logs.includes("[securecoms] status idle failed http=500"));
+    expect(logs).toContain("[securecoms] status working failed http=500");
+  });
+
+  it("idle waits for a deliver still in flight when dispatch returns early, then is sent once it settles", async () => {
+    const sendGate = deferred<unknown>();
+    sendImpl = () => sendGate.promise;
+    const rt = makeRuntime();
+    // Dispatch hands a block to deliver and returns WITHOUT awaiting it.
+    rt.setDispatch(async (args) => { void args.dispatcherOptions.deliver({ text: "late reply" }); });
+    const h = await startTurnHarness(rt.runtime);
+    h.deliverFrame("m-early");
+    await waitFor(() => sends.length === 1);
+    await waitFor(() => logs.some((m) => m.startsWith("[securecoms] turn dispatch_ms=")));
+    await tick(50);
+    expect(statusPosts).toEqual(["working"]); // no idle while the reply is still being published
+
+    sendGate.resolve({ ok: true, status: 200, json: async () => ({ message_id: "r" }) });
+    await waitFor(() => statusPosts.length === 2);
+    expect(statusPosts).toEqual(["working", "idle"]);
+  });
+
+  it("idle is still sent when a pending deliver fails", async () => {
+    const sendGate = deferred<unknown>();
+    sendImpl = () => sendGate.promise;
+    const rt = makeRuntime();
+    rt.setDispatch(async (args) => { void args.dispatcherOptions.deliver({ text: "x" }).catch(() => {}); });
+    const h = await startTurnHarness(rt.runtime);
+    h.deliverFrame("m-fail");
+    await waitFor(() => sends.length === 1);
+    await tick(30);
+    expect(statusPosts).toEqual(["working"]);
+    sendGate.reject(new Error("send exploded"));
+    await waitFor(() => statusPosts.length === 2);
+    expect(statusPosts).toEqual(["working", "idle"]);
+  });
+
+  it("idle is still sent when dispatch throws (unchanged error behavior)", async () => {
+    const rt = makeRuntime();
+    rt.setDispatch(async () => { throw new Error("model exploded"); });
+    const h = await startTurnHarness(rt.runtime);
+    h.deliverFrame("m-throw");
+    await waitFor(() => statusPosts.length === 2);
+    expect(statusPosts).toEqual(["working", "idle"]);
+    expect(h.acks()).not.toContain("m-throw");
+  });
+
+  it("logs the dispatch duration and delivered block count once per turn", async () => {
+    const rt = makeRuntime();
+    rt.setDispatch(async (args) => {
+      await args.dispatcherOptions.deliver({ text: "one" });
+      await args.dispatcherOptions.deliver({ kind: "thinking", text: "hidden" });
+      await args.dispatcherOptions.deliver({ text: "two" });
+    });
+    const h = await startTurnHarness(rt.runtime);
+    h.deliverFrame("m-log");
+    await waitFor(() => h.acks().includes("m-log"));
+    const lines = logs.filter((m) => m.startsWith("[securecoms] turn "));
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toMatch(/^\[securecoms\] turn dispatch_ms=\d+ delivered_blocks=2 pending_deliveries=0$/);
+  });
+
+  it("two quick turns on one channel end with working then idle, idle last", async () => {
+    const rt = makeRuntime();
+    rt.setDispatch(async (args) => { await args.dispatcherOptions.deliver({ text: "r" }); });
+    const ep = makeStatusEndpoint();
+    statusImpl = ep.handle;
+    const h = await startTurnHarness(rt.runtime);
+    h.deliverFrame("t1");
+    h.deliverFrame("t2");
+    await waitFor(() => h.acks().length === 2);
+    // Settle whatever is on the wire until the channel is drained.
+    for (let i = 0; i < 6; i++) {
+      for (const p of ep.posts) p.settle.resolve(okRes());
+      await tick();
+    }
+    expect(ep.maxInFlight).toBe(1);
+    expect(ep.posts[0].state).toBe("working");
+    expect(ep.posts.at(-1)?.state).toBe("idle");
+    expect(ep.posts.map((p) => p.state)).toEqual(["working", "idle"]);
+  });
+});

package/dist/bin.js

@@ -28583,6 +28583,13 @@ function assertManagedName(name) {
   if (!name || name.includes("/") || name.includes("\\") || name === "." || name === ".." || name !== basename2(name)) {
     throw new Error(`refusing managed config file name ${JSON.stringify(name)}: not a plain filename`);
   }
+  if (isLocalOnlyName(name)) {
+    throw new Error(`refusing managed config file name ${JSON.stringify(name)}: reserved for a local writer`);
+  }
+}
+function isLocalOnlyName(name) {
+  const n = name.toLowerCase().replace(/[. ]+$/, "");
+  return n === "llm.key" || n.startsWith("llm.key.") || n === "local-config.json";
 }
 function atomicWrite(path, body, deps) {
   const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;

package/dist/index.js

@@ -28432,6 +28432,13 @@ function assertManagedName(name) {
   if (!name || name.includes("/") || name.includes("\\") || name === "." || name === ".." || name !== basename2(name)) {
     throw new Error(`refusing managed config file name ${JSON.stringify(name)}: not a plain filename`);
   }
+  if (isLocalOnlyName(name)) {
+    throw new Error(`refusing managed config file name ${JSON.stringify(name)}: reserved for a local writer`);
+  }
+}
+function isLocalOnlyName(name) {
+  const n = name.toLowerCase().replace(/[. ]+$/, "");
+  return n === "llm.key" || n.startsWith("llm.key.") || n === "local-config.json";
 }
 function atomicWrite(path, body, deps) {
   const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const BRIDGE_VERSION = "0.25.0";
+export declare const BRIDGE_VERSION = "0.25.2";

package/package.json

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