talon-agent 1.1.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -44,7 +44,6 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "test:mutation": "stryker run",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint src/",
     "knip": "knip",
@@ -52,7 +51,7 @@
     "format:check": "prettier --check src/ prompts/"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.96",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.97",
     "@clack/prompts": "^1.2.0",
     "@grammyjs/auto-retry": "^2.0.2",
     "@grammyjs/transformer-throttler": "^1.2.1",
@@ -74,9 +73,6 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@stryker-mutator/core": "^9.6.0",
-    "@stryker-mutator/typescript-checker": "^9.6.0",
-    "@stryker-mutator/vitest-runner": "^9.6.0",
     "@types/node": "^25.5.2",
     "@types/write-file-atomic": "^4.0.3",
     "@vitest/coverage-v8": "^4.1.3",
@@ -86,5 +82,8 @@
     "prettier": "^3.8.1",
     "typescript": "^6.0.2",
     "vitest": "^4.1.3"
+  },
+  "overrides": {
+    "@anthropic-ai/sdk": "^0.86.1"
   }
 }

package/prompts/dream.md

@@ -1,8 +1,8 @@
 You are Talon's background memory consolidation agent. Your job is to update the persistent memory file with new information learned from recent interaction logs.
 
-You have access ONLY to filesystem tools (Read, Write, Edit, Bash, Glob, Grep). Do NOT attempt to use any Telegram, MCP, or messaging tools.
+You primarily use filesystem tools (Read, Write, Edit, Bash, Glob, Grep). Do NOT attempt to use any Telegram or other messaging tools. MCP tools may be used if required by Stage 5.
 
-## Your 4-stage task
+## Your 5-stage task
 
 ### Stage 1 — Orient
 
@@ -42,4 +42,8 @@ You have access ONLY to filesystem tools (Read, Write, Edit, Bash, Glob, Grep).
 - Do NOT remove entries just because they're old — only remove if wrong or superseded
 - Write the updated memory.md back to `{{memoryFile}}`
 
+### Stage 5 — Mine to MemPalace & Write Diary (optional)
+
+{{mempalaceSection}}
+
 When done with memory consolidation, stop. The system handles all dream_state.json updates.

package/prompts/mempalace.md

@@ -0,0 +1,57 @@
+## MemPalace — Long-term Memory
+
+You have access to a local memory palace via MCP tools. The palace stores verbatim conversation history and a temporal knowledge graph — all local, zero cloud, zero API calls.
+
+### Architecture
+
+- **Wings** = top-level categories (people, projects, topics)
+- **Rooms** = specific subjects within a wing
+- **Drawers** = individual memory chunks (verbatim text)
+- **Knowledge Graph** = entity-relationship facts with temporal validity
+
+### Protocol — FOLLOW EVERY SESSION
+
+1. **BEFORE RESPONDING** about any person, project, or past event: call `mempalace_search` or `mempalace_kg_query` FIRST. Never guess — verify from the palace.
+2. **IF UNSURE** about a fact (name, age, relationship, preference): query the palace. Wrong is worse than slow.
+3. **WHEN FACTS CHANGE**: Call `mempalace_kg_invalidate` on the old fact, then `mempalace_kg_add` for the new one.
+4. **AFTER LEARNING** something important: store it. Use `mempalace_add_drawer` for rich context, `mempalace_kg_add` for structured facts.
+
+### Tools
+
+**Search & Browse:**
+
+- `mempalace_search` — Semantic search. Use short keywords/questions, not full sentences. Filter by wing/room.
+- `mempalace_check_duplicate` — Check before filing new content (threshold default 0.9, lower to 0.85 to catch near-dupes).
+- `mempalace_status` — Palace overview: total drawers, wings, rooms.
+- `mempalace_list_wings` / `mempalace_list_rooms` — Browse structure.
+- `mempalace_get_taxonomy` — Full wing/room/count tree.
+
+**Knowledge Graph (Temporal Facts):**
+
+- `mempalace_kg_query` — Query entity relationships. Supports `as_of` date filtering.
+- `mempalace_kg_add` — Add fact: subject -> predicate -> object. Optional `valid_from`.
+- `mempalace_kg_invalidate` — Mark a fact as no longer true.
+- `mempalace_kg_timeline` — Chronological story of an entity.
+- `mempalace_kg_stats` — Graph overview: entities, triples, relationship types.
+
+**Palace Graph (Cross-Domain Connections):**
+
+- `mempalace_traverse` — Walk from a room, find connected ideas across wings.
+- `mempalace_find_tunnels` — Find rooms that bridge two wings.
+- `mempalace_graph_stats` — Graph connectivity overview.
+
+**Write:**
+
+- `mempalace_add_drawer` — Store verbatim content into a wing/room. Auto-checks duplicates.
+- `mempalace_delete_drawer` — Remove a drawer by ID.
+- `mempalace_diary_write` — Write a session diary entry (agent_name, entry, topic).
+- `mempalace_diary_read` — Read recent diary entries.
+
+### Tips
+
+- Search is **semantic** (meaning-based), not keyword. "What did we discuss about database performance?" works better than "database".
+- The knowledge graph stores typed relationships with **time windows**. It knows WHEN things were true.
+- Use `mempalace_check_duplicate` before storing new content to avoid clutter.
+- Diary entries accumulate across sessions. Write them to build continuity of self.
+
+### Palace location: `{{palacePath}}`

