@botcord/daemon 0.2.4 → 0.2.6

package/src/daemon.ts

@@ -1,7 +1,12 @@
-import { CONTROL_FRAME_TYPES } from "@botcord/protocol-core";
+import {
+  CONTROL_FRAME_TYPES,
+  shouldWake,
+  type AttentionPolicy,
+} from "@botcord/protocol-core";
 import {
   Gateway,
   createBotCordChannel,
+  resolveTranscriptEnabled,
   sanitizeUntrustedContent,
   type ChannelAdapter,
   type GatewayChannelConfig,
@@ -31,6 +36,8 @@ import {
 } from "./loop-risk.js";
 import { composeBotCordUserTurn } from "./turn-text.js";
 import { UserAuthManager } from "./user-auth.js";
+import { PolicyResolver } from "./gateway/policy-resolver.js";
+import { scanMention } from "./mention-scan.js";
 
 /**
  * Matches the 10-minute turn timeout the legacy daemon dispatcher used, so
@@ -222,6 +229,18 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
 
   const gwConfig = toGatewayConfig(opts.config, { agentIds, agentRuntimes });
 
+  // Per-agent hub URL — read from each credential file at boot. Used to
+  // populate `BOTCORD_HUB` for runtime CLI subprocesses so the bundled
+  // `botcord` CLI talks to the same hub the agent is registered against,
+  // even when a single daemon hosts agents from different hubs.
+  const hubUrlByAgentId = new Map<string, string>();
+  for (const a of boot.agents) {
+    if (a.hubUrl) hubUrlByAgentId.set(a.agentId, a.hubUrl);
+  }
+  const fallbackHubUrl = opts.hubBaseUrl;
+  const resolveHubUrl = (accountId: string): string | undefined =>
+    hubUrlByAgentId.get(accountId) ?? fallbackHubUrl;
+
   // ActivityTracker lives at the daemon layer (not the gateway core). We
   // expose it to the gateway via (a) the `buildSystemContext` hook so the
   // cross-room digest reflects current activity, and (b) the `onInbound`
@@ -319,6 +338,40 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     });
   };
 
+  // Per-agent attention policy cache (PR3, design §4.2 / §5). Seeded from
+  // the optional `defaultAttention` / `attentionKeywords` carried by
+  // `provision_agent`, refreshed in-place by the `policy_updated` control
+  // frame. PR2 will plug per-room overrides into `fetchEffective`; PR3
+  // leaves it absent so the resolver collapses to per-agent state.
+  const policyResolver = new PolicyResolver({
+    fetchGlobal: async (_agentId: string) => undefined,
+  });
+
+  // Display-name lookup for the mention text-fallback. Populated from boot
+  // credentials; multi-agent daemons can reuse the same map via accountId.
+  const displayNameByAgent = new Map<string, string>();
+  for (const a of boot.agents) {
+    if (a.displayName) displayNameByAgent.set(a.agentId, a.displayName);
+  }
+
+  // Attention gate: compose `messages.mentioned` (sender-supplied — distrust)
+  // with a local `@<display_name>` / `@<agent_id>` text scan, resolve the
+  // effective policy, then defer to the protocol-core `shouldWake` decision.
+  const attentionGate = async (msg: GatewayInboundMessage): Promise<boolean> => {
+    const policy: AttentionPolicy = await policyResolver.resolve(
+      msg.accountId,
+      msg.conversation.id,
+    );
+    const localMention = scanMention(msg.text, {
+      agentId: msg.accountId,
+      displayName: displayNameByAgent.get(msg.accountId),
+    });
+    return shouldWake(policy, {
+      mentioned: msg.mentioned === true || localMention,
+      text: msg.text,
+    });
+  };
+
   const gateway = new Gateway({
     config: gwConfig,
     sessionStorePath: opts.sessionStorePath ?? SESSIONS_PATH,
@@ -340,6 +393,12 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     onInbound,
     onOutbound,
     composeUserTurn: composeBotCordUserTurn,
+    attentionGate,
+    resolveHubUrl,
+    transcriptEnabled: resolveTranscriptEnabled(
+      process.env.BOTCORD_TRANSCRIPT,
+      opts.config.transcript?.enabled === true,
+    ),
   });
 
   logger.info("daemon starting", {
@@ -356,7 +415,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     logger.warn("daemon starting with no channels", {
       source: boot.source,
       credentialsDir: boot.credentialsDir,
-      hint: "drop a credentials JSON in the discovery dir and restart, or run `botcord-daemon init --agent <ag_xxx>`",
+      hint: "drop a credentials JSON in the discovery dir and restart, or run `botcord-daemon start --agent <ag_xxx>` (only seeds config on first run)",
     });
   }
 
@@ -376,7 +435,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
       userId: userAuth.current.userId,
       hubUrl: userAuth.current.hubUrl,
     });
-    const provisioner = createProvisioner({ gateway });
+    const provisioner = createProvisioner({ gateway, policyResolver });
     controlChannel = new ControlChannel({
       auth: userAuth,
       handle: provisioner,
@@ -443,7 +502,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
  */
 export interface BootBackfillResult {
   credentialPathByAgentId: Map<string, string>;
-  agentRuntimes: Record<string, { runtime?: string; cwd?: string }>;
+  agentRuntimes: Record<string, { runtime?: string; cwd?: string; openclawGateway?: string; openclawAgent?: string }>;
 }
 
 /**
@@ -466,10 +525,12 @@ export function backfillBootAgents(
   const failed: string[] = [];
   for (const a of agents) {
     if (a.credentialsFile) credentialPathByAgentId.set(a.agentId, a.credentialsFile);
-    if (a.runtime || a.cwd) {
+    if (a.runtime || a.cwd || a.openclawGateway || a.openclawAgent) {
       agentRuntimes[a.agentId] = {
         ...(a.runtime ? { runtime: a.runtime } : {}),
         ...(a.cwd ? { cwd: a.cwd } : {}),
+        ...(a.openclawGateway ? { openclawGateway: a.openclawGateway } : {}),
+        ...(a.openclawAgent ? { openclawAgent: a.openclawAgent } : {}),
       };
     }
     // Seed files are written only when missing (see `ensureAgentWorkspace`),

package/src/doctor.ts

@@ -31,9 +31,34 @@ export interface DoctorHttpResult {
   error?: string;
 }
 
+/** One endpoint probe entry, mirrored from `RuntimeEndpointProbe`. */
+export interface DoctorRuntimeEndpoint {
+  name: string;
+  url: string;
+  reachable: boolean;
+  version?: string;
+  error?: string;
+  agents?: Array<{
+    id: string;
+    name?: string;
+    workspace?: string;
+    model?: { name?: string; provider?: string };
+  }>;
+  /**
+   * Optional warning surfaced by the doctor: e.g. botcord plugin loaded on
+   * the gateway (would form a daemon → openclaw → botcord → Hub loop).
+   */
+  warnings?: string[];
+}
+
+/** Augmented runtime entry that may carry endpoint probe results. */
+export interface DoctorRuntimeEntry extends RuntimeProbeEntry {
+  endpoints?: DoctorRuntimeEndpoint[];
+}
+
 /** Input for the rendered doctor output. */
 export interface DoctorInput {
-  runtimes: RuntimeProbeEntry[];
+  runtimes: DoctorRuntimeEntry[];
   channels: ChannelProbeResult[];
 }
 
@@ -226,10 +251,32 @@ export function renderDoctor(input: DoctorInput): string {
   lines.push(
     `${pad("RUNTIME", widths.runtime)}  ${pad("NAME", widths.name)}  ${pad("STATUS", widths.status)}  ${pad("VERSION", widths.version)}  PATH`,
   );
-  for (const r of rows) {
+  for (let i = 0; i < rows.length; i += 1) {
+    const r = rows[i];
+    const e = input.runtimes[i];
     lines.push(
       `${pad(r.runtime, widths.runtime)}  ${pad(r.name, widths.name)}  ${pad(r.status, widths.status)}  ${pad(r.version, widths.version)}  ${r.path}`,
     );
+    if (e.endpoints && e.endpoints.length > 0) {
+      for (const ep of e.endpoints) {
+        const mark = ep.reachable ? "✓" : "✗";
+        const detail = ep.reachable
+          ? ep.version ?? "ok"
+          : ep.error ?? "unreachable";
+        lines.push(`    gateway ${pad(`"${ep.name}"`, 16)} ${pad(ep.url, 40)} ${mark} ${detail}`);
+        if (ep.agents && ep.agents.length > 0) {
+          // RFC §3.8.4: list by `id` (stable key); show display name when distinct.
+          lines.push(
+            `      agents (id): ${ep.agents
+              .map((a) => (a.name && a.name !== a.id ? `${a.id} (${a.name})` : a.id))
+              .join(", ")}`,
+          );
+        }
+        if (ep.warnings) {
+          for (const w of ep.warnings) lines.push(`      WARN: ${w}`);
+        }
+      }
+    }
   }
   const available = input.runtimes.filter((e) => e.result.available).length;
   lines.push(`\n${available}/${input.runtimes.length} runtimes available`);

package/src/gateway/__tests__/dispatcher.test.ts

@@ -459,16 +459,19 @@ describe("Dispatcher", () => {
     });
     const { dispatcher, channel } = await scaffold({ config, runtimeFactory });
 
+    // Use an `rm_oc_` room so the dispatcher's reply gating does not drop
+    // the runtime text — non-owner-chat rooms intentionally suppress
+    // result.text since the agent is expected to use `botcord_send`.
     const p1 = dispatcher.handle(
       makeEnvelope({
         id: "m1",
-        conversation: { id: "rm_g1", kind: "group" },
+        conversation: { id: "rm_oc_g1", kind: "group" },
       }),
     );
     const p2 = dispatcher.handle(
       makeEnvelope({
         id: "m2",
-        conversation: { id: "rm_g1", kind: "group" },
+        conversation: { id: "rm_oc_g1", kind: "group" },
       }),
     );
     await Promise.all([p1, p2]);
@@ -1196,4 +1199,439 @@ describe("Dispatcher", () => {
       vi.useRealTimers();
     }
   });
+
+  // ─────────────────────────────────────────────────────────────────────
+  // Owner-chat reply gating
+  // ─────────────────────────────────────────────────────────────────────
+
+  it("non-owner-chat room: discards result.text, agent must use botcord_send", async () => {
+    const runtime = new FakeRuntime({ reply: "would-be-reply", newSessionId: "sid-1" });
+    const { dispatcher, channel, store } = await scaffold({
+      runtimeFactory: () => runtime,
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({
+        id: "msg_1",
+        conversation: { id: "rm_g_other", kind: "group" },
+      }),
+    );
+
+    expect(runtime.calls.length).toBe(1);
+    // Session is still persisted — only the channel send is gated.
+    expect(store.all().length).toBe(1);
+    expect(channel.sends.length).toBe(0);
+  });
+
+  it("non-owner-chat room: timeout reply is suppressed (logged only)", async () => {
+    vi.useFakeTimers();
+    try {
+      const runtime = new FakeRuntime({ hang: true });
+      const { dispatcher, channel } = await scaffold({
+        runtimeFactory: () => runtime,
+        turnTimeoutMs: 500,
+      });
+      const p = dispatcher.handle(
+        makeEnvelope({
+          id: "m_to",
+          conversation: { id: "rm_g_other", kind: "group" },
+        }),
+      );
+      await vi.advanceTimersByTimeAsync(501);
+      await p;
+      expect(runtime.calls[0].signal.aborted).toBe(true);
+      expect(channel.sends.length).toBe(0);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("non-owner-chat room: runtime error reply is suppressed", async () => {
+    const runtime = new FakeRuntime({ throwError: "boom" });
+    const { dispatcher, channel } = await scaffold({
+      runtimeFactory: () => runtime,
+    });
+    await dispatcher.handle(
+      makeEnvelope({
+        id: "m_err",
+        conversation: { id: "rm_g_other", kind: "group" },
+      }),
+    );
+    expect(channel.sends.length).toBe(0);
+  });
+
+  // ─────────────────────────────────────────────────────────────────────
+  // Serial coalesce-on-drain
+  // ─────────────────────────────────────────────────────────────────────
+
+  it("serial coalesce: messages arriving during a slow turn fold into ONE next turn", async () => {
+    let callNo = 0;
+    const runtimeFactory: RuntimeFactory = () => {
+      callNo += 1;
+      const tag = `r${callNo}`;
+      return new FakeRuntime({
+        id: "claude-code",
+        reply: tag,
+        delayMs: 30,
+        newSessionId: `sid-${callNo}`,
+      });
+    };
+    // Capture composer input so we can inspect what each turn was asked to render.
+    const composeCalls: Array<{ id: string; batchSize: number }> = [];
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const dispatcher = new Dispatcher({
+      config: baseConfig({
+        defaultRoute: { runtime: "claude-code", cwd: "/tmp/d", queueMode: "serial" },
+      }),
+      channels: new Map<string, ChannelAdapter>([[channel.id, channel]]),
+      runtime: runtimeFactory,
+      sessionStore: store,
+      log: silentLogger(),
+      composeUserTurn: (msg) => {
+        const raw = msg.raw as { batch?: unknown[] } | null | undefined;
+        const batch = Array.isArray(raw?.batch) ? raw!.batch : null;
+        composeCalls.push({ id: msg.id, batchSize: batch ? batch.length : 1 });
+        return msg.text ?? "";
+      },
+    });
+
+    // m1 arrives → triggers immediate turn.
+    const p1 = dispatcher.handle(
+      makeEnvelope({
+        id: "m1",
+        text: "hello",
+        raw: { hub_msg_id: "m1", text: "hello" },
+        conversation: { id: "rm_grp_x", kind: "group" },
+      }),
+    );
+    // Let the worker start runtime.run for m1.
+    await Promise.resolve();
+    await Promise.resolve();
+    // m2 + m3 arrive while m1 is in flight → buffered, must coalesce.
+    const p2 = dispatcher.handle(
+      makeEnvelope({
+        id: "m2",
+        text: "second",
+        raw: { hub_msg_id: "m2", text: "second" },
+        conversation: { id: "rm_grp_x", kind: "group" },
+      }),
+    );
+    const p3 = dispatcher.handle(
+      makeEnvelope({
+        id: "m3",
+        text: "third",
+        raw: { hub_msg_id: "m3", text: "third" },
+        conversation: { id: "rm_grp_x", kind: "group" },
+      }),
+    );
+    await Promise.all([p1, p2, p3]);
+
+    // Exactly two runtime turns: m1 alone, then a single coalesced turn merging m2+m3.
+    expect(callNo).toBe(2);
+    expect(composeCalls.length).toBe(2);
+    expect(composeCalls[0]).toEqual({ id: "m1", batchSize: 1 });
+    // Anchor of merged turn is the latest entry (m3); raw.batch holds both.
+    expect(composeCalls[1].id).toBe("m3");
+    expect(composeCalls[1].batchSize).toBe(2);
+    // Sends gated for non-owner-chat room.
+    expect(channel.sends.length).toBe(0);
+  });
+
+  it("serial coalesce: mentioned is OR'd across the merged batch", async () => {
+    let captured: { mentioned?: boolean } = {};
+    const runtimeFactory: RuntimeFactory = () =>
+      new FakeRuntime({ reply: "ok", delayMs: 20, newSessionId: "sid" });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const dispatcher = new Dispatcher({
+      config: baseConfig({
+        defaultRoute: { runtime: "claude-code", cwd: "/tmp/d", queueMode: "serial" },
+      }),
+      channels: new Map<string, ChannelAdapter>([[channel.id, channel]]),
+      runtime: runtimeFactory,
+      sessionStore: store,
+      log: silentLogger(),
+      composeUserTurn: (msg) => {
+        if (msg.id === "m_b") captured = { mentioned: msg.mentioned };
+        return msg.text ?? "";
+      },
+    });
+
+    const p1 = dispatcher.handle(
+      makeEnvelope({
+        id: "m_a",
+        text: "a",
+        mentioned: false,
+        conversation: { id: "rm_grp_y", kind: "group" },
+      }),
+    );
+    await Promise.resolve();
+    await Promise.resolve();
+    // Two new entries arrive during turn 1; one of them is mentioned.
+    const p2 = dispatcher.handle(
+      makeEnvelope({
+        id: "m_a2",
+        text: "a2",
+        mentioned: true,
+        conversation: { id: "rm_grp_y", kind: "group" },
+      }),
+    );
+    const p3 = dispatcher.handle(
+      makeEnvelope({
+        id: "m_b",
+        text: "b",
+        mentioned: false,
+        conversation: { id: "rm_grp_y", kind: "group" },
+      }),
+    );
+    await Promise.all([p1, p2, p3]);
+    expect(captured.mentioned).toBe(true);
+  });
+
+  it("serial coalesce: buffer overflow drops oldest entries (>40 backlog)", async () => {
+    let firstTurnDone!: () => void;
+    const firstTurnGate = new Promise<void>((resolve) => {
+      firstTurnDone = resolve;
+    });
+    let callNo = 0;
+    const runtimeFactory: RuntimeFactory = () => {
+      callNo += 1;
+      const tag = `r${callNo}`;
+      // Turn 1 hangs until firstTurnGate is resolved, so we can pile up the
+      // overflowing backlog while it's in flight. Turns 2+ just complete.
+      if (callNo === 1) {
+        return new FakeRuntime({
+          reply: tag,
+          newSessionId: `sid-${callNo}`,
+          observeRun: () => {
+            void firstTurnGate.then(() => undefined);
+          },
+        });
+      }
+      return new FakeRuntime({
+        reply: tag,
+        newSessionId: `sid-${callNo}`,
+        delayMs: 0,
+      });
+    };
+    const composedIds: string[][] = [];
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const dispatcher = new Dispatcher({
+      config: baseConfig({
+        defaultRoute: { runtime: "claude-code", cwd: "/tmp/d", queueMode: "serial" },
+      }),
+      channels: new Map<string, ChannelAdapter>([[channel.id, channel]]),
+      runtime: runtimeFactory,
+      sessionStore: store,
+      log: silentLogger(),
+      composeUserTurn: (msg) => {
+        const raw = msg.raw as { batch?: Array<{ hub_msg_id?: string }> } | null;
+        const ids = Array.isArray(raw?.batch)
+          ? raw!.batch!.map((b) => b.hub_msg_id ?? "?")
+          : [msg.id];
+        composedIds.push(ids);
+        return msg.text ?? "";
+      },
+    });
+    // Use a slow-runtime trigger that only resolves once we've enqueued
+    // enough overflow. Easier path: switch to delayMs and use timers.
+    // Simplification: just push 50 messages serially via Promise.all so that
+    // arrivals 2-50 buffer while arrival 1 is mid-run.
+    const arrivals: Array<Promise<void>> = [];
+    arrivals.push(
+      dispatcher.handle(
+        makeEnvelope({
+          id: "m_first",
+          text: "first",
+          raw: { hub_msg_id: "m_first", text: "first" },
+          conversation: { id: "rm_grp_overflow", kind: "group" },
+        }),
+      ),
+    );
+    // Yield twice so the worker observes the first entry and starts runtime.
+    await Promise.resolve();
+    await Promise.resolve();
+    // Push 50 more — backlog cap is 40, so the oldest 10 must be dropped.
+    for (let i = 0; i < 50; i++) {
+      arrivals.push(
+        dispatcher.handle(
+          makeEnvelope({
+            id: `m_${i}`,
+            text: `msg-${i}`,
+            raw: { hub_msg_id: `m_${i}`, text: `msg-${i}` },
+            conversation: { id: "rm_grp_overflow", kind: "group" },
+          }),
+        ),
+      );
+    }
+    // Release turn 1 so the worker drains the (capped) backlog.
+    firstTurnDone();
+    await Promise.all(arrivals);
+
+    // Two compose calls: first turn (m_first), second turn (40 surviving
+    // backlog entries — m_10 through m_49 if drop-oldest was applied).
+    expect(composedIds.length).toBe(2);
+    expect(composedIds[0]).toEqual(["m_first"]);
+    expect(composedIds[1].length).toBe(40);
+    expect(composedIds[1][0]).toBe("m_10");
+    expect(composedIds[1][39]).toBe("m_49");
+  });
+
+  it("serial coalesce: char-cap drops oldest individual messages from merged batch", async () => {
+    let callNo = 0;
+    const runtimeFactory: RuntimeFactory = () => {
+      callNo += 1;
+      const tag = `r${callNo}`;
+      return new FakeRuntime({
+        reply: tag,
+        newSessionId: `sid-${callNo}`,
+        // Turn 1 holds until released so turns 2-N pile up.
+        delayMs: callNo === 1 ? 50 : 0,
+      });
+    };
+    const composedItemCounts: number[] = [];
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const dispatcher = new Dispatcher({
+      config: baseConfig({
+        defaultRoute: { runtime: "claude-code", cwd: "/tmp/d", queueMode: "serial" },
+      }),
+      channels: new Map<string, ChannelAdapter>([[channel.id, channel]]),
+      runtime: runtimeFactory,
+      sessionStore: store,
+      log: silentLogger(),
+      composeUserTurn: (msg) => {
+        const raw = msg.raw as { batch?: unknown[] } | null;
+        const items = Array.isArray(raw?.batch) ? raw!.batch!.length : 1;
+        composedItemCounts.push(items);
+        return msg.text ?? "";
+      },
+    });
+    // Each pile-up message carries ~2000 chars; 20 messages = ~40000 chars,
+    // well over the 16000 cap. The merger must drop oldest until ≤16000.
+    const big = "x".repeat(2000);
+    const p0 = dispatcher.handle(
+      makeEnvelope({
+        id: "m_lead",
+        text: "lead",
+        raw: { hub_msg_id: "m_lead", text: "lead" },
+        conversation: { id: "rm_grp_chars", kind: "group" },
+      }),
+    );
+    await Promise.resolve();
+    await Promise.resolve();
+    const arrivals: Array<Promise<void>> = [p0];
+    for (let i = 0; i < 20; i++) {
+      arrivals.push(
+        dispatcher.handle(
+          makeEnvelope({
+            id: `mb_${i}`,
+            text: big,
+            raw: { hub_msg_id: `mb_${i}`, text: big },
+            conversation: { id: "rm_grp_chars", kind: "group" },
+          }),
+        ),
+      );
+    }
+    await Promise.all(arrivals);
+
+    // Two composer calls. The second is the merged drain — it must contain
+    // strictly fewer than 20 items because oldest were dropped to fit cap.
+    expect(composedItemCounts.length).toBe(2);
+    expect(composedItemCounts[0]).toBe(1);
+    expect(composedItemCounts[1]).toBeGreaterThan(0);
+    expect(composedItemCounts[1]).toBeLessThan(20);
+    // Cap is 16000 chars; each item is 2000 → at most 8 items survive.
+    expect(composedItemCounts[1]).toBeLessThanOrEqual(8);
+  });
+
+  it("attentionGate=false skips the runtime turn but still acks and runs onInbound (PR3)", async () => {
+    const runtime = new FakeRuntime();
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const channels = new Map<string, ChannelAdapter>([[channel.id, channel]]);
+    const accept = vi.fn(async () => {});
+    const onInbound = vi.fn();
+    const attentionGate = vi.fn(async () => false);
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels,
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      onInbound,
+      attentionGate,
+    });
+    await dispatcher.handle(makeEnvelope({ id: "m_gated", text: "hello" }, { accept }));
+    expect(accept).toHaveBeenCalledTimes(1);
+    expect(onInbound).toHaveBeenCalledTimes(1);
+    expect(attentionGate).toHaveBeenCalledTimes(1);
+    expect(runtime.calls.length).toBe(0);
+    expect(channel.sends.length).toBe(0);
+  });
+
+  it("attentionGate=true wakes the runtime as usual (PR3)", async () => {
+    const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const channels = new Map<string, ChannelAdapter>([[channel.id, channel]]);
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels,
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      attentionGate: () => true,
+    });
+    await dispatcher.handle(makeEnvelope({ id: "m_wake" }));
+    expect(runtime.calls.length).toBe(1);
+    expect(channel.sends.length).toBe(1);
+  });
+
+  it("attentionGate throwing fails open and runs the turn (PR3)", async () => {
+    const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
+    const { store, dir } = await makeStore();
+    tempDirs.push(dir);
+    const channel = new FakeChannel();
+    const channels = new Map<string, ChannelAdapter>([[channel.id, channel]]);
+    const dispatcher = new Dispatcher({
+      config: baseConfig(),
+      channels,
+      runtime: () => runtime,
+      sessionStore: store,
+      log: silentLogger(),
+      attentionGate: () => {
+        throw new Error("boom");
+      },
+    });
+    await dispatcher.handle(makeEnvelope({ id: "m_wake_throw" }));
+    expect(runtime.calls.length).toBe(1);
+  });
+
+  it("owner-chat detection: dashboard_user_chat in non-rm_oc room still sends reply", async () => {
+    const runtime = new FakeRuntime({ reply: "ok", newSessionId: "sid-1" });
+    const { dispatcher, channel } = await scaffold({
+      runtimeFactory: () => runtime,
+    });
+    await dispatcher.handle(
+      makeEnvelope({
+        id: "m_dash",
+        // Note: room id does NOT start with rm_oc_ but raw.source_type marks
+        // this as a dashboard user chat — must be treated as owner-chat by
+        // the gating predicate.
+        conversation: { id: "rm_dashroom", kind: "direct" },
+        raw: { source_type: "dashboard_user_chat" },
+      }),
+    );
+    expect(channel.sends.length).toBe(1);
+    expect(channel.sends[0].message.text).toBe("ok");
+  });
 });