@circuitwall/jarela 0.7.2 → 0.7.3

package/lib/agents/context-budget.ts

@@ -0,0 +1,128 @@
+import type { MessageRow } from "@/lib/stores/threads";
+import { transcriptText } from "@/lib/agents/conversation-summary";
+
+export type ContextTier = "hot" | "warm" | "facts";
+
+export type ContextTierPriority = [ContextTier, ContextTier, ContextTier];
+
+export interface ContextTierProportions {
+  hot?: number;
+  warm?: number;
+  facts?: number;
+}
+
+export interface ContextBudgetConfig {
+  context_window_tokens?: number;
+  max_tokens?: number;
+  context_tier_proportions?: ContextTierProportions;
+  context_tier_priority?: ContextTierPriority | readonly ContextTier[] | unknown;
+}
+
+export interface ContextBudget {
+  contextWindowTokens: number;
+  outputReserveTokens: number;
+  inputBudgetTokens: number;
+  overheadTokens: number;
+  tierBudgets: Record<ContextTier, number>;
+  tierPriority: ContextTierPriority;
+}
+
+const DEFAULT_CONTEXT_WINDOW_TOKENS = 8_192;
+const DEFAULT_OVERHEAD_TOKENS = 1_200;
+const DEFAULT_OUTPUT_RESERVE_RATIO = 0.2;
+const DEFAULT_TIER_PRIORITY: ContextTierPriority = ["hot", "warm", "facts"];
+const DEFAULT_TIER_PROPORTIONS: Required<ContextTierProportions> = {
+  hot: 0.6,
+  warm: 0.25,
+  facts: 0.15,
+};
+
+export function estimateTokens(text: string): number {
+  const trimmed = text.trim();
+  if (!trimmed) return 0;
+  return Math.max(1, Math.ceil(trimmed.length / 4));
+}
+
+export function normalizeTierPriority(value: ContextBudgetConfig["context_tier_priority"]): ContextTierPriority {
+  if (!Array.isArray(value)) return DEFAULT_TIER_PRIORITY;
+  const tiers = value.filter((v): v is ContextTier => v === "hot" || v === "warm" || v === "facts");
+  if (tiers.length !== 3) return DEFAULT_TIER_PRIORITY;
+  if (new Set(tiers).size !== 3) return DEFAULT_TIER_PRIORITY;
+  return [tiers[0], tiers[1], tiers[2]];
+}
+
+export function normalizeTierProportions(value: ContextTierProportions | undefined): Required<ContextTierProportions> {
+  const hot = toPositiveNumber(value?.hot, DEFAULT_TIER_PROPORTIONS.hot);
+  const warm = toPositiveNumber(value?.warm, DEFAULT_TIER_PROPORTIONS.warm);
+  const facts = toPositiveNumber(value?.facts, DEFAULT_TIER_PROPORTIONS.facts);
+  const sum = hot + warm + facts;
+  if (sum <= 0) return DEFAULT_TIER_PROPORTIONS;
+  return {
+    hot: hot / sum,
+    warm: warm / sum,
+    facts: facts / sum,
+  };
+}
+
+export function computeContextBudget(config: ContextBudgetConfig): ContextBudget {
+  const contextWindowTokens = Math.max(
+    1,
+    Math.floor(config.context_window_tokens ?? DEFAULT_CONTEXT_WINDOW_TOKENS),
+  );
+  const outputReserveTokens = Math.max(
+    256,
+    Math.min(
+      contextWindowTokens - 1,
+      Math.floor(config.max_tokens ?? contextWindowTokens * DEFAULT_OUTPUT_RESERVE_RATIO),
+    ),
+  );
+  const overheadTokens = Math.max(0, Math.min(DEFAULT_OVERHEAD_TOKENS, contextWindowTokens - outputReserveTokens));
+  const inputBudgetTokens = Math.max(0, contextWindowTokens - outputReserveTokens - overheadTokens);
+  const proportions = normalizeTierProportions(config.context_tier_proportions);
+  const tierPriority = normalizeTierPriority(config.context_tier_priority);
+  const tierBudgets = {
+    hot: Math.floor(inputBudgetTokens * proportions.hot),
+    warm: Math.floor(inputBudgetTokens * proportions.warm),
+    facts: Math.max(0, inputBudgetTokens - Math.floor(inputBudgetTokens * proportions.hot) - Math.floor(inputBudgetTokens * proportions.warm)),
+  } satisfies Record<ContextTier, number>;
+
+  return {
+    contextWindowTokens,
+    outputReserveTokens,
+    inputBudgetTokens,
+    overheadTokens,
+    tierBudgets,
+    tierPriority,
+  };
+}
+
+export function takeRecentMessagesWithinBudget(messages: readonly MessageRow[], tokenBudget: number): MessageRow[] {
+  if (tokenBudget <= 0 || messages.length === 0) return [];
+  const chosen: MessageRow[] = [];
+  let used = 0;
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i];
+    const tokens = estimateTokens(transcriptText(msg.content));
+    if (chosen.length > 0 && used + tokens > tokenBudget) break;
+    chosen.push(msg);
+    used += tokens;
+    if (used >= tokenBudget) break;
+  }
+  return chosen.reverse();
+}
+
+export function formatContextBudgetSummary(budget: ContextBudget): string {
+  const parts = [
+    `window ${budget.contextWindowTokens} tokens`,
+    `output reserve ${budget.outputReserveTokens}`,
+    `input budget ${budget.inputBudgetTokens}`,
+    `hot ${budget.tierBudgets.hot}`,
+    `warm ${budget.tierBudgets.warm}`,
+    `facts ${budget.tierBudgets.facts}`,
+  ];
+  return parts.join(" · ");
+}
+
+function toPositiveNumber(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}