package/src/__tests__/cron-store-extended.test.ts

@@ -596,7 +596,7 @@ describe("loadCronJobs — invalid timezone stripping", () => {
   beforeEach(() => existsSyncMock.mockReset().mockReturnValue(false));
 
   it("strips invalid timezone from loaded job", async () => {
-    const { isValidTimezone } = await import("../storage/cron-store.js");
+    await import("../storage/cron-store.js");
     const jobWithBadTz: Record<string, unknown> = {
       "tz-bad-id": {
         id: "tz-bad-id",

package/src/__tests__/dream.test.ts

@@ -747,6 +747,7 @@ describe("dream error paths", () => {
     vi.doMock("write-file-atomic", () => ({ default: { sync: vi.fn() } }));
     vi.doMock("@anthropic-ai/claude-agent-sdk", () => ({
       query: vi.fn(async function* () {
+        yield; // satisfy require-yield
         throw new Error("agent crashed unexpectedly");
       }),
     }));
@@ -811,6 +812,7 @@ describe("dream error paths", () => {
     }));
     vi.doMock("@anthropic-ai/claude-agent-sdk", () => ({
       query: vi.fn(async function* () {
+        yield; // satisfy require-yield
         await queryPromise; // suspend until we release
       }),
     }));
@@ -957,7 +959,8 @@ describe("runDreamAgent — timeout arrow fn fires after DREAM_TIMEOUT_MS", () =
     // query never resolves — so the 10-minute timeout wins the race
     vi.doMock("@anthropic-ai/claude-agent-sdk", () => ({
       query: vi.fn(async function* () {
-        await new Promise(() => {}); // never yields
+        yield; // satisfy require-yield
+        await new Promise(() => {}); // never resolves
       }),
     }));
 
@@ -973,6 +976,120 @@ describe("runDreamAgent — timeout arrow fn fires after DREAM_TIMEOUT_MS", () =
   });
 });
 
+describe("mempalace section gating in dream prompt", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("includes mempalace mining command and diary instructions when mempalace is configured", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => false),
+      readFileSync: vi.fn(() => "PROMPT START {{mempalaceSection}} PROMPT END"),
+      mkdirSync: vi.fn(),
+      appendFileSync: vi.fn(),
+    }));
+    vi.doMock("write-file-atomic", () => ({ default: { sync: vi.fn() } }));
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: vi.fn(),
+      logWarn: vi.fn(),
+    }));
+    vi.doMock("../util/paths.js", () => ({
+      files: {
+        dreamState: "/fake/.talon/data/dream_state.json",
+        memory: "/fake/.talon/workspace/memory/memory.md",
+        log: "/fake/.talon/talon.log",
+      },
+      dirs: {
+        root: "/fake/.talon",
+        logs: "/fake/.talon/workspace/logs",
+        workspace: "/fake/.talon/workspace",
+        data: "/fake/.talon/data",
+        memory: "/fake/.talon/workspace/memory",
+        dailyMemory: "/fake/.talon/workspace/memory/daily",
+      },
+    }));
+    const queryMock = vi.fn(async function* () {});
+    vi.doMock("@anthropic-ai/claude-agent-sdk", () => ({ query: queryMock }));
+
+    const mod = await import("../core/dream.js");
+    mod.initDream({
+      model: "claude-sonnet-4-6",
+      workspace: "/fake/ws",
+      mempalace: {
+        pythonPath: "/usr/bin/python3",
+        palacePath: "/fake/palace",
+      },
+    });
+    await mod.forceDream();
+
+    expect(queryMock).toHaveBeenCalled();
+    const callArgs = (queryMock.mock.calls[0] as unknown[])[0] as {
+      prompt: string;
+    };
+    // Mempalace mining command should be in the prompt
+    expect(callArgs.prompt).toContain("-m mempalace mine");
+    // Diary instructions should be in the prompt
+    expect(callArgs.prompt).toContain("mempalace_diary_write");
+    // Should NOT contain the skip message
+    expect(callArgs.prompt).not.toContain(
+      "MemPalace is not configured. Skip this stage.",
+    );
+  });
+
+  it("includes skip message when mempalace is not configured", async () => {
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => false),
+      readFileSync: vi.fn(() => "PROMPT START {{mempalaceSection}} PROMPT END"),
+      mkdirSync: vi.fn(),
+      appendFileSync: vi.fn(),
+    }));
+    vi.doMock("write-file-atomic", () => ({ default: { sync: vi.fn() } }));
+    vi.doMock("../util/log.js", () => ({
+      log: vi.fn(),
+      logError: vi.fn(),
+      logWarn: vi.fn(),
+    }));
+    vi.doMock("../util/paths.js", () => ({
+      files: {
+        dreamState: "/fake/.talon/data/dream_state.json",
+        memory: "/fake/.talon/workspace/memory/memory.md",
+        log: "/fake/.talon/talon.log",
+      },
+      dirs: {
+        root: "/fake/.talon",
+        logs: "/fake/.talon/workspace/logs",
+        workspace: "/fake/.talon/workspace",
+        data: "/fake/.talon/data",
+        memory: "/fake/.talon/workspace/memory",
+        dailyMemory: "/fake/.talon/workspace/memory/daily",
+      },
+    }));
+    const queryMock = vi.fn(async function* () {});
+    vi.doMock("@anthropic-ai/claude-agent-sdk", () => ({ query: queryMock }));
+
+    const mod = await import("../core/dream.js");
+    // No mempalace config
+    mod.initDream({
+      model: "claude-sonnet-4-6",
+      workspace: "/fake/ws",
+    });
+    await mod.forceDream();
+
+    expect(queryMock).toHaveBeenCalled();
+    const callArgs = (queryMock.mock.calls[0] as unknown[])[0] as {
+      prompt: string;
+    };
+    // Should contain the skip message
+    expect(callArgs.prompt).toContain(
+      "MemPalace is not configured. Skip this stage.",
+    );
+    // Should NOT contain mempalace mining commands
+    expect(callArgs.prompt).not.toContain("-m mempalace mine");
+    expect(callArgs.prompt).not.toContain("mempalace_diary_write");
+  });
+});
+
 describe("maybeStartDream — () => {} catch callback on executeDream rejection", () => {
   it("fires the catch callback silently when executeDream('auto') rejects", async () => {
     vi.resetModules();

package/src/__tests__/fuzz.test.ts

@@ -46,7 +46,7 @@ vi.mock("../storage/cron-store.js", () => ({
 // ── Imports (after mocks) ────────────────────────────────────────────────────
 
 const { classify, TalonError } = await import("../core/errors.js");
-const { validateCronExpression } = await import("../storage/cron-store.js");
+await import("../storage/cron-store.js");
 const { handleSharedAction } = await import("../core/gateway-actions.js");
 const { resolveModelName } = await import("../storage/chat-settings.js");
 const { Cron } = await import("croner");

package/src/__tests__/gateway-retry.test.ts

@@ -244,10 +244,8 @@ describe("withRetry", () => {
 
   describe("exhausting all retries", () => {
     it("throws the last error after 3 total attempts for retryable errors", async () => {
-      let calls = 0;
       const networkErr = talonErr("network");
       const fn = vi.fn(async () => {
-        calls++;
         throw networkErr;
       });
 
@@ -257,9 +255,7 @@ describe("withRetry", () => {
     });
 
     it("throws the last error after 3 total attempts for overloaded errors", async () => {
-      let calls = 0;
       const fn = vi.fn(async () => {
-        calls++;
         throw talonErr("overloaded");
       });
 

package/src/__tests__/handlers.test.ts

@@ -533,8 +533,6 @@ describe("handleTextMessage — integration via mock Context", () => {
 });
 
 describe("handlePhotoMessage — downloads and enqueues photo", () => {
-  let restoreFetch: () => void;
-
   beforeEach(() => {
     // Mock bot.api.getFile for file download
     mockBot.api.getFile = vi.fn(async () => ({ file_path: "photos/test.jpg" }));
@@ -547,7 +545,6 @@ describe("handlePhotoMessage — downloads and enqueues photo", () => {
       headers: { get: (_name: string) => null },
       arrayBuffer: async () => jpegBuf.buffer,
     }));
-    restoreFetch = () => {};
     vi.stubGlobal("fetch", mockFetch);
 
     executeMock.mockResolvedValue({
@@ -795,7 +792,6 @@ describe("rate limiting — isUserRateLimited via handleTextMessage", () => {
     }
 
     // 16th message should be rate limited (return early without enqueuing)
-    const before = executeMock.mock.calls.length;
     await handleTextMessage(makeCtx(15), mockBot, mockConfig);
 
     // Wait to confirm no debounce fires for the 16th chat

package/src/__tests__/heartbeat.test.ts

@@ -197,6 +197,7 @@ describe("forceHeartbeat", () => {
 
     // Make agent throw
     queryMock.mockImplementationOnce(async function* () {
+      yield; // satisfy require-yield
       throw new Error("Agent exploded");
     });
 
@@ -217,6 +218,7 @@ describe("forceHeartbeat", () => {
     existsSyncMock.mockReturnValue(false);
 
     queryMock.mockImplementationOnce(async function* () {
+      yield; // satisfy require-yield
       throw new Error("Boom");
     });
 
@@ -340,6 +342,7 @@ describe("awaitCurrentRun", () => {
     });
 
     queryMock.mockImplementationOnce(async function* () {
+      yield; // satisfy require-yield
       await agentPromise;
     });
 

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"),
+    );
+  });
+});