talon-agent 1.2.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.2.0",
+  "version": "1.4.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,12 +51,14 @@
     "format:check": "prettier --check src/ prompts/"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.96",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.97",
+    "@brave/brave-search-mcp-server": "^2.0.75",
     "@clack/prompts": "^1.2.0",
     "@grammyjs/auto-retry": "^2.0.2",
     "@grammyjs/transformer-throttler": "^1.2.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opencode-ai/sdk": "^1.4.0",
+    "@playwright/mcp": "^0.0.70",
     "big-integer": "^1.6.52",
     "cheerio": "^1.2.0",
     "croner": "^10.0.1",
@@ -74,9 +75,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 +84,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__/compose-tools.test.ts

@@ -0,0 +1,216 @@
+import { describe, it, expect } from "vitest";
+import { ALL_TOOLS, composeTools } from "../core/tools/index.js";
+import type {
+  ToolDefinition,
+  ToolFrontend,
+  ToolTag,
+} from "../core/tools/types.js";
+
+describe("ALL_TOOLS registry", () => {
+  it("contains tools from every domain", () => {
+    const tags = new Set(ALL_TOOLS.map((t) => t.tag));
+    expect(tags).toContain("messaging");
+    expect(tags).toContain("chat");
+    expect(tags).toContain("history");
+    expect(tags).toContain("members");
+    expect(tags).toContain("media");
+    expect(tags).toContain("stickers");
+    expect(tags).toContain("scheduling");
+    expect(tags).toContain("web");
+  });
+
+  it("has no duplicate tool names", () => {
+    const names = ALL_TOOLS.map((t) => t.name);
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  it("every tool has required fields", () => {
+    for (const tool of ALL_TOOLS) {
+      expect(tool.name).toBeTruthy();
+      expect(tool.description).toBeTruthy();
+      expect(tool.schema).toBeDefined();
+      expect(typeof tool.execute).toBe("function");
+      expect(tool.tag).toBeTruthy();
+    }
+  });
+});
+
+describe("composeTools()", () => {
+  it("returns all tools when no options are given", () => {
+    const tools = composeTools();
+    expect(tools).toHaveLength(ALL_TOOLS.length);
+  });
+
+  it("returns a new array (not a reference to ALL_TOOLS)", () => {
+    const tools = composeTools();
+    expect(tools).not.toBe(ALL_TOOLS);
+  });
+
+  // ── Frontend filtering ────────────────────────────────────────────────
+
+  it("filters tools by telegram frontend", () => {
+    const tools = composeTools({ frontend: "telegram" });
+    // Should include telegram-specific and universal tools
+    expect(tools.length).toBeGreaterThan(0);
+    expect(tools.length).toBeLessThan(ALL_TOOLS.length);
+
+    for (const t of tools) {
+      const f = t.frontends;
+      expect(!f || f.includes("all") || f.includes("telegram")).toBe(true);
+    }
+  });
+
+  it("filters tools by teams frontend", () => {
+    const tools = composeTools({ frontend: "teams" });
+    expect(tools.length).toBeGreaterThan(0);
+
+    for (const t of tools) {
+      const f = t.frontends;
+      expect(!f || f.includes("all") || f.includes("teams")).toBe(true);
+    }
+  });
+
+  it("excludes telegram-only tools from teams", () => {
+    const teamsTools = composeTools({ frontend: "teams" });
+    const teamsNames = new Set(teamsTools.map((t) => t.name));
+
+    // react is telegram-only
+    expect(teamsNames.has("react")).toBe(false);
+    // send_message is teams-only — should be present
+    expect(teamsNames.has("send_message")).toBe(true);
+  });
+
+  it("excludes teams-only tools from telegram", () => {
+    const tgTools = composeTools({ frontend: "telegram" });
+    const tgNames = new Set(tgTools.map((t) => t.name));
+
+    // send_message is teams-only
+    expect(tgNames.has("send_message")).toBe(false);
+    // send is telegram-only — should be present
+    expect(tgNames.has("send")).toBe(true);
+  });
+
+  it("includes universal tools (no frontends set) for any frontend", () => {
+    const universalTools = ALL_TOOLS.filter((t) => !t.frontends);
+    expect(universalTools.length).toBeGreaterThan(0);
+
+    for (const frontend of [
+      "telegram",
+      "teams",
+      "terminal",
+    ] as ToolFrontend[]) {
+      const tools = composeTools({ frontend });
+      const names = new Set(tools.map((t) => t.name));
+      for (const ut of universalTools) {
+        expect(names.has(ut.name)).toBe(true);
+      }
+    }
+  });
+
+  it("includes tools with frontends: ['all'] for any frontend", () => {
+    const allFrontendTools = ALL_TOOLS.filter((t) =>
+      t.frontends?.includes("all"),
+    );
+    // Even if there are none right now, the filter logic is tested via universal tools
+    for (const frontend of [
+      "telegram",
+      "teams",
+      "terminal",
+    ] as ToolFrontend[]) {
+      const tools = composeTools({ frontend });
+      const names = new Set(tools.map((t) => t.name));
+      for (const t of allFrontendTools) {
+        expect(names.has(t.name)).toBe(true);
+      }
+    }
+  });
+
+  // ── Tag filtering ─────────────────────────────────────────────────────
+
+  it("filters by tags (include)", () => {
+    const tools = composeTools({ tags: ["web"] });
+    expect(tools.length).toBeGreaterThan(0);
+    for (const t of tools) {
+      expect(t.tag).toBe("web");
+    }
+  });
+
+  it("filters by multiple tags", () => {
+    const tools = composeTools({ tags: ["web", "scheduling"] });
+    expect(tools.length).toBeGreaterThan(0);
+    for (const t of tools) {
+      expect(["web", "scheduling"]).toContain(t.tag);
+    }
+  });
+
+  it("filters by excludeTags", () => {
+    const tools = composeTools({ excludeTags: ["stickers", "media"] });
+    for (const t of tools) {
+      expect(t.tag).not.toBe("stickers");
+      expect(t.tag).not.toBe("media");
+    }
+    expect(tools.length).toBeLessThan(ALL_TOOLS.length);
+  });
+
+  // ── Name exclusion ────────────────────────────────────────────────────
+
+  it("excludes tools by name", () => {
+    const tools = composeTools({ excludeNames: ["send", "react"] });
+    const names = new Set(tools.map((t) => t.name));
+    expect(names.has("send")).toBe(false);
+    expect(names.has("react")).toBe(false);
+    expect(tools.length).toBe(ALL_TOOLS.length - 2);
+  });
+
+  // ── Combined filters ──────────────────────────────────────────────────
+
+  it("combines frontend + tag filters", () => {
+    const tools = composeTools({ frontend: "telegram", tags: ["messaging"] });
+    expect(tools.length).toBeGreaterThan(0);
+    for (const t of tools) {
+      expect(t.tag).toBe("messaging");
+      const f = t.frontends;
+      expect(!f || f.includes("all") || f.includes("telegram")).toBe(true);
+    }
+    // Should NOT include teams send_message
+    const names = new Set(tools.map((t) => t.name));
+    expect(names.has("send_message")).toBe(false);
+  });
+
+  it("combines frontend + excludeTags", () => {
+    const tools = composeTools({
+      frontend: "telegram",
+      excludeTags: ["stickers"],
+    });
+    for (const t of tools) {
+      expect(t.tag).not.toBe("stickers");
+    }
+  });
+
+  it("combines frontend + excludeNames", () => {
+    const tools = composeTools({
+      frontend: "telegram",
+      excludeNames: ["fetch_url"],
+    });
+    const names = new Set(tools.map((t) => t.name));
+    expect(names.has("fetch_url")).toBe(false);
+    expect(names.has("send")).toBe(true);
+  });
+
+  // ── Edge cases ────────────────────────────────────────────────────────
+
+  it("returns empty array when tags match nothing", () => {
+    const tools = composeTools({ tags: ["nonexistent" as ToolTag] });
+    expect(tools).toEqual([]);
+  });
+
+  it("returns all tools when excludeNames is empty", () => {
+    const tools = composeTools({ excludeNames: [] });
+    expect(tools).toHaveLength(ALL_TOOLS.length);
+  });
+
+  it("returns all tools when excludeTags is empty", () => {
+    const tools = composeTools({ excludeTags: [] });
+    expect(tools).toHaveLength(ALL_TOOLS.length);
+  });
+});

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");
@@ -193,7 +193,6 @@ describe("fuzz: handleSharedAction() — unknown actions", () => {
           "get_user_messages",
           "list_known_users",
           "list_media",
-          "web_search",
           "fetch_url",
           "create_cron_job",
           "list_cron_jobs",
@@ -224,7 +223,6 @@ describe("fuzz: handleSharedAction() — unknown actions", () => {
             "get_user_messages",
             "list_known_users",
             "list_media",
-            "web_search",
             "fetch_url",
             "create_cron_job",
             "list_cron_jobs",