package/lib/agents/conversation-summary.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from "vitest";
+import { summarizeTranscript, transcriptText } from "./conversation-summary";
+import type { ModelProvider, ProviderMessage, ProviderParams } from "@/lib/providers/types";
+
+describe("transcriptText", () => {
+  it("returns plain text unchanged", () => {
+    expect(transcriptText("hello")).toBe("hello");
+  });
+
+  it("flattens content parts and stubs attachments", () => {
+    const raw = JSON.stringify([
+      { type: "text", text: "hello" },
+      { type: "image", media_type: "image/png", data: "a" },
+      { type: "file", name: "report.pdf", media_type: "application/pdf", data: "b" },
+    ]);
+    expect(transcriptText(raw)).toContain("hello");
+    expect(transcriptText(raw)).toContain("[image attachment: image/png]");
+    expect(transcriptText(raw)).toContain("[file attachment: report.pdf (application/pdf)]");
+  });
+
+  it("falls back to raw when JSON is malformed", () => {
+    expect(transcriptText("[not-json")).toBe("[not-json");
+  });
+});
+
+describe("summarizeTranscript", () => {
+  it("returns empty for empty transcript", async () => {
+    const provider = {
+      chat: vi.fn(),
+    } as unknown as Pick<ModelProvider, "chat">;
+    const out = await summarizeTranscript(provider, "m", {}, "   ");
+    expect(out).toBe("");
+    expect(provider.chat).not.toHaveBeenCalled();
+  });
+
+  it("streams chunks and trims final summary", async () => {
+    const chat = vi.fn(async (_modelId: string, _messages: ProviderMessage[], _params: ProviderParams) => {
+      async function* gen() {
+        yield "  first";
+        yield " second  ";
+      }
+      return { stream: gen() };
+    });
+
+    const provider = { chat } as unknown as Pick<ModelProvider, "chat">;
+    const out = await summarizeTranscript(provider, "model-x", { max_tokens: 100 }, "conversation");
+    expect(out).toBe("first second");
+    expect(chat).toHaveBeenCalledTimes(1);
+  });
+
+  it("sends summarizer system prompt and transcript payload", async () => {
+    const chat = vi.fn(async (_modelId: string, messages: ProviderMessage[], _params: ProviderParams) => {
+      expect(messages[0].role).toBe("system");
+      expect(String(messages[0].content)).toContain("concise summarizer");
+      expect(messages[1].role).toBe("user");
+      expect(String(messages[1].content)).toContain("Conversation to summarize");
+      expect(String(messages[1].content)).toContain("alpha beta");
+      async function* gen() {
+        yield "ok";
+      }
+      return { stream: gen() };
+    });
+
+    const provider = { chat } as unknown as Pick<ModelProvider, "chat">;
+    const out = await summarizeTranscript(provider, "model-x", {}, "alpha beta");
+    expect(out).toBe("ok");
+  });
+});

package/lib/agents/conversation-summary.ts

