@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/gateway/server-runtime-state.js

@@ -1,14 +1,14 @@
 import { WebSocketServer } from "ws";
 import { CANVAS_HOST_PATH } from "../canvas-host/a2ui.js";
 import { createCanvasHostHandler } from "../canvas-host/server.js";
-import { createGatewayHooksRequestHandler } from "./server/hooks.js";
-import { listenGatewayHttpServer } from "./server/http-listen.js";
 import { resolveGatewayListenHosts } from "./net.js";
-import { createGatewayPluginRequestHandler } from "./server/plugins-http.js";
 import { createGatewayBroadcaster } from "./server-broadcast.js";
-import { createChatRunState } from "./server-chat.js";
+import { createChatRunState, createToolEventRecipientRegistry, } from "./server-chat.js";
 import { MAX_PAYLOAD_BYTES } from "./server-constants.js";
 import { attachGatewayUpgradeHandler, createGatewayHttpServer } from "./server-http.js";
+import { createGatewayHooksRequestHandler } from "./server/hooks.js";
+import { listenGatewayHttpServer } from "./server/http-listen.js";
+import { createGatewayPluginRequestHandler } from "./server/plugins-http.js";
 export async function createGatewayRuntimeState(params) {
     let canvasHost = null;
     if (params.canvasHostEnabled) {
@@ -29,6 +29,10 @@ export async function createGatewayRuntimeState(params) {
             params.logCanvas.warn(`canvas host failed to start: ${String(err)}`);
         }
     }
+    // Create clients set before HTTP server so it can be passed to both
+    // createGatewayHttpServer (for canvas auth) and attachGatewayUpgradeHandler
+    const clients = new Set();
+    const { broadcast, broadcastToConnIds } = createGatewayBroadcaster({ clients });
     const handleHooksRequest = createGatewayHooksRequestHandler({
         deps: params.deps,
         getHooksConfig: params.hooksConfig,
@@ -46,8 +50,10 @@ export async function createGatewayRuntimeState(params) {
     for (const host of bindHosts) {
         const httpServer = createGatewayHttpServer({
             canvasHost,
+            clients,
             controlUiEnabled: params.controlUiEnabled,
             controlUiBasePath: params.controlUiBasePath,
+            controlUiRoot: params.controlUiRoot,
             openAiChatCompletionsEnabled: params.openAiChatCompletionsEnabled,
             openResponsesEnabled: params.openResponsesEnabled,
             openResponsesConfig: params.openResponsesConfig,
@@ -66,8 +72,9 @@ export async function createGatewayRuntimeState(params) {
             httpBindHosts.push(host);
         }
         catch (err) {
-            if (host === bindHosts[0])
+            if (host === bindHosts[0]) {
                 throw err;
+            }
             params.log.warn(`gateway: failed to bind loopback alias ${host}:${params.port} (${String(err)})`);
         }
     }
@@ -80,10 +87,14 @@ export async function createGatewayRuntimeState(params) {
         maxPayload: MAX_PAYLOAD_BYTES,
     });
     for (const server of httpServers) {
-        attachGatewayUpgradeHandler({ httpServer: server, wss, canvasHost });
+        attachGatewayUpgradeHandler({
+            httpServer: server,
+            wss,
+            canvasHost,
+            clients,
+            resolvedAuth: params.resolvedAuth,
+        });
     }
-    const clients = new Set();
-    const { broadcast } = createGatewayBroadcaster({ clients });
     const agentRunSeq = new Map();
     const dedupe = new Map();
     const chatRunState = createChatRunState();
@@ -93,6 +104,7 @@ export async function createGatewayRuntimeState(params) {
     const addChatRun = chatRunRegistry.add;
     const removeChatRun = chatRunRegistry.remove;
     const chatAbortControllers = new Map();
+    const toolEventRecipients = createToolEventRecipientRegistry();
     return {
         canvasHost,
         httpServer,
@@ -101,6 +113,7 @@ export async function createGatewayRuntimeState(params) {
         wss,
         clients,
         broadcast,
+        broadcastToConnIds,
         agentRunSeq,
         dedupe,
         chatRunState,
@@ -109,5 +122,6 @@ export async function createGatewayRuntimeState(params) {
         addChatRun,
         removeChatRun,
         chatAbortControllers,
+        toolEventRecipients,
     };
 }

package/dist/gateway/server-startup-memory.js

@@ -0,0 +1,16 @@
+import { resolveDefaultAgentId } from "../agents/agent-scope.js";
+import { resolveMemoryBackendConfig } from "../memory/backend-config.js";
+import { getMemorySearchManager } from "../memory/index.js";
+export async function startGatewayMemoryBackend(params) {
+    const agentId = resolveDefaultAgentId(params.cfg);
+    const resolved = resolveMemoryBackendConfig({ cfg: params.cfg, agentId });
+    if (resolved.backend !== "qmd" || !resolved.qmd) {
+        return;
+    }
+    const { manager, error } = await getMemorySearchManager({ cfg: params.cfg, agentId });
+    if (!manager) {
+        params.log.warn(`qmd memory startup initialization failed for agent "${agentId}": ${error ?? "unknown error"}`);
+        return;
+    }
+    params.log.info?.(`qmd memory startup initialization armed for agent "${agentId}"`);
+}

package/dist/gateway/server.impl.js

@@ -156,7 +156,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
     if (cfgAtStart.gateway?.tls?.enabled && !gatewayTls.enabled) {
         throw new Error(gatewayTls.error ?? "gateway tls: failed to enable");
     }
-    const { canvasHost, httpServer, httpServers, httpBindHosts, wss, clients, broadcast, agentRunSeq, dedupe, chatRunState, chatRunBuffers, chatDeltaSentAt, addChatRun, removeChatRun, chatAbortControllers, } = await createGatewayRuntimeState({
+    const { canvasHost, httpServer, httpServers, httpBindHosts, wss, clients, broadcast, agentRunSeq, dedupe, chatRunState, chatRunBuffers, chatDeltaSentAt, addChatRun, removeChatRun, chatAbortControllers, broadcastToConnIds, toolEventRecipients, } = await createGatewayRuntimeState({
         cfg: cfgAtStart,
         bindHost,
         port,
@@ -257,11 +257,13 @@ export async function startGatewayServer(port = 18789, opts = {}) {
     });
     const agentUnsub = onAgentEvent(createAgentEventHandler({
         broadcast,
+        broadcastToConnIds,
         nodeSendToSession,
         agentRunSeq,
         chatRunState,
         resolveSessionKeyForRun,
         clearAgentRunContext,
+        toolEventRecipients,
     }));
     const heartbeatUnsub = onHeartbeatEvent((evt) => {
         broadcast("heartbeat", evt, { dropIfSlow: true });
@@ -304,6 +306,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
             incrementPresenceVersion,
             getHealthVersion,
             broadcast,
+            broadcastToConnIds,
             nodeSendToSession,
             nodeSendToAllSubscribed,
             nodeSubscribe,
@@ -318,6 +321,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
             chatDeltaSentAt: chatRunState.deltaSentAt,
             addChatRun,
             removeChatRun,
+            registerToolEventRecipient: toolEventRecipients.add,
             dedupe,
             wizardSessions,
             findRunningWizard,

package/dist/gateway/session-utils.fs.js

@@ -2,6 +2,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { resolveSessionTranscriptPath } from "../config/sessions.js";
+import { resolveRequiredHomeDir } from "../infra/home-dir.js";
+import { extractToolCallNames, hasToolCall } from "../utils/transcript-tools.js";
 import { stripEnvelope } from "./chat-sanitize.js";
 export function readSessionMessages(sessionId, storePath, sessionFile) {
     const candidates = resolveSessionTranscriptCandidates(sessionId, storePath, sessionFile);
@@ -17,6 +19,22 @@ export function readSessionMessages(sessionId, storePath, sessionFile) {
             const parsed = JSON.parse(line);
             if (parsed?.message) {
                 messages.push(parsed.message);
+                continue;
+            }
+            // Compaction entries are not "message" records, but they're useful context for debugging.
+            // Emit a lightweight synthetic message that the Web UI can render as a divider.
+            if (parsed?.type === "compaction") {
+                const ts = typeof parsed.timestamp === "string" ? Date.parse(parsed.timestamp) : Number.NaN;
+                const timestamp = Number.isFinite(ts) ? ts : Date.now();
+                messages.push({
+                    role: "system",
+                    content: [{ type: "text", text: "Compaction" }],
+                    timestamp,
+                    __poolbot: {
+                        kind: "compaction",
+                        id: typeof parsed.id === "string" ? parsed.id : undefined,
+                    },
+                });
             }
         }
         catch {
@@ -36,7 +54,8 @@ export function resolveSessionTranscriptCandidates(sessionId, storePath, session
     if (agentId) {
         candidates.push(resolveSessionTranscriptPath(sessionId, agentId));
     }
-    candidates.push(path.join(os.homedir(), ".poolbot", "sessions", `${sessionId}.jsonl`));
+    const home = resolveRequiredHomeDir(process.env, os.homedir);
+    candidates.push(path.join(home, ".poolbot", "sessions", `${sessionId}.jsonl`));
     return candidates;
 }
 export function archiveFileOnDisk(filePath, reason) {
@@ -214,31 +233,10 @@ function extractPreviewText(message) {
     return null;
 }
 function isToolCall(message) {
-    if (message.toolName || message.tool_name)
-        return true;
-    if (!Array.isArray(message.content))
-        return false;
-    return message.content.some((entry) => {
-        if (entry?.name)
-            return true;
-        const raw = typeof entry?.type === "string" ? entry.type.toLowerCase() : "";
-        return raw === "toolcall" || raw === "tool_call";
-    });
+    return hasToolCall(message);
 }
 function extractToolNames(message) {
-    const names = [];
-    if (Array.isArray(message.content)) {
-        for (const entry of message.content) {
-            if (typeof entry?.name === "string" && entry.name.trim()) {
-                names.push(entry.name.trim());
-            }
-        }
-    }
-    const toolName = typeof message.toolName === "string" ? message.toolName : message.tool_name;
-    if (typeof toolName === "string" && toolName.trim()) {
-        names.push(toolName.trim());
-    }
-    return names;
+    return extractToolCallNames(message);
 }
 function extractMediaSummary(message) {
     if (!Array.isArray(message.content))
@@ -316,7 +314,7 @@ function readRecentMessagesFromTranscript(filePath, maxMessages, readBytes) {
                 // skip malformed lines
             }
         }
-        return collected.reverse();
+        return collected.toReversed();
     }
     catch {
         return [];

package/dist/gateway/session-utils.js

@@ -3,11 +3,12 @@ import path from "node:path";
 import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { lookupContextTokens } from "../agents/context.js";
 import { DEFAULT_CONTEXT_TOKENS, DEFAULT_MODEL, DEFAULT_PROVIDER } from "../agents/defaults.js";
-import { resolveConfiguredModelRef } from "../agents/model-selection.js";
+import { resolveConfiguredModelRef, resolveDefaultModelForAgent, } from "../agents/model-selection.js";
 import { loadConfig } from "../config/config.js";
 import { resolveStateDir } from "../config/paths.js";
 import { buildGroupDisplayName, canonicalizeMainSessionAlias, loadSessionStore, resolveMainSessionKey, resolveStorePath, } from "../config/sessions.js";
 import { normalizeAgentId, normalizeMainKey, parseAgentSessionKey, } from "../routing/session-key.js";
+import { isCronRunSessionKey } from "../sessions/session-key-utils.js";
 import { normalizeSessionDeliveryFields } from "../utils/delivery-context.js";
 import { readFirstUserMessageFromTranscript, readLastMessagePreviewFromTranscript, } from "./session-utils.fs.js";
 export { archiveFileOnDisk, capArrayByJsonBytes, readFirstUserMessageFromTranscript, readLastMessagePreviewFromTranscript, readSessionPreviewItemsFromTranscript, readSessionMessages, resolveSessionTranscriptCandidates, } from "./session-utils.fs.js";
@@ -374,12 +375,14 @@ export function getSessionDefaults(cfg) {
         contextTokens: contextTokens ?? null,
     };
 }
-export function resolveSessionModelRef(cfg, entry) {
-    const resolved = resolveConfiguredModelRef({
-        cfg,
-        defaultProvider: DEFAULT_PROVIDER,
-        defaultModel: DEFAULT_MODEL,
-    });
+export function resolveSessionModelRef(cfg, entry, agentId) {
+    const resolved = agentId
+        ? resolveDefaultModelForAgent({ cfg, agentId })
+        : resolveConfiguredModelRef({
+            cfg,
+            defaultProvider: DEFAULT_PROVIDER,
+            defaultModel: DEFAULT_MODEL,
+        });
     let provider = resolved.provider;
     let model = resolved.model;
     const storedModelOverride = entry?.modelOverride?.trim();
@@ -405,6 +408,8 @@ export function listSessionsFromStore(params) {
         : undefined;
     let sessions = Object.entries(store)
         .filter(([key]) => {
+        if (isCronRunSessionKey(key))
+            return false;
         if (!includeGlobal && key === "global")
             return false;
         if (!includeUnknown && key === "unknown")
@@ -458,6 +463,11 @@ export function listSessionsFromStore(params) {
             entry?.label ??
             originLabel;
         const deliveryFields = normalizeSessionDeliveryFields(entry);
+        const parsedAgent = parseAgentSessionKey(key);
+        const sessionAgentId = normalizeAgentId(parsedAgent?.agentId ?? resolveDefaultAgentId(cfg));
+        const resolvedModel = resolveSessionModelRef(cfg, entry, sessionAgentId);
+        const modelProvider = resolvedModel.provider ?? DEFAULT_PROVIDER;
+        const model = resolvedModel.model ?? DEFAULT_MODEL;
         return {
             key,
             entry,
@@ -483,8 +493,8 @@ export function listSessionsFromStore(params) {
             outputTokens: entry?.outputTokens,
             totalTokens: total,
             responseUsage: entry?.responseUsage,
-            modelProvider: entry?.modelProvider,
-            model: entry?.model,
+            modelProvider,
+            model,
             contextTokens: entry?.contextTokens,
             deliveryContext: deliveryFields.deliveryContext,
             lastChannel: deliveryFields.lastChannel ?? entry?.lastChannel,
@@ -492,7 +502,7 @@ export function listSessionsFromStore(params) {
             lastAccountId: deliveryFields.lastAccountId ?? entry?.lastAccountId,
         };
     })
-        .sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+        .toSorted((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
     if (search) {
         sessions = sessions.filter((s) => {
             const fields = [s.displayName, s.label, s.subject, s.sessionId, s.key];

package/dist/gateway/sessions-patch.js

@@ -1,9 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../agents/defaults.js";
-import { resolveAllowedModelRef, resolveConfiguredModelRef } from "../agents/model-selection.js";
+import { resolveAllowedModelRef, resolveDefaultModelForAgent } from "../agents/model-selection.js";
+import { resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { normalizeGroupActivation } from "../auto-reply/group-activation.js";
 import { formatThinkingLevels, formatXHighModelHint, normalizeElevatedLevel, normalizeReasoningLevel, normalizeThinkLevel, normalizeUsageDisplay, supportsXHighThinking, } from "../auto-reply/thinking.js";
-import { isSubagentSessionKey } from "../routing/session-key.js";
+import { isSubagentSessionKey, normalizeAgentId, parseAgentSessionKey, } from "../routing/session-key.js";
 import { applyVerboseOverride, parseVerboseOverride } from "../sessions/level-overrides.js";
 import { normalizeSendPolicy } from "../sessions/send-policy.js";
 import { parseSessionLabel } from "../sessions/session-label.js";
@@ -36,6 +36,9 @@ function normalizeExecAsk(raw) {
 export async function applySessionsPatchToStore(params) {
     const { cfg, store, storeKey, patch } = params;
     const now = Date.now();
+    const parsedAgent = parseAgentSessionKey(storeKey);
+    const sessionAgentId = normalizeAgentId(parsedAgent?.agentId ?? resolveDefaultAgentId(cfg));
+    const resolvedDefault = resolveDefaultModelForAgent({ cfg, agentId: sessionAgentId });
     const existing = store[storeKey];
     const next = existing
         ? {
@@ -89,19 +92,11 @@ export async function applySessionsPatchToStore(params) {
         else if (raw !== undefined) {
             const normalized = normalizeThinkLevel(String(raw));
             if (!normalized) {
-                const resolvedDefault = resolveConfiguredModelRef({
-                    cfg,
-                    defaultProvider: DEFAULT_PROVIDER,
-                    defaultModel: DEFAULT_MODEL,
-                });
                 const hintProvider = existing?.providerOverride?.trim() || resolvedDefault.provider;
                 const hintModel = existing?.modelOverride?.trim() || resolvedDefault.model;
                 return invalid(`invalid thinkingLevel (use ${formatThinkingLevels(hintProvider, hintModel, "|")})`);
             }
-            if (normalized === "off")
-                delete next.thinkingLevel;
-            else
-                next.thinkingLevel = normalized;
+            next.thinkingLevel = normalized;
         }
     }
     if ("verboseLevel" in patch) {
@@ -205,11 +200,6 @@ export async function applySessionsPatchToStore(params) {
     }
     if ("model" in patch) {
         const raw = patch.model;
-        const resolvedDefault = resolveConfiguredModelRef({
-            cfg,
-            defaultProvider: DEFAULT_PROVIDER,
-            defaultModel: DEFAULT_MODEL,
-        });
         if (raw === null) {
             applyModelOverrideToSessionEntry({
                 entry: next,
@@ -254,11 +244,6 @@ export async function applySessionsPatchToStore(params) {
         }
     }
     if (next.thinkingLevel === "xhigh") {
-        const resolvedDefault = resolveConfiguredModelRef({
-            cfg,
-            defaultProvider: DEFAULT_PROVIDER,
-            defaultModel: DEFAULT_MODEL,
-        });
         const effectiveProvider = next.providerOverride ?? resolvedDefault.provider;
         const effectiveModel = next.modelOverride ?? resolvedDefault.model;
         if (!supportsXHighThinking(effectiveProvider, effectiveModel)) {

package/dist/gateway/test-helpers.mocks.js

@@ -197,17 +197,21 @@ export const testState = {
 export const testIsNixMode = hoisted.testIsNixMode;
 export const sessionStoreSaveDelayMs = hoisted.sessionStoreSaveDelayMs;
 export const embeddedRunMock = hoisted.embeddedRunMock;
-vi.mock("@mariozechner/pi-coding-agent", async () => {
-    const actual = await vi.importActual("@mariozechner/pi-coding-agent");
-    return {
-        ...actual,
-        discoverModels: (...args) => {
+vi.mock("../agents/pi-model-discovery.js", async () => {
+    const actual = await vi.importActual("../agents/pi-model-discovery.js");
+    class MockModelRegistry extends actual.ModelRegistry {
+        getAll() {
             if (!piSdkMock.enabled) {
-                return actual.discoverModels(...args);
+                return super.getAll();
             }
             piSdkMock.discoverCalls += 1;
+            // Cast to expected type for testing purposes
             return piSdkMock.models;
-        },
+        }
+    }
+    return {
+        ...actual,
+        ModelRegistry: MockModelRegistry,
     };
 });
 vi.mock("../cron/isolated-agent.js", () => ({

package/dist/gateway/test-helpers.server.js

@@ -26,6 +26,7 @@ let previousConfigPath;
 let previousSkipBrowserControl;
 let previousSkipGmailWatcher;
 let previousSkipCanvasHost;
+let previousBundledPluginsDir;
 let tempHome;
 let tempConfigRoot;
 export async function writeSessionStore(params) {
@@ -56,6 +57,7 @@ async function setupGatewayTestHome() {
     previousSkipBrowserControl = process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER;
     previousSkipGmailWatcher = process.env.CLAWDBOT_SKIP_GMAIL_WATCHER;
     previousSkipCanvasHost = process.env.CLAWDBOT_SKIP_CANVAS_HOST;
+    previousBundledPluginsDir = process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR;
     tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "poolbot-gateway-home-"));
     process.env.HOME = tempHome;
     process.env.USERPROFILE = tempHome;
@@ -66,6 +68,9 @@ function applyGatewaySkipEnv() {
     process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER = "1";
     process.env.CLAWDBOT_SKIP_GMAIL_WATCHER = "1";
     process.env.CLAWDBOT_SKIP_CANVAS_HOST = "1";
+    process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR = tempHome
+        ? path.join(tempHome, "poolbot-test-no-bundled-extensions")
+        : "poolbot-test-no-bundled-extensions";
 }
 async function resetGatewayTestState(options) {
     // Some tests intentionally use fake timers; ensure they don't leak into gateway suites.
@@ -146,6 +151,10 @@ async function cleanupGatewayTestHome(options) {
             delete process.env.CLAWDBOT_SKIP_CANVAS_HOST;
         else
             process.env.CLAWDBOT_SKIP_CANVAS_HOST = previousSkipCanvasHost;
+        if (previousBundledPluginsDir === undefined)
+            delete process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR;
+        else
+            process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR = previousBundledPluginsDir;
     }
     if (options.restoreEnv && tempHome) {
         await fs.rm(tempHome, {
@@ -224,7 +233,8 @@ timeoutMs = 10_000) {
 }
 export async function startGatewayServer(port, opts) {
     const mod = await serverModulePromise;
-    return await mod.startGatewayServer(port, opts);
+    const resolvedOpts = opts?.controlUiEnabled === undefined ? { ...opts, controlUiEnabled: false } : opts;
+    return await mod.startGatewayServer(port, resolvedOpts);
 }
 export async function startServerWithClient(token, opts) {
     let port = await getFreePort();
@@ -259,7 +269,30 @@ export async function startServerWithClient(token, opts) {
         throw new Error("failed to start gateway server after retries");
     }
     const ws = new WebSocket(`ws://127.0.0.1:${port}`);
-    await new Promise((resolve) => ws.once("open", resolve));
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("timeout waiting for ws open")), 10_000);
+        const cleanup = () => {
+            clearTimeout(timer);
+            ws.off("open", onOpen);
+            ws.off("error", onError);
+            ws.off("close", onClose);
+        };
+        const onOpen = () => {
+            cleanup();
+            resolve();
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        const onClose = (code, reason) => {
+            cleanup();
+            reject(new Error(`closed ${code}: ${reason.toString()}`));
+        };
+        ws.once("open", onOpen);
+        ws.once("error", onError);
+        ws.once("close", onClose);
+    });
     return { server, ws, port, prevToken: prev };
 }
 export async function connectReq(ws, opts) {

package/dist/imessage/constants.js

@@ -0,0 +1,2 @@
+/** Default timeout for iMessage probe/RPC operations (10 seconds). */
+export const DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS = 10_000;

package/dist/imessage/monitor/deliver.js

@@ -4,7 +4,7 @@ import { resolveMarkdownTableMode } from "../../config/markdown-tables.js";
 import { convertMarkdownTables } from "../../markdown/tables.js";
 import { sendMessageIMessage } from "../send.js";
 export async function deliverReplies(params) {
-    const { replies, target, client, runtime, maxBytes, textLimit, accountId } = params;
+    const { replies, target, client, runtime, maxBytes, textLimit, accountId, sentMessageCache } = params;
     const cfg = loadConfig();
     const tableMode = resolveMarkdownTableMode({
         cfg,
@@ -25,6 +25,7 @@ export async function deliverReplies(params) {
                     client,
                     accountId,
                 });
+                sentMessageCache?.remember(target, chunk);
             }
         }
         else {
@@ -38,6 +39,8 @@ export async function deliverReplies(params) {
                     client,
                     accountId,
                 });
+                if (caption)
+                    sentMessageCache?.remember(target, caption);
             }
         }
         runtime.log?.(`imessage: delivered reply to ${target}`);

package/dist/imessage/monitor/monitor-provider.js

@@ -25,6 +25,7 @@ import { truncateUtf16Safe } from "../../utils.js";
 import { resolveControlCommandGate } from "../../channels/command-gating.js";
 import { resolveIMessageAccount } from "../accounts.js";
 import { createIMessageRpcClient } from "../client.js";
+import { DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS } from "../constants.js";
 import { probeIMessage } from "../probe.js";
 import { sendMessageIMessage } from "../send.js";
 import { formatIMessageChatTarget, isAllowedIMessageSender, normalizeIMessageHandle, } from "../targets.js";
@@ -72,6 +73,38 @@ function describeReplyContext(message) {
     const sender = normalizeReplyField(message.reply_to_sender);
     return { body, id, sender };
 }
+class SentMessageCache {
+    cache = new Map();
+    ttlMs = 5000;
+    remember(scope, text) {
+        if (!text?.trim())
+            return;
+        const key = `${scope}:${text.trim()}`;
+        this.cache.set(key, Date.now());
+        this.cleanup();
+    }
+    has(scope, text) {
+        if (!text?.trim())
+            return false;
+        const key = `${scope}:${text.trim()}`;
+        const timestamp = this.cache.get(key);
+        if (!timestamp)
+            return false;
+        const age = Date.now() - timestamp;
+        if (age > this.ttlMs) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [text, timestamp] of this.cache.entries()) {
+            if (now - timestamp > this.ttlMs)
+                this.cache.delete(text);
+        }
+    }
+}
 export async function monitorIMessageProvider(opts = {}) {
     const runtime = resolveRuntime(opts);
     const cfg = opts.config ?? loadConfig();
@@ -84,6 +117,7 @@ export async function monitorIMessageProvider(opts = {}) {
         cfg.messages?.groupChat?.historyLimit ??
         DEFAULT_GROUP_HISTORY_LIMIT);
     const groupHistories = new Map();
+    const sentMessageCache = new SentMessageCache();
     const textLimit = resolveTextChunkLimit(cfg, "imessage", accountInfo.accountId);
     const allowFrom = normalizeAllowList(opts.allowFrom ?? imessageCfg.allowFrom);
     const groupAllowFrom = normalizeAllowList(opts.groupAllowFrom ??
@@ -96,6 +130,7 @@ export async function monitorIMessageProvider(opts = {}) {
     const mediaMaxBytes = (opts.mediaMaxMb ?? imessageCfg.mediaMaxMb ?? 16) * 1024 * 1024;
     const cliPath = opts.cliPath ?? imessageCfg.cliPath ?? "imsg";
     const dbPath = opts.dbPath ?? imessageCfg.dbPath;
+    const probeTimeoutMs = imessageCfg.probeTimeoutMs ?? DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS;
     // Resolve remoteHost: explicit config, or auto-detect from SSH wrapper script
     let remoteHost = imessageCfg.remoteHost;
     if (!remoteHost && cliPath && cliPath !== "imsg") {
@@ -290,6 +325,11 @@ export async function monitorIMessageProvider(opts = {}) {
         });
         const mentionRegexes = buildMentionRegexes(cfg, route.agentId);
         const messageText = (message.text ?? "").trim();
+        const echoScope = `${accountInfo.accountId}:${isGroup ? formatIMessageChatTarget(chatId) : `imessage:${sender}`}`;
+        if (messageText && sentMessageCache.has(echoScope, messageText)) {
+            logVerbose(`imessage: skipping echo message (matches recently sent text within 5s): "${truncateUtf16Safe(messageText, 50)}"`);
+            return;
+        }
         const attachments = includeAttachments ? (message.attachments ?? []) : [];
         // Filter to valid attachments with paths
         const validAttachments = attachments.filter((entry) => entry?.original_path && !entry?.missing);
@@ -426,8 +466,17 @@ export async function monitorIMessageProvider(opts = {}) {
             });
         }
         const imessageTo = (isGroup ? chatTarget : undefined) || `imessage:${sender}`;
+        const inboundHistory = isGroup && historyKey && historyLimit > 0
+            ? (groupHistories.get(historyKey) ?? []).map((entry) => ({
+                sender: entry.sender,
+                body: entry.body,
+                timestamp: entry.timestamp,
+            }))
+            : undefined;
         const ctxPayload = finalizeInboundContext({
             Body: combinedBody,
+            BodyForAgent: bodyText,
+            InboundHistory: inboundHistory,
             RawBody: bodyText,
             CommandBody: bodyText,
             From: isGroup ? `imessage:group:${chatId ?? "unknown"}` : `imessage:${sender}`,
@@ -495,6 +544,7 @@ export async function monitorIMessageProvider(opts = {}) {
                     runtime,
                     maxBytes: mediaMaxBytes,
                     textLimit,
+                    sentMessageCache,
                 });
             },
             onError: (err, info) => {
@@ -542,7 +592,7 @@ export async function monitorIMessageProvider(opts = {}) {
         abortSignal: opts.abortSignal,
         runtime,
         check: async () => {
-            const probe = await probeIMessage(2000, { cliPath, dbPath, runtime });
+            const probe = await probeIMessage(probeTimeoutMs, { cliPath, dbPath, runtime });
             if (probe.ok)
                 return { ok: true };
             if (probe.fatal) {