talon-agent 1.2.0 → 1.4.0

package/src/__tests__/mempalace-plugin.test.ts

@@ -0,0 +1,295 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../util/log.js", () => ({
+  log: vi.fn(),
+  logError: vi.fn(),
+  logWarn: vi.fn(),
+  logDebug: vi.fn(),
+}));
+
+const PROMPT_TEMPLATE = `## MemPalace — Long-term Memory
+
+mempalace_search mempalace_add_drawer mempalace_kg_query mempalace_kg_invalidate
+mempalace_kg_timeline mempalace_traverse mempalace_find_tunnels
+mempalace_diary_write mempalace_diary_read mempalace_delete_drawer
+Protocol
+
+### Palace location: \`{{palacePath}}\`
+`;
+
+describe("mempalace plugin", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+  });
+
+  it("creates a plugin with correct name and MCP server config", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      mkdirSync: vi.fn(),
+      readFileSync: vi.fn(() => PROMPT_TEMPLATE),
+    }));
+    vi.doMock("node:child_process", () => ({
+      execFileSync: vi.fn(() => "ok"),
+      execFile: vi.fn(
+        (
+          _cmd: string,
+          _args: string[],
+          _opts: unknown,
+          cb: (
+            err: Error | null,
+            result: { stdout: string; stderr: string },
+          ) => void,
+        ) => {
+          cb(null, { stdout: "Palace: 42 drawers", stderr: "" });
+        },
+      ),
+    }));
+
+    const { createMempalacePlugin } =
+      await import("../plugins/mempalace/index.js");
+    const plugin = createMempalacePlugin({
+      pythonPath: "/venv/bin/python",
+      palacePath: "/data/palace",
+    });
+
+    expect(plugin.name).toBe("mempalace");
+    expect(plugin.version).toBe("1.0.0");
+    expect(plugin.mcpServer).toEqual({
+      command: "/venv/bin/python",
+      args: ["-m", "mempalace.mcp_server", "--palace", "/data/palace"],
+    });
+  });
+
+  it("validateConfig returns error when python binary not found", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => false),
+      mkdirSync: vi.fn(),
+      readFileSync: vi.fn(() => PROMPT_TEMPLATE),
+    }));
+    vi.doMock("node:child_process", () => ({
+      execFileSync: vi.fn(),
+      execFile: vi.fn(),
+    }));
+
+    const { createMempalacePlugin } =
+      await import("../plugins/mempalace/index.js");
+    const plugin = createMempalacePlugin({
+      pythonPath: "/nonexistent/python",
+      palacePath: "/data/palace",
+    });
+
+    const errors = plugin.validateConfig!({});
+    expect(errors).toBeDefined();
+    expect(errors!.length).toBeGreaterThan(0);
+    expect(errors![0]).toContain("Python binary not found");
+  });
+
+  it("validateConfig passes when python binary exists and mempalace is importable", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      mkdirSync: vi.fn(),
+      readFileSync: vi.fn(() => PROMPT_TEMPLATE),
+    }));
+    vi.doMock("node:child_process", () => ({
+      execFileSync: vi.fn(() => "ok"),
+      execFile: vi.fn(),
+    }));
+
+    const { createMempalacePlugin } =
+      await import("../plugins/mempalace/index.js");
+    const plugin = createMempalacePlugin({
+      pythonPath: "/venv/bin/python",
+      palacePath: "/data/palace",
+    });
+
+    const errors = plugin.validateConfig!({});
+    expect(errors).toBeUndefined();
+  });
+
+  it("validateConfig returns error when mempalace is not importable", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      mkdirSync: vi.fn(),
+      readFileSync: vi.fn(() => PROMPT_TEMPLATE),
+    }));
+    vi.doMock("node:child_process", () => ({
+      execFileSync: vi.fn(() => {
+        throw new Error("ModuleNotFoundError");
+      }),
+      execFile: vi.fn(),
+    }));
+
+    const { createMempalacePlugin } =
+      await import("../plugins/mempalace/index.js");
+    const plugin = createMempalacePlugin({
+      pythonPath: "/venv/bin/python",
+      palacePath: "/data/palace",
+    });
+
+    const errors = plugin.validateConfig!({});
+    expect(errors).toBeDefined();
+    expect(errors!.length).toBeGreaterThan(0);
+    expect(errors![0]).toContain("mempalace package not installed");
+  });
+
+  it("init creates palace directory if missing", async () => {
+    const mkdirSyncMock = vi.fn();
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn((p: string) =>
+        p === "/venv/bin/python" ? true : false,
+      ),
+      mkdirSync: mkdirSyncMock,
+      readFileSync: vi.fn(() => PROMPT_TEMPLATE),
+    }));
+    vi.doMock("node:child_process", () => ({
+      execFileSync: vi.fn(() => "ok"),
+      execFile: vi.fn(
+        (
+          _cmd: string,
+          _args: string[],
+          _opts: unknown,
+          cb: (
+            err: Error | null,
+            result: { stdout: string; stderr: string },
+          ) => void,
+        ) => {
+          cb(null, { stdout: "ok", stderr: "" });
+        },
+      ),
+    }));
+
+    const { createMempalacePlugin } =
+      await import("../plugins/mempalace/index.js");
+    const plugin = createMempalacePlugin({
+      pythonPath: "/venv/bin/python",
+      palacePath: "/data/new-palace",
+    });
+
+    await plugin.init!({});
+    expect(mkdirSyncMock).toHaveBeenCalledWith("/data/new-palace", {
+      recursive: true,
+    });
+  });
+
+  it("validateConfig returns error when python binary exists but mempalace import fails with ENOENT", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      mkdirSync: vi.fn(),
+      readFileSync: vi.fn(() => PROMPT_TEMPLATE),
+    }));
+    vi.doMock("node:child_process", () => ({
+      execFileSync: vi.fn(() => {
+        const err = new Error("spawn ENOENT") as Error & { code: string };
+        err.code = "ENOENT";
+        throw err;
+      }),
+      execFile: vi.fn(),
+    }));
+
+    const { createMempalacePlugin } =
+      await import("../plugins/mempalace/index.js");
+    const plugin = createMempalacePlugin({
+      pythonPath: "/venv/bin/python",
+      palacePath: "/data/palace",
+    });
+
+    const errors = plugin.validateConfig!({});
+    expect(errors).toBeDefined();
+    expect(errors!.length).toBeGreaterThan(0);
+    expect(errors![0]).toContain("Cannot execute Python");
+    expect(errors![0]).toContain("ENOENT");
+  });
+
+  it("getEnvVars returns MEMPALACE_PALACE_PATH", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      mkdirSync: vi.fn(),
+      readFileSync: vi.fn(() => PROMPT_TEMPLATE),
+    }));
+    vi.doMock("node:child_process", () => ({
+      execFileSync: vi.fn(),
+      execFile: vi.fn(),
+    }));
+
+    const { createMempalacePlugin } =
+      await import("../plugins/mempalace/index.js");
+    const plugin = createMempalacePlugin({
+      pythonPath: "/venv/bin/python",
+      palacePath: "/data/palace",
+    });
+
+    expect(plugin.getEnvVars!({})).toEqual({
+      MEMPALACE_PALACE_PATH: "/data/palace",
+    });
+  });
+
+  it("getSystemPromptAddition loads from .md file and interpolates palacePath", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      mkdirSync: vi.fn(),
+      readFileSync: vi.fn(() => PROMPT_TEMPLATE),
+    }));
+    vi.doMock("node:child_process", () => ({
+      execFileSync: vi.fn(),
+      execFile: vi.fn(),
+    }));
+
+    const { createMempalacePlugin } =
+      await import("../plugins/mempalace/index.js");
+    const plugin = createMempalacePlugin({
+      pythonPath: "/venv/bin/python",
+      palacePath: "/custom/palace",
+    });
+
+    const addition = plugin.getSystemPromptAddition!({});
+    expect(addition).toContain("MemPalace");
+    expect(addition).toContain("mempalace_search");
+    expect(addition).toContain("mempalace_add_drawer");
+    expect(addition).toContain("mempalace_kg_query");
+    expect(addition).toContain("mempalace_kg_invalidate");
+    expect(addition).toContain("mempalace_kg_timeline");
+    expect(addition).toContain("mempalace_traverse");
+    expect(addition).toContain("mempalace_find_tunnels");
+    expect(addition).toContain("mempalace_diary_write");
+    expect(addition).toContain("mempalace_diary_read");
+    expect(addition).toContain("mempalace_delete_drawer");
+    expect(addition).toContain("Protocol");
+    expect(addition).toContain("/custom/palace");
+    // Verify interpolation happened — no raw placeholder
+    expect(addition).not.toContain("{{palacePath}}");
+  });
+
+  it("getSystemPromptAddition returns fallback when .md file is missing", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      mkdirSync: vi.fn(),
+      readFileSync: vi.fn(() => {
+        throw new Error("ENOENT: no such file");
+      }),
+    }));
+    vi.doMock("node:child_process", () => ({
+      execFileSync: vi.fn(),
+      execFile: vi.fn(),
+    }));
+
+    const { logWarn } = (await import("../util/log.js")) as unknown as {
+      logWarn: ReturnType<typeof vi.fn>;
+    };
+
+    const { createMempalacePlugin } =
+      await import("../plugins/mempalace/index.js");
+    const plugin = createMempalacePlugin({
+      pythonPath: "/venv/bin/python",
+      palacePath: "/data/palace",
+    });
+
+    const addition = plugin.getSystemPromptAddition!({});
+    expect(addition).toContain("MemPalace");
+    expect(addition).toContain("/data/palace");
+    expect(logWarn).toHaveBeenCalledWith(
+      "mempalace",
+      expect.stringContaining("Failed to load prompt"),
+    );
+  });
+});