@@ -0,0 +1,51 @@
+import type { ContentPart } from "@/lib/tools/types";
+import type { ModelProvider, ProviderMessage, ProviderParams } from "@/lib/providers/types";
+
+export function transcriptText(raw: string): string {
+  if (!raw.startsWith("[")) return raw;
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return raw;
+    return (parsed as ContentPart[])
+      .map((p) => {
+        if (p.type === "text") return p.text;
+        if (p.type === "image") return `[image attachment: ${p.media_type}]`;
+        if (p.type === "file") return `[file attachment: ${p.name} (${p.media_type})]`;
+        return "";
+      })
+      .filter(Boolean)
+      .join(" ")
+      .trim();
+  } catch {
+    return raw;
+  }
+}
+
+function summaryMessages(transcript: string): ProviderMessage[] {
+  return [
+    {
+      role: "system",
+      content:
+        "You are a concise summarizer. Summarize the conversation below in 3-7 bullet points, capturing key facts, decisions, and context that would be useful to remember later.",
+    },
+    {
+      role: "user",
+      content: `Conversation to summarize:\n\n${transcript}`,
+    },
+  ];
+}
+
+export async function summarizeTranscript(
+  provider: Pick<ModelProvider, "chat">,
+  modelId: string,
+  providerParams: ProviderParams,
+  transcript: string,
+): Promise<string> {
+  const trimmed = transcript.trim();
+  if (!trimmed) return "";
+
+  const { stream } = await provider.chat(modelId, summaryMessages(trimmed), providerParams);
+  let summary = "";
+  for await (const chunk of stream) summary += chunk;
+  return summary.trim();
+}

package/lib/agents/run-thread.ts

@@ -13,6 +13,12 @@ import { resolveHarness } from "@/lib/agents/harness/resolve";
 import { validateAssistantOutput } from "@/lib/agents/output-validator";
 import { getAppName } from "@/lib/env/app-config";
 import os from "node:os";
+import { computeContextBudget, formatContextBudgetSummary, takeRecentMessagesWithinBudget } from "@/lib/agents/context-budget";
+import { listMemory } from "@/lib/stores/memory";
+import { summarizeTranscript, transcriptText } from "@/lib/agents/conversation-summary";
+import { getDefaultModelConfig, getModelConfig } from "@/lib/stores/model-config";
+import { getProvider } from "@/lib/providers";
+import type { ProviderParams } from "@/lib/providers/types";
 
 // Resolve the app name once at module load. Forks set NEXT_PUBLIC_APP_NAME to
 // rebrand the user-visible name the LLM echoes in chat replies; default