package/src/__tests__/plugin.test.ts

@@ -218,6 +218,97 @@ describe("plugin system", () => {
         });
       }
     });
+
+    it("builds MCP server entries for plugins with custom mcpServer", async () => {
+      const plugin = createMockPlugin({
+        mcpServer: {
+          command: "/usr/bin/python3",
+          args: ["-m", "mempalace.mcp_server", "--palace", "/tmp/palace"],
+        },
+        getEnvVars: () => ({ PALACE_PATH: "/tmp/palace" }),
+      });
+      // Remove mcpServerPath so mcpServer is used
+      delete (plugin as Record<string, unknown>).mcpServerPath;
+      const { loadPlugins, getPluginMcpServers } = await setup(plugin);
+      await loadPlugins([{ path: "/fake/plugin" }]);
+
+      const servers = getPluginMcpServers("http://localhost:19876", "chat1");
+      expect(servers["test-plugin-tools"]).toBeDefined();
+      expect(servers["test-plugin-tools"].command).toBe("/usr/bin/python3");
+      expect(servers["test-plugin-tools"].args).toEqual([
+        "-m",
+        "mempalace.mcp_server",
+        "--palace",
+        "/tmp/palace",
+      ]);
+      expect(servers["test-plugin-tools"].env.PALACE_PATH).toBe("/tmp/palace");
+      expect(servers["test-plugin-tools"].env.TALON_BRIDGE_URL).toBe(
+        "http://localhost:19876",
+      );
+    });
+
+    it("mcpServer takes priority over mcpServerPath when both are set", async () => {
+      const plugin = createMockPlugin({
+        mcpServerPath: "/fake/tools.ts",
+        mcpServer: {
+          command: "/usr/bin/python3",
+          args: ["-m", "my_server"],
+        },
+      });
+      const { loadPlugins, getPluginMcpServers } = await setup(plugin);
+      await loadPlugins([{ path: "/fake/plugin" }]);
+
+      const servers = getPluginMcpServers("http://localhost:19876", "chat1");
+      // mcpServer should win over mcpServerPath
+      expect(servers["test-plugin-tools"].command).toBe("/usr/bin/python3");
+      expect(servers["test-plugin-tools"].args).toEqual(["-m", "my_server"]);
+    });
+
+    it("skips plugins without mcpServer or mcpServerPath", async () => {
+      const plugin = createMockPlugin();
+      delete (plugin as Record<string, unknown>).mcpServerPath;
+      delete (plugin as Record<string, unknown>).mcpServer;
+      const { loadPlugins, getPluginMcpServers } = await setup(plugin);
+      await loadPlugins([{ path: "/fake/plugin" }]);
+
+      const servers = getPluginMcpServers("http://localhost:19876", "chat1");
+      expect(Object.keys(servers)).toHaveLength(0);
+    });
+  });
+
+  describe("registerPlugin (built-in)", () => {
+    it("registers a built-in plugin directly", async () => {
+      const plugin = createMockPlugin({ name: "built-in-test" });
+      const { registerPlugin, getPlugin } = await setup(createMockPlugin());
+
+      registerPlugin(plugin, { key: "val" });
+      expect(getPlugin("built-in-test")).toBeDefined();
+      expect(getPlugin("built-in-test")!.path).toBe("(built-in)");
+    });
+
+    it("sets env vars from built-in plugin", async () => {
+      const plugin = createMockPlugin({
+        name: "builtin-env",
+        getEnvVars: () => ({
+          TEST_PLUGIN_BUILTIN_FOO: "baz",
+        }),
+      });
+      const { registerPlugin } = await setup(createMockPlugin());
+
+      registerPlugin(plugin);
+      expect(process.env.TEST_PLUGIN_BUILTIN_FOO).toBe("baz");
+    });
+
+    it("skips registration when validateConfig returns errors", async () => {
+      const plugin = createMockPlugin({
+        name: "builtin-invalid",
+        validateConfig: () => ["missing required field"],
+      });
+      const { registerPlugin, getPlugin } = await setup(createMockPlugin());
+
+      registerPlugin(plugin, {});
+      expect(getPlugin("builtin-invalid")).toBeUndefined();
+    });
   });
 
   describe("system prompt additions", () => {
@@ -409,6 +500,84 @@ describe("extractPlugin — invalid optional field types", () => {
     expect(mod.getPluginCount()).toBe(0);
   });
 
+  it("rejects plugin when mcpServer is not an object", async () => {
+    const plugin = { name: "bad-mcp-server", mcpServer: "not-an-object" };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/bad-mcp-server" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer is null", async () => {
+    const plugin = { name: "null-mcp-server", mcpServer: null };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/null-mcp-server" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer.command is not a string", async () => {
+    const plugin = {
+      name: "bad-mcp-cmd",
+      mcpServer: { command: 123, args: [] },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/bad-mcp-cmd" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer.args is not an array", async () => {
+    const plugin = {
+      name: "bad-mcp-args",
+      mcpServer: { command: "/usr/bin/python3", args: "not-an-array" },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/bad-mcp-args" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer.command is empty string", async () => {
+    const plugin = {
+      name: "empty-mcp-cmd",
+      mcpServer: { command: "", args: ["-m", "server"] },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/empty-mcp-cmd" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer.args contains non-string elements", async () => {
+    const plugin = {
+      name: "bad-mcp-args-types",
+      mcpServer: { command: "/usr/bin/python3", args: ["-m", 42] },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/bad-mcp-args-types" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("accepts plugin with valid mcpServer object", async () => {
+    const plugin = {
+      name: "good-mcp-server",
+      mcpServer: { command: "/usr/bin/python3", args: ["-m", "server"] },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/good-mcp-server" }]);
+    expect(mod.getPluginCount()).toBe(1);
+  });
+
   it("catches and logs error when importModule throws", async () => {
     vi.resetModules();
     vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));

package/src/__tests__/storage-save-errors.test.ts

@@ -49,7 +49,7 @@ describe("cron-store — save failure logs error", () => {
       registerCleanup: vi.fn(),
     }));
 
-    const { addCronJob, generateCronId, flushCronJobs } =
+    const { addCronJob, generateCronId } =
       await import("../storage/cron-store.js");
 
     const job = {

package/src/__tests__/time.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { describe, it, expect, afterEach } from "vitest";
 import {
   setTimezone,
   getTimezone,

package/src/__tests__/watchdog.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
+import { describe, it, expect, vi, afterEach } from "vitest";
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -38,8 +38,6 @@ describe("watchdog", () => {
     });
 
     it("updates lastProcessedAt timestamp", () => {
-      const beforeStatus = getHealthStatus();
-      const beforeMs = beforeStatus.msSinceLastMessage;
       recordMessageProcessed();
       const afterStatus = getHealthStatus();
       // After recording, msSinceLastMessage should be very small (near 0)

package/src/__tests__/workspace.test.ts

@@ -5,7 +5,6 @@ import {
   rmSync,
   existsSync,
   readdirSync,
-  readFileSync,
   symlinkSync,
 } from "node:fs";
 import { join } from "node:path";

package/src/backend/claude-sdk/index.ts

@@ -9,7 +9,6 @@ import {
   setSessionName,
 } from "../../storage/sessions.js";
 import { getChatSettings, setChatModel } from "../../storage/chat-settings.js";
-import { getRecentHistory } from "../../storage/history.js";
 import { resolve } from "node:path";
 import { classify } from "../../core/errors.js";
 import {
@@ -19,7 +18,7 @@ import {
 import { rebuildSystemPrompt } from "../../util/config.js";
 import { log, logError, logWarn } from "../../util/log.js";
 import { traceMessage } from "../../util/trace.js";
-import { formatSmartTimestamp, formatFullDatetime } from "../../util/time.js";
+import { formatFullDatetime } from "../../util/time.js";
 
 import type { QueryParams, QueryResult } from "../../core/types.js";
 
@@ -115,66 +114,68 @@ export async function handleMessage(
       "TaskOutput",
       "TaskStop",
       "AskUserQuestion",
+      // Always disable Claude Code built-in web tools — fetch_url is always
+      // available, and Brave Search MCP replaces WebSearch when configured.
+      "WebSearch",
+      "WebFetch",
     ],
     ...thinkingConfig,
     mcpServers: {
-      // Register frontend-specific MCP tools based on active frontend
+      // Register unified MCP tools server — one per messaging frontend.
+      // Terminal frontend relies on Claude Code built-in tools (Read, Write,
+      // Bash, etc.) and doesn't need a custom MCP tools server.
       ...(() => {
-        const frontends = Array.isArray(config.frontend)
+        const allFrontends = Array.isArray(config.frontend)
           ? config.frontend
           : [config.frontend];
+        const frontends = allFrontends.filter((f) => f !== "terminal");
         const bridgeUrl = `http://127.0.0.1:${bridgePortFn()}`;
-        const mcpEnv = { TALON_BRIDGE_URL: bridgeUrl, TALON_CHAT_ID: chatId };
         const servers: Record<
           string,
           { command: string; args: string[]; env: Record<string, string> }
         > = {};
-        // Resolve tsx from Talon's node_modules (cwd may be ~/.talon/workspace/ which has no node_modules)
         // Resolve tsx from the package root (3 levels up from src/backend/claude-sdk/)
         const tsxImport = resolve(
           import.meta.dirname ?? ".",
           "../../../node_modules/tsx/dist/esm/index.mjs",
         );
+        // Unified MCP server in core/tools/
+        const mcpServerPath = resolve(
+          import.meta.dirname ?? ".",
+          "../../core/tools/mcp-server.ts",
+        );
 
-        if (frontends.includes("telegram")) {
-          servers["telegram-tools"] = {
-            command: process.platform === "win32" ? "npx" : "node",
-            args:
-              process.platform === "win32"
-                ? ["tsx", resolve(import.meta.dirname ?? ".", "tools.ts")]
-                : [
-                    "--import",
-                    tsxImport,
-                    resolve(import.meta.dirname ?? ".", "tools.ts"),
-                  ],
-            env: mcpEnv,
+        for (const frontend of frontends) {
+          const serverName = `${frontend}-tools`;
+          const mcpEnv = {
+            TALON_BRIDGE_URL: bridgeUrl,
+            TALON_CHAT_ID: chatId,
+            TALON_FRONTEND: frontend,
           };
-        }
-        if (frontends.includes("teams")) {
-          servers["teams-tools"] = {
+          servers[serverName] = {
             command: process.platform === "win32" ? "npx" : "node",
             args:
               process.platform === "win32"
-                ? [
-                    "tsx",
-                    resolve(
-                      import.meta.dirname ?? ".",
-                      "../../frontend/teams/tools.ts",
-                    ),
-                  ]
-                : [
-                    "--import",
-                    tsxImport,
-                    resolve(
-                      import.meta.dirname ?? ".",
-                      "../../frontend/teams/tools.ts",
-                    ),
-                  ],
+                ? ["tsx", mcpServerPath]
+                : ["--import", tsxImport, mcpServerPath],
             env: mcpEnv,
           };
         }
         return servers;
       })(),
+      // Brave Search MCP server — provides brave_web_search and brave_local_search
+      ...(config.braveApiKey
+        ? {
+            "brave-search": {
+              command: resolve(
+                import.meta.dirname ?? ".",
+                "../../../node_modules/.bin/brave-search-mcp-server",
+              ),
+              args: [],
+              env: { BRAVE_API_KEY: config.braveApiKey },
+            },
+          }
+        : {}),
       ...getPluginMcpServers(`http://127.0.0.1:${bridgePortFn()}`, chatId),
     },
     ...(session.sessionId ? { resume: session.sessionId } : {}),
@@ -183,25 +184,9 @@ export async function handleMessage(
   const msgIdHint = params.messageId ? ` [msg_id:${params.messageId}]` : "";
   const nowTag = `[${formatFullDatetime()}]`;
 
-  // Session continuity: when resuming a session that has history but no active
-  // SDK session (after restart or /resume), prepend recent messages for context.
-  let continuityPrefix = "";
-  if (!session.sessionId && session.turns > 0) {
-    const recentMsgs = getRecentHistory(chatId, 10);
-    if (recentMsgs.length > 0) {
-      const contextLines = recentMsgs
-        .map((m) => {
-          const time = formatSmartTimestamp(m.timestamp);
-          return `[${time}] ${m.senderName}: ${m.text.slice(0, 300)}`;
-        })
-        .join("\n");
-      continuityPrefix = `[Session resumed — recent conversation context:\n${contextLines}]\n\n`;
-    }
-  }
-
   const prompt = isGroup
-    ? `${continuityPrefix}${nowTag} [${senderName}]${msgIdHint}: ${text}`
-    : `${continuityPrefix}${nowTag}${msgIdHint} ${text}`;
+    ? `${nowTag} [${senderName}]${msgIdHint}: ${text}`
+    : `${nowTag}${msgIdHint} ${text}`;
   log("agent", `[${chatId}] <- (${text.length} chars)`);
   traceMessage(chatId, "in", text, { senderName, isGroup });