@@ -145,7 +151,35 @@ export async function prepareThreadRun(
   const sinceISO = windowHours > 0
     ? new Date(Date.now() - windowHours * 3600_000).toISOString()
     : undefined;
-  const history = getRecentMessagesWindow(thread_id, limit, sinceISO).map((m) => ({
+  const allWindowMessages = getRecentMessagesWindow(thread_id, limit, sinceISO);
+
+  const modelCfg = agentCfg.model_config_name
+    ? getModelConfig(agentCfg.model_config_name)
+    : getDefaultModelConfig();
+  let providerParams: ProviderParams = {};
+  if (modelCfg) {
+    try {
+      providerParams = JSON.parse(modelCfg.params) as ProviderParams;
+    } catch {
+      providerParams = {};
+    }
+  }
+
+  const budget = computeContextBudget({
+    context_window_tokens:
+      typeof providerParams.context_window_tokens === "number"
+        ? providerParams.context_window_tokens
+        : undefined,
+    max_tokens: typeof providerParams.max_tokens === "number" ? providerParams.max_tokens : undefined,
+    context_tier_proportions:
+      typeof providerParams.context_tier_proportions === "object" && providerParams.context_tier_proportions
+        ? (providerParams.context_tier_proportions as { hot?: number; warm?: number; facts?: number })
+        : undefined,
+    context_tier_priority: providerParams.context_tier_priority,
+  });
+
+  const hotMessages = takeRecentMessagesWithinBudget(allWindowMessages, budget.tierBudgets.hot);
+  const history = hotMessages.map((m) => ({
     role: m.role as "user" | "assistant",
     content: parseContent(m.content),
   }));
@@ -253,12 +287,32 @@ export async function prepareThreadRun(
   const memoryCtx = [
     "--- Memory & recall ---",
     "You have long-term memory across sessions and a fresh recall pass on every turn.",
-    `- The recent ${limit} messages from the last ${windowHours}h are already in your context above.`,
+    `- Hot conversation history is budgeted by model context size: ${formatContextBudgetSummary(budget)}.`,
     "- A semantic search over all stored memory entries + past chat messages was run against the user's turn; matching items appear under \"Relevant context\" below.",
     "- Use memory_write proactively when the user shares a fact, preference, or decision worth remembering. Use memory_read / memory_list to recall stored facts on demand.",
     "- If you want detail from outside the recent window, the user can scroll up — but for facts you've stored explicitly, prefer recall over guessing.",
   ].join("\n");
 
+  const warmSummaryCtx = await buildWarmSummaryContext(
+    allWindowMessages,
+    hotMessages.length,
+    modelCfg?.provider,
+    modelCfg?.model_id,
+    providerParams,
+    budget.tierBudgets.warm,
+  );
+
+  const factsCtx = buildFactsContext(trimmed, budget.tierBudgets.facts);
+
+  const tierCtxByName = {
+    hot: "",
+    warm: warmSummaryCtx,
+    facts: factsCtx,
+  } as const;
+  const tierOrderCtx = budget.tierPriority
+    .map((tier) => tierCtxByName[tier])
+    .filter(Boolean);
+
   // Semantic recall: pull in long-term memory + past messages relevant to this turn.
   // Skip messages from the current thread that are already in the windowed history.
   // Capped at RECALL_BUDGET_MS — if the embedding round-trip is slower than
@@ -287,6 +341,7 @@ export async function prepareThreadRun(
     envCtx,
     harnessParts.self_config,
     memoryCtx,
+    ...tierOrderCtx,
     recallCtx,
   ].filter(Boolean);
   let allowedTools: string[] = [];
@@ -310,6 +365,61 @@ export async function prepareThreadRun(
   };
 }
 
+async function buildWarmSummaryContext(
+  allWindowMessages: readonly { role: string; content: string }[],
+  hotCount: number,
+  providerName: string | undefined,
+  modelId: string | undefined,
+  providerParams: ProviderParams,
+  warmBudgetTokens: number,
+): Promise<string> {
+  if (warmBudgetTokens <= 32) return "";
+  if (!providerName || !modelId) return "";
+  const warmMessages = allWindowMessages.slice(0, Math.max(0, allWindowMessages.length - hotCount));
+  if (warmMessages.length < 2) return "";
+
+  // Keep summary input bounded by the warm budget to avoid recursive prompt bloat.
+  const summaryInputChars = Math.max(0, warmBudgetTokens * 4);
+  const transcript = warmMessages
+    .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${transcriptText(m.content)}`)
+    .join("\n\n")
+    .slice(-summaryInputChars);
+  if (!transcript.trim()) return "";
+
+  try {
+    const provider = getProvider(providerName);
+    const summary = await summarizeTranscript(provider, modelId, providerParams, transcript);
+    if (!summary) return "";
+    return [
+      "--- Warm context summary ---",
+      "Compressed recap of earlier messages outside the hot window:",
+      summary,
+    ].join("\n");
+  } catch {
+    return "";
+  }
+}
+
+function buildFactsContext(query: string, factsBudgetTokens: number): string {
+  if (factsBudgetTokens <= 16) return "";
+  const charBudget = factsBudgetTokens * 4;
+  const rows = listMemory("facts", query.slice(0, 120), 12);
+  if (rows.length === 0) return "";
+
+  const lines = [
+    "--- Facts memory ---",
+    "Durable fact entries from memory_store namespace=facts:",
+  ];
+  let used = 0;
+  for (const row of rows) {
+    const line = `- ${row.key}: ${String(row.value).slice(0, 220)}`;
+    if (used > 0 && used + line.length > charBudget) break;
+    lines.push(line);
+    used += line.length;
+  }
+  return lines.length > 2 ? lines.join("\n") : "";
+}
+
 // Wraps the raw agent stream with stall-retry logic. Chunks pass through
 // LIVE to the consumer (so the chat UI sees deltas as they arrive); we only
 // hold the terminal `done` chunk so we can decide whether to retry. If the

package/lib/bridges/dispatcher.test.ts

@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { BridgeAdapter, InboundMessage } from "./types";
+
+const resolveRouteMock = vi.fn();
+const getAgentConfigMock = vi.fn();
+const getOrCreateAgentThreadMock = vi.fn();
+const prepareThreadRunMock = vi.fn();
+const collectStreamMock = vi.fn();
+const persistAssistantMessageMock = vi.fn();
+const publishNotificationMock = vi.fn();
+const formatBridgePromptMock = vi.fn();
+
+vi.mock("./router", () => ({
+  resolveRoute: (...args: unknown[]) => resolveRouteMock(...args),
+}));
+
+vi.mock("@/lib/stores/agent-configs", () => ({
+  getAgentConfig: (...args: unknown[]) => getAgentConfigMock(...args),
+}));
+
+vi.mock("@/lib/stores/threads", () => ({
+  getOrCreateAgentThread: (...args: unknown[]) => getOrCreateAgentThreadMock(...args),
+}));
+
+vi.mock("@/lib/agents/run-thread", () => ({
+  prepareThreadRun: (...args: unknown[]) => prepareThreadRunMock(...args),
+  persistAssistantMessage: (...args: unknown[]) => persistAssistantMessageMock(...args),
+}));
+
+vi.mock("@/lib/agents/stream-collector", () => ({
+  collectStream: (...args: unknown[]) => collectStreamMock(...args),
+}));
+
+vi.mock("@/lib/notifications/bus", () => ({
+  publish: (...args: unknown[]) => publishNotificationMock(...args),
+}));
+
+vi.mock("./message-role", () => ({
+  formatBridgePrompt: (...args: unknown[]) => formatBridgePromptMock(...args),
+}));
+
+const { handleInboundMessage } = await import("./dispatcher");
+
+function makeAdapter(): BridgeAdapter {
+  return {
+    bridge_id: "b1",
+    start: vi.fn(async () => {}),
+    stop: vi.fn(async () => {}),
+    sendText: vi.fn(async () => {}),
+    sendTyping: vi.fn(async () => {}),
+    resetAuth: vi.fn(async () => {}),
+    onInboundMessage: vi.fn(() => {}),
+    onStatusChange: vi.fn(() => {}),
+    listChats: vi.fn(() => []),
+    refreshChats: vi.fn(async () => {}),
+    lookupChat: vi.fn(async () => null),
+  };
+}
+
+function makeMessage(): InboundMessage {
+  return {
+    remote_jid: "chat@jid",
+    push_name: "Alice",
+    chat_name: "Family",
+    sender_name: "Bob",
+    text: "hello",
+    attachments: undefined,
+    message_id: "m1",
+    is_group: true,
+    participant_jid: "bob@jid",
+    role: "counterpart",
+  };
+}
+
+describe("handleInboundMessage silent observer mode", () => {
+  beforeEach(() => {
+    resolveRouteMock.mockReset();
+    getAgentConfigMock.mockReset();
+    getOrCreateAgentThreadMock.mockReset();
+    prepareThreadRunMock.mockReset();
+    collectStreamMock.mockReset();
+    persistAssistantMessageMock.mockReset();
+    publishNotificationMock.mockReset();
+    formatBridgePromptMock.mockReset();
+
+    resolveRouteMock.mockReturnValue({
+      bridge_id: "b1",
+      remote_jid: "chat@jid",
+      agent_id: "a1",
+      silent_mode: 1,
+      respond_to: "counterpart",
+    });
+    getAgentConfigMock.mockReturnValue({ id: "a1" });
+    getOrCreateAgentThreadMock.mockReturnValue({ thread_id: "t1" });
+    prepareThreadRunMock.mockResolvedValue({ stream: {} });
+    formatBridgePromptMock.mockReturnValue("BRIDGE_PROMPT");
+  });
+
+  it("suppresses non-important NO_REPLY assistant output", async () => {
+    const adapter = makeAdapter();
+    const msg = makeMessage();
+    collectStreamMock.mockResolvedValue({ assistantContent: "NO_REPLY", usedTools: [], toolEvents: [] });
+
+    await handleInboundMessage(adapter, msg);
+
+    expect(prepareThreadRunMock).toHaveBeenCalled();
+    const promptArg = prepareThreadRunMock.mock.calls[0][1] as string;
+    expect(promptArg).toContain("BRIDGE_PROMPT");
+    expect(promptArg).toContain("[SILENT_BRIDGE]");
+    expect(promptArg).toContain("standing on the user's side");
+
+    expect(persistAssistantMessageMock).not.toHaveBeenCalled();
+    expect(adapter.sendText).not.toHaveBeenCalled();
+    expect(publishNotificationMock).not.toHaveBeenCalled();
+  });
+
+  it("keeps important in-app update while still suppressing outbound chat replies", async () => {
+    const adapter = makeAdapter();
+    const msg = makeMessage();
+    collectStreamMock.mockResolvedValue({
+      assistantContent: "Important: the group announced an urgent schedule change.",
+      usedTools: [],
+      toolEvents: [],
+    });
+
+    await handleInboundMessage(adapter, msg);
+
+    expect(persistAssistantMessageMock).toHaveBeenCalledTimes(1);
+    expect(adapter.sendText).not.toHaveBeenCalled();
+    expect(publishNotificationMock).toHaveBeenCalledTimes(1);
+    const payload = publishNotificationMock.mock.calls[0][0] as { preview: string };
+    expect(payload.preview).toContain("Important:");
+  });
+});

package/lib/bridges/dispatcher.ts

@@ -7,6 +7,17 @@ import { resolveRoute } from "./router";
 import { formatBridgePrompt } from "./message-role";
 import type { BridgeAdapter, InboundMessage } from "./types";
 
+const SILENT_BRIDGE_DIRECTIVE =
+  "[SILENT_BRIDGE] Observer mode is enabled for this route. You are standing on the user's side and monitoring events. " +
+  "Never behave like a participant in the external chat and never draft/imitate a direct chat reply. " +
+  "Write to the user only, as a concise report of important events, risks, or user-actionable changes. " +
+  "Keep tone informational (status/update summary), not conversational. " +
+  "If nothing important happened, reply with exactly the single token NO_REPLY and nothing else.";
+
+function isNoReply(text: string): boolean {
+  return /^\s*NO[_ ]?REPLY\b/i.test(text);
+}
+
 /**
  * Handle one inbound message from a bridge adapter:
  *   1. Resolve the chat → agent route. Unrouted → publish an advisory
@@ -63,9 +74,13 @@ export async function handleInboundMessage(
       sender_name: senderName,
       text: msg.text,
     });
+    const silent = route.silent_mode === 1;
+    const effectivePrompt = silent
+      ? `${promptText}\n\n${SILENT_BRIDGE_DIRECTIVE}`
+      : promptText;
     const prepared = await prepareThreadRun(
       thread.thread_id,
-      promptText,
+      effectivePrompt,
       undefined,
       msg.attachments,
       undefined,
@@ -88,8 +103,6 @@ export async function handleInboundMessage(
     // matches. Default 'counterpart' = agent answers the user's chat
     // partner / group members but stays quiet on the user's own messages.
     // 'user' = inverse — react only to what the paired user typed.
-    const silent = route.silent_mode === 1;
-
     // Show the "composing…" presence on the channel while we drain the
     // LLM stream. Refresh every ~8s because WhatsApp drops the indicator
     // after ~10s if not renewed. We always send a final "paused" in the
@@ -126,9 +139,12 @@ export async function handleInboundMessage(
       }
     }
 
-    persistAssistantMessage(thread.thread_id, assistantContent, usedTools, toolEvents, "bridge");
-
     const reply = assistantContent.trim();
+    const suppressAssistant = silent && (reply.length === 0 || isNoReply(reply));
+    if (!suppressAssistant) {
+      persistAssistantMessage(thread.thread_id, assistantContent, usedTools, toolEvents, "bridge");
+    }
+
     // Outbound reply gate: silent_mode (master switch) AND respond_to
     // (per-role trigger). Both must clear for a message to leave the
     // dispatcher. The WhatsApp adapter also re-checks `route.silent_mode`
@@ -143,17 +159,19 @@ export async function handleInboundMessage(
       }
     }
 
-    publishNotification({
-      type: "bridge_message_received",
-      bridge_id: adapter.bridge_id,
-      remote_jid: msg.remote_jid,
-      push_name: msg.push_name,
-      is_group: msg.is_group,
-      thread_id: thread.thread_id,
-      agent_id: agentId,
-      preview: reply.replace(/\s+/g, " ").slice(0, 120),
-      ts: Date.now(),
-    });
+    if (!silent || !suppressAssistant) {
+      publishNotification({
+        type: "bridge_message_received",
+        bridge_id: adapter.bridge_id,
+        remote_jid: msg.remote_jid,
+        push_name: msg.push_name,
+        is_group: msg.is_group,
+        thread_id: thread.thread_id,
+        agent_id: agentId,
+        preview: suppressAssistant ? "" : reply.replace(/\s+/g, " ").slice(0, 120),
+        ts: Date.now(),
+      });
+    }
   } catch (err) {
     const m = err instanceof Error ? err.message : String(err);
     console.error(`[bridge ${adapter.bridge_id}] dispatcher error on ${msg.remote_jid}:`, m);