talon-agent 1.8.1 → 1.9.0

package/README.md

@@ -12,15 +12,15 @@ Multi-platform agentic AI harness powered by Claude. Runs on **Telegram**, **Tea
 
 ## Features
 
-| | |
-|---|---|
-| **Multi-frontend** | Telegram (Grammy + GramJS userbot), Microsoft Teams (Bot Framework), Terminal with live tool visibility |
-| **Claude Agent SDK** | Streaming responses, extended thinking, adaptive effort, 1M token context, dynamic model discovery |
-| **MCP tools** | Messaging, media, history, search, web fetch, cron jobs, stickers, file system, admin controls |
-| **Plugins** | Hot-reloadable plugin system. Built-in: GitHub, MemPalace, Playwright, Brave Search |
-| **Background agents** | Heartbeat (periodic maintenance) and Dream (memory consolidation + diary) |
-| **Per-chat settings** | Model, effort level, and pulse toggle per conversation via inline keyboard |
-| **Model registry** | Models discovered from the SDK at startup --- new models appear in all pickers automatically |
+|                       |                                                                                                         |
+| --------------------- | ------------------------------------------------------------------------------------------------------- |
+| **Multi-frontend**    | Telegram (Grammy + GramJS userbot), Microsoft Teams (Bot Framework), Terminal with live tool visibility |
+| **Claude Agent SDK**  | Streaming responses, extended thinking, adaptive effort, 1M token context, dynamic model discovery      |
+| **MCP tools**         | Messaging, media, history, search, web fetch, cron jobs, stickers, file system, admin controls          |
+| **Plugins**           | Hot-reloadable plugin system. Built-in: GitHub, MemPalace, Playwright, Brave Search                     |
+| **Background agents** | Heartbeat (periodic maintenance) and Dream (memory consolidation + diary)                               |
+| **Per-chat settings** | Model, effort level, and pulse toggle per conversation via inline keyboard                              |
+| **Model registry**    | Models discovered from the SDK at startup --- new models appear in all pickers automatically            |
 
 ---
 
@@ -39,8 +39,10 @@ npx talon chat        # terminal chat mode
 ```
 
 **Prerequisites:**
+
 - [Node.js 22+](https://nodejs.org/)
 - [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed and authenticated (`claude` CLI on PATH)
+- Talon runs from a normal source or package install; standalone compiled binaries are not supported.
 
 ---
 
@@ -161,9 +163,7 @@ Plugins add MCP tools and gateway actions without modifying core code. SOLID int
 
 ```json
 {
-  "plugins": [
-    { "path": "/path/to/my-plugin", "config": { "apiKey": "..." } }
-  ]
+  "plugins": [{ "path": "/path/to/my-plugin", "config": { "apiKey": "..." } }]
 }
 ```
 
@@ -172,12 +172,24 @@ export default {
   name: "my-plugin",
   version: "1.0.0",
   mcpServerPath: resolve(import.meta.dirname, "tools.ts"),
-  validateConfig(config) { /* return errors or undefined */ },
-  getEnvVars(config) { return { MY_KEY: config.apiKey }; },
-  handleAction(body, chatId) { /* gateway action handler */ },
-  getSystemPromptAddition(config) { return "## My Plugin\n..."; },
-  init(config) { /* one-time setup */ },
-  destroy() { /* cleanup */ },
+  validateConfig(config) {
+    /* return errors or undefined */
+  },
+  getEnvVars(config) {
+    return { MY_KEY: config.apiKey };
+  },
+  handleAction(body, chatId) {
+    /* gateway action handler */
+  },
+  getSystemPromptAddition(config) {
+    return "## My Plugin\n...";
+  },
+  init(config) {
+    /* one-time setup */
+  },
+  destroy() {
+    /* cleanup */
+  },
 };
 ```
 
@@ -204,25 +216,25 @@ talon doctor    Validate environment and dependencies
 
 Config file: `~/.talon/config.json`
 
-| Field | Default | Description |
-|-------|---------|-------------|
-| `frontend` | `"telegram"` | `"telegram"`, `"terminal"`, `"teams"`, or an array |
-| `backend` | `"claude"` | `"claude"` or `"opencode"` |
-| `botToken` | --- | Telegram bot token |
-| `model` | `"default"` | Default Claude model. Legacy `claude-*` aliases are still accepted. |
-| `concurrency` | `1` | Max concurrent AI queries (1--20) |
-| `pulse` | `true` | Periodic group engagement |
-| `heartbeat` | `false` | Background maintenance agent |
-| `heartbeatIntervalMinutes` | `60` | Heartbeat interval |
-| `braveApiKey` | --- | Brave Search API key |
-| `timezone` | --- | IANA timezone (e.g. `"Europe/London"`) |
-| `plugins` | `[]` | External plugin packages |
-| `adminUserId` | --- | Telegram user ID for `/admin` commands |
-| `allowedUsers` | --- | Whitelist of Telegram user IDs |
-| `apiId` / `apiHash` | --- | Telegram API credentials for full message history |
-| `github` | --- | GitHub plugin config (see above) |
-| `mempalace` | --- | MemPalace plugin config (see above) |
-| `playwright` | --- | Playwright plugin config (see above) |
+| Field                      | Default      | Description                                                         |
+| -------------------------- | ------------ | ------------------------------------------------------------------- |
+| `frontend`                 | `"telegram"` | `"telegram"`, `"terminal"`, `"teams"`, or an array                  |
+| `backend`                  | `"claude"`   | `"claude"` or `"opencode"`                                          |
+| `botToken`                 | ---          | Telegram bot token                                                  |
+| `model`                    | `"default"`  | Default Claude model. Legacy `claude-*` aliases are still accepted. |
+| `concurrency`              | `1`          | Max concurrent AI queries (1--20)                                   |
+| `pulse`                    | `true`       | Periodic group engagement                                           |
+| `heartbeat`                | `false`      | Background maintenance agent                                        |
+| `heartbeatIntervalMinutes` | `60`         | Heartbeat interval                                                  |
+| `braveApiKey`              | ---          | Brave Search API key                                                |
+| `timezone`                 | ---          | IANA timezone (e.g. `"Europe/London"`)                              |
+| `plugins`                  | `[]`         | External plugin packages                                            |
+| `adminUserId`              | ---          | Telegram user ID for `/admin` commands                              |
+| `allowedUsers`             | ---          | Whitelist of Telegram user IDs                                      |
+| `apiId` / `apiHash`        | ---          | Telegram API credentials for full message history                   |
+| `github`                   | ---          | GitHub plugin config (see above)                                    |
+| `mempalace`                | ---          | MemPalace plugin config (see above)                                 |
+| `playwright`               | ---          | Playwright plugin config (see above)                                |
 
 ---
 
@@ -241,6 +253,7 @@ Commands: `/model`, `/effort`, `/reset`, `/status`, `/help`
 ## Production
 
 **Docker:**
+
 ```bash
 docker compose up -d
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -36,7 +36,6 @@
     "tsconfig.json"
   ],
   "scripts": {
-    "build:binary": "bun build --compile --minify src/index.ts --outfile talon-bun",
     "start": "tsx src/index.ts",
     "cli": "tsx src/cli.ts",
     "setup": "tsx src/cli.ts setup",

package/prompts/mempalace.md

@@ -53,5 +53,8 @@ You have access to a local memory palace via MCP tools. The palace stores verbat
 - 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.
+- Entity detection runs per-language; results include `created_at` timestamps you can surface when the user asks "when did I last…".
 
 ### Palace location: `{{palacePath}}`
+
+### Entity-detection languages: `{{entityLanguages}}`

package/src/__tests__/mcp-launcher-functional.test.ts

@@ -0,0 +1,334 @@
+/**
+ * Functional tests for the MCP launcher supervisor.
+ *
+ * Each test targets a distinct failure mode that would produce an orphaned
+ * MCP subprocess in production. All spawn real Node subprocesses and tear
+ * them down in afterEach — no mocks, no shortcuts. If these pass on Linux
+ * and macOS, the "launcher-wrapped spawns never orphan" claim holds.
+ *
+ * Cases kept:
+ *   1. SIGKILL of parent at scale (headline bug from PR #67).
+ *   2. Graceful stdin-close shutdown (normal Talon exit).
+ *   3. Stubborn child that ignores SIGTERM (validates SIGKILL fallback).
+ *   4. Supervised child exits on its own (launcher doesn't hang).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { spawn, type ChildProcess } from "node:child_process";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const LAUNCHER_MODULE = pathToFileURL(
+  resolve(REPO_ROOT, "src/util/mcp-launcher.ts"),
+).href;
+const TSX_IMPORT = pathToFileURL(
+  resolve(REPO_ROOT, "node_modules/tsx/dist/esm/index.mjs"),
+).href;
+const FUNCTIONAL_TIMEOUT_MS = 30_000;
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "ESRCH") return false;
+    // EPERM: exists but unreachable. Count as alive.
+    return true;
+  }
+}
+
+async function waitForPidGone(
+  pid: number,
+  timeoutMs: number,
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!pidAlive(pid)) return true;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  return !pidAlive(pid);
+}
+
+async function assertAllGone(pids: number[], timeoutMs: number): Promise<void> {
+  const stuck: number[] = [];
+  for (const pid of pids) {
+    if (!(await waitForPidGone(pid, timeoutMs))) stuck.push(pid);
+  }
+  if (stuck.length > 0) {
+    // Clean up the leak so it doesn't poison sibling tests.
+    for (const pid of stuck) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+        /* ok */
+      }
+    }
+    throw new Error(`orphaned pids after teardown: ${stuck.join(", ")}`);
+  }
+}
+
+/** Read the first stdout line matching `match`, with a timeout. */
+async function readMarker(
+  child: ChildProcess,
+  match: RegExp,
+  timeoutMs: number,
+  label: string,
+): Promise<RegExpMatchArray> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`timeout waiting for ${label}`)),
+      timeoutMs,
+    );
+    let buf = "";
+    const onData = (d: Buffer) => {
+      buf += d.toString();
+      const m = buf.match(match);
+      if (m) {
+        clearTimeout(timer);
+        child.stdout!.off("data", onData);
+        resolve(m);
+      }
+    };
+    child.stdout!.on("data", onData);
+    child.once("exit", (code) => {
+      clearTimeout(timer);
+      reject(new Error(`process exited before ${label} (code=${code})`));
+    });
+  });
+}
+
+type IdlerOpts = {
+  name?: string;
+  /** If false, the idler keeps running even after its stdin closes. */
+  exitOnStdinClose?: boolean;
+  /** If true, the idler ignores SIGTERM (forces SIGKILL cleanup path). */
+  ignoreSigterm?: boolean;
+  /** If set, the idler exits on its own this many ms after starting. */
+  selfExitAfterMs?: number;
+};
+
+function writeIdler(dir: string, opts: IdlerOpts = {}): string {
+  const path = join(dir, opts.name ?? "idler.mjs");
+  const exitOnStdin = opts.exitOnStdinClose !== false;
+  const ignoreTerm = opts.ignoreSigterm === true;
+  const selfExit = opts.selfExitAfterMs;
+  writeFileSync(
+    path,
+    `
+    process.stderr.write("IDLER_PID=" + process.pid + "\\n");
+    ${exitOnStdin ? 'process.stdin.on("end", () => process.exit(0));' : ""}
+    process.on("SIGTERM", () => { ${
+      ignoreTerm ? "/* stubborn: ignore */" : "process.exit(0);"
+    } });
+    process.on("SIGINT", () => process.exit(0));
+    process.stdin.resume();
+    ${selfExit !== undefined ? `setTimeout(() => process.exit(0), ${selfExit});` : ""}
+    setInterval(() => {}, 1 << 30);
+    `,
+  );
+  return path;
+}
+
+type HarnessResult = { harness: ChildProcess; pids: number[] };
+
+/**
+ * Spawn a harness that uses the real `wrapMcpServer()` to supervise
+ * `count` idlers. Resolves once every idler has reported its PID, returning
+ * [launcher PIDs..., idler PIDs...] (length = count * 2).
+ */
+async function spawnHarness(opts: {
+  workDir: string;
+  count: number;
+  idlerPath: string;
+}): Promise<HarnessResult> {
+  const { workDir, count, idlerPath } = opts;
+  const harnessPath = join(workDir, "harness.mjs");
+  writeFileSync(
+    harnessPath,
+    `
+    import { spawn } from "node:child_process";
+    import { wrapMcpServer } from ${JSON.stringify(LAUNCHER_MODULE)};
+
+    const launchers = [];
+    const idlers = [];
+    const TARGET = ${count};
+
+    for (let i = 0; i < TARGET; i++) {
+      const cfg = wrapMcpServer({
+        command: "node",
+        args: [${JSON.stringify(idlerPath)}],
+        env: {},
+      });
+      const c = spawn(cfg.command, cfg.args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, ...cfg.env },
+      });
+      launchers.push(c);
+
+      let buf = "";
+      c.stderr.on("data", (d) => {
+        buf += d.toString();
+        const m = buf.match(/IDLER_PID=(\\d+)/);
+        if (m) {
+          idlers.push(parseInt(m[1], 10));
+          buf = buf.replace(/IDLER_PID=\\d+\\n?/, "");
+          if (idlers.length === TARGET) {
+            process.stdout.write(
+              "PIDS=" + launchers.map((c) => c.pid).concat(idlers).join(",") + "\\n",
+            );
+          }
+        }
+      });
+    }
+
+    process.stdin.on("end", () => process.exit(0));
+    process.stdin.resume();
+    `,
+  );
+
+  const harness = spawn("node", ["--import", TSX_IMPORT, harnessPath], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env, HOME: workDir },
+  });
+  const marker = await readMarker(
+    harness,
+    /PIDS=([\d,]+)/,
+    15_000,
+    "harness PID marker",
+  );
+  const pids = marker[1].split(",").map((s) => parseInt(s, 10));
+  if (pids.length !== count * 2) {
+    throw new Error(
+      `harness reported ${pids.length} pids, expected ${count * 2}`,
+    );
+  }
+  return { harness, pids };
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+describe("launcher functional: no orphaned MCP processes", () => {
+  let workDir: string;
+  const cleanup: Array<() => void> = [];
+
+  beforeEach(() => {
+    workDir = mkdtempSync(join(tmpdir(), "talon-launcher-fn-"));
+    process.env.HOME = workDir; // paths.ts reads homedir() → this
+  });
+
+  afterEach(() => {
+    for (const fn of cleanup.splice(0)) {
+      try {
+        fn();
+      } catch {
+        /* ok */
+      }
+    }
+    try {
+      rmSync(workDir, { recursive: true, force: true });
+    } catch {
+      /* ok */
+    }
+  });
+
+  function track(child: ChildProcess): void {
+    cleanup.push(() => {
+      if (!child.killed) {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+          /* ok */
+        }
+      }
+    });
+  }
+
+  it(
+    "SIGKILL of parent cleans up every descendant (10 wrapped children)",
+    async () => {
+      const idler = writeIdler(workDir);
+      const { harness, pids } = await spawnHarness({
+        workDir,
+        count: 10,
+        idlerPath: idler,
+      });
+      track(harness);
+      expect(pids).toHaveLength(20); // 10 launchers + 10 idlers
+
+      harness.kill("SIGKILL");
+      await assertAllGone(pids, 5_000);
+    },
+    FUNCTIONAL_TIMEOUT_MS,
+  );
+
+  it(
+    "graceful shutdown (stdin close) cleans up every descendant",
+    async () => {
+      const idler = writeIdler(workDir);
+      const { harness, pids } = await spawnHarness({
+        workDir,
+        count: 3,
+        idlerPath: idler,
+      });
+      track(harness);
+
+      harness.stdin!.end();
+      const exitCode = await new Promise<number | null>((r) =>
+        harness.on("exit", (c) => r(c)),
+      );
+      expect(exitCode).toBe(0);
+      await assertAllGone(pids, 5_000);
+    },
+    FUNCTIONAL_TIMEOUT_MS,
+  );
+
+  it(
+    "SIGKILLs stubborn children that ignore SIGTERM",
+    async () => {
+      const stubborn = writeIdler(workDir, {
+        name: "stubborn.mjs",
+        ignoreSigterm: true,
+        exitOnStdinClose: false,
+      });
+      const { harness, pids } = await spawnHarness({
+        workDir,
+        count: 2,
+        idlerPath: stubborn,
+      });
+      track(harness);
+
+      harness.kill("SIGKILL");
+      // Launcher: SIGTERM → 1s grace → SIGKILL. Give 4s headroom.
+      await assertAllGone(pids, 4_000);
+    },
+    FUNCTIONAL_TIMEOUT_MS,
+  );
+
+  it(
+    "launcher exits when its supervised child exits on its own",
+    async () => {
+      const oneShot = writeIdler(workDir, {
+        name: "one-shot.mjs",
+        selfExitAfterMs: 200,
+      });
+      const { harness, pids } = await spawnHarness({
+        workDir,
+        count: 1,
+        idlerPath: oneShot,
+      });
+      track(harness);
+
+      // Both launcher (pids[0]) and idler (pids[1]) must be gone within seconds
+      // even though the harness itself is still running.
+      await assertAllGone(pids, 5_000);
+      expect(pidAlive(harness.pid!)).toBe(true);
+    },
+    FUNCTIONAL_TIMEOUT_MS,
+  );
+});

package/src/__tests__/mcp-launcher.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Launcher tests.
+ *
+ * Unit-level: wrapMcpServer + ensureLauncher path resolution.
+ * Integration: spawn the real launcher.mjs, drive it with a dummy child,
+ * close its stdin, verify it terminates the child and exits cleanly.
+ */
+
+import { describe, it, expect } from "vitest";
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+const CHECKED_IN_LAUNCHER = resolve(REPO_ROOT, "src/util/mcp-launcher.mjs");
+
+describe("mcp-launcher", () => {
+  it("wrapMcpServer rewrites command/args to go through node launcher", async () => {
+    const { wrapMcpServer } = await freshLauncher();
+    const wrapped = wrapMcpServer({
+      command: "/usr/bin/python",
+      args: ["-m", "mempalace.mcp_server"],
+      env: { FOO: "bar" },
+    });
+
+    expect(wrapped.command).toBe("node");
+    expect(wrapped.args[0]).toMatch(/mcp-launcher\.mjs$/);
+    expect(wrapped.args.slice(1)).toEqual([
+      "/usr/bin/python",
+      "-m",
+      "mempalace.mcp_server",
+    ]);
+    expect(wrapped.env).toEqual({ FOO: "bar" });
+  });
+
+  it("ensureLauncher returns the checked-in launcher script", async () => {
+    const { ensureLauncher } = await freshLauncher();
+    const path = ensureLauncher();
+
+    expect(path).toBe(CHECKED_IN_LAUNCHER);
+    expect(existsSync(path)).toBe(true);
+    const content = readFileSync(path, "utf-8");
+    expect(content).toContain("Supervises an MCP stdio child");
+    expect(content).toContain("spawn(cmd, args");
+    expect(content).toContain('process.stdin.on("end"');
+  });
+
+  // ── Integration: real launcher + real child ────────────────────────────
+
+  it("terminates the supervised child when parent stdin closes", async () => {
+    const { ensureLauncher } = await freshLauncher();
+    const launcherPath = ensureLauncher();
+
+    // Dummy child: a Node one-liner that keeps stdin open forever and prints
+    // a ready marker so the parent can detect it has spawned. It will only
+    // exit when its stdin closes (which happens when the launcher dies).
+    const childScript = `
+      process.stdout.write("READY\\n");
+      process.stdin.on("data", (d) => process.stdout.write(d));
+      process.stdin.on("end", () => process.exit(0));
+      process.stdin.resume();
+    `;
+
+    const launcher = spawn("node", [launcherPath, "node", "-e", childScript], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    // Wait for READY to confirm stdio proxy is up
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error("timeout waiting for READY")),
+        5000,
+      );
+      launcher.stdout!.on("data", (chunk) => {
+        if (chunk.toString().includes("READY")) {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+      launcher.on("exit", () => {
+        clearTimeout(timeout);
+        reject(new Error("launcher exited before READY"));
+      });
+    });
+
+    // Close our write-end → launcher sees stdin EOF → it SIGTERMs the child
+    // → launcher exits.
+    launcher.stdin!.end();
+
+    const exitCode = await new Promise<number | null>((resolve) => {
+      launcher.on("exit", (code) => resolve(code));
+    });
+    expect(exitCode).toBe(0);
+  }, 10_000);
+
+  it("proxies stdin→stdout verbatim while the child is alive", async () => {
+    const { ensureLauncher } = await freshLauncher();
+    const launcherPath = ensureLauncher();
+
+    // Echo-style child.
+    const childScript = `
+      process.stdin.on("data", (d) => process.stdout.write(d));
+      process.stdin.resume();
+    `;
+    const launcher = spawn("node", [launcherPath, "node", "-e", childScript], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    const output: Buffer[] = [];
+    launcher.stdout!.on("data", (c) => output.push(c));
+    launcher.stdin!.write("hello\n");
+
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("echo timeout")), 5000);
+      const check = setInterval(() => {
+        if (Buffer.concat(output).toString().includes("hello")) {
+          clearInterval(check);
+          clearTimeout(timeout);
+          resolve();
+        }
+      }, 50);
+    });
+
+    launcher.stdin!.end();
+    await new Promise((r) => launcher.on("exit", r));
+    expect(Buffer.concat(output).toString()).toContain("hello");
+  }, 10_000);
+});
+
+/**
+ * Import the launcher module fresh so mocks and module state never leak
+ * between tests.
+ */
+async function freshLauncher() {
+  const { vi } = await import("vitest");
+  vi.resetModules();
+  return import("../util/mcp-launcher.js");
+}

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

@@ -15,6 +15,7 @@ mempalace_diary_write mempalace_diary_read mempalace_delete_drawer
 Protocol
 
 ### Palace location: \`{{palacePath}}\`
+### Entity-detection languages: \`{{entityLanguages}}\`
 `;
 
 describe("mempalace plugin", () => {
@@ -54,7 +55,7 @@ describe("mempalace plugin", () => {
     });
 
     expect(plugin.name).toBe("mempalace");
-    expect(plugin.version).toBe("1.0.0");
+    expect(plugin.version).toBe("1.1.0");
     expect(plugin.mcpServer).toEqual({
       command: "/venv/bin/python",
       args: ["-m", "mempalace.mcp_server", "--palace", "/data/palace"],
@@ -224,6 +225,33 @@ describe("mempalace plugin", () => {
     });
   });
 
+  it("getEnvVars includes MEMPALACE_ENTITY_LANGUAGES and MEMPAL_VERBOSE when configured", 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",
+      entityLanguages: ["en", "ja", "fr"],
+      verbose: true,
+    });
+
+    expect(plugin.getEnvVars!({})).toEqual({
+      MEMPALACE_PALACE_PATH: "/data/palace",
+      MEMPALACE_ENTITY_LANGUAGES: "en,ja,fr",
+      MEMPAL_VERBOSE: "1",
+    });
+  });
+
   it("getSystemPromptAddition loads from .md file and interpolates palacePath", async () => {
     vi.doMock("node:fs", () => ({
       existsSync: vi.fn(() => true),
@@ -256,8 +284,35 @@ describe("mempalace plugin", () => {
     expect(addition).toContain("mempalace_delete_drawer");
     expect(addition).toContain("Protocol");
     expect(addition).toContain("/custom/palace");
+    // Default entity-language interpolation
+    expect(addition).toContain("en (default)");
     // Verify interpolation happened — no raw placeholder
     expect(addition).not.toContain("{{palacePath}}");
+    expect(addition).not.toContain("{{entityLanguages}}");
+  });
+
+  it("getSystemPromptAddition interpolates configured entity languages", 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",
+      entityLanguages: ["en", "ja"],
+    });
+
+    const addition = plugin.getSystemPromptAddition!({});
+    expect(addition).toContain("en, ja");
+    expect(addition).not.toContain("{{entityLanguages}}");
   });
 
   it("getSystemPromptAddition returns fallback when .md file is missing", async () => {

package/src/__tests__/plugin.test.ts

@@ -8,6 +8,14 @@ vi.mock("../util/log.js", () => ({
   logDebug: vi.fn(),
 }));
 
+// Identity-wrap so existing assertions can match the raw MCP server shape
+// without the launcher prefix. Dedicated wrap behavior is covered in
+// mcp-launcher.test.ts.
+vi.mock("../util/mcp-launcher.js", () => ({
+  wrapMcpServer: <T>(server: T) => server,
+  ensureLauncher: () => "/tmp/fake-launcher.mjs",
+}));
+
 describe("plugin system", () => {
   beforeEach(() => {
     vi.resetModules();

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

@@ -11,6 +11,7 @@ import { getSession } from "../../storage/sessions.js";
 import { getChatSettings } from "../../storage/chat-settings.js";
 import { getPluginMcpServers } from "../../core/plugin.js";
 import { resolveModelId } from "../../core/models.js";
+import { wrapMcpServer } from "../../util/mcp-launcher.js";
 import { getConfig, getBridgePort } from "./state.js";
 import { DISALLOWED_TOOLS_CHAT, EFFORT_MAP } from "./constants.js";
 
@@ -64,26 +65,26 @@ export function buildMcpServers(
       TALON_CHAT_ID: chatId,
       TALON_FRONTEND: frontend,
     };
-    servers[serverName] = {
+    servers[serverName] = wrapMcpServer({
       command: process.platform === "win32" ? "npx" : "node",
       args:
         process.platform === "win32"
           ? ["tsx", mcpServerPath]
           : ["--import", tsxImport, mcpServerPath],
       env: mcpEnv,
-    };
+    });
   }
 
   // Brave Search MCP server (if configured)
   if (config.braveApiKey) {
-    servers["brave-search"] = {
+    servers["brave-search"] = wrapMcpServer({
       command: resolve(
         import.meta.dirname ?? ".",
         "../../../node_modules/.bin/brave-search-mcp-server",
       ),
       args: [],
       env: { BRAVE_API_KEY: config.braveApiKey },
-    };
+    });
   }
 
   return servers;

package/src/core/dream.ts

@@ -149,7 +149,7 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
 Run this command using the Bash tool:
 
 \`\`\`bash
-'${configRef.mempalace.pythonPath.replace(/'/g, "'\\''")}' -m mempalace mine '${dirs.dailyMemory.replace(/'/g, "'\\''")}' --palace '${configRef.mempalace.palacePath.replace(/'/g, "'\\''")}' --mode convos --wing daily-notes
+'${configRef.mempalace.pythonPath.replace(/'/g, "'\\''")}' -m mempalace mine '${dirs.dailyMemory.replace(/'/g, "'\\''")}' --palace '${configRef.mempalace.palacePath.replace(/'/g, "'\\''")}' --mode convos --wing daily-notes --agent talon
 \`\`\`
 
 Then write a personal diary entry. This is YOUR journal — not a status report. Reflect on:

package/src/core/plugin.ts

@@ -17,6 +17,7 @@
 import { resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { log, logError, logWarn } from "../util/log.js";
+import { wrapMcpServer } from "../util/mcp-launcher.js";
 import type { ActionResult } from "./types.js";
 import type { TalonConfig } from "../util/config.js";
 
@@ -524,7 +525,12 @@ export async function loadBuiltinPlugins(config: TalonConfig): Promise<void> {
       const { dirs, files: pf } = await import("../util/paths.js");
       const pythonPath = mempalace.pythonPath ?? pf.mempalacePython;
       const palacePath = mempalace.palacePath ?? dirs.palace;
-      const mp = createMempalacePlugin({ pythonPath, palacePath });
+      const mp = createMempalacePlugin({
+        pythonPath,
+        palacePath,
+        entityLanguages: mempalace.entityLanguages,
+        verbose: mempalace.verbose,
+      });
       const mpConfig = mempalace as unknown as Record<string, unknown>;
       const loaded = registerPlugin(mp, mpConfig);
       if (loaded) {
@@ -738,32 +744,32 @@ export function getPluginMcpServers(
 
     if (plugin.mcpServer) {
       // Custom command/args (Python, Go, etc.) — no tsx wrapper
-      servers[`${plugin.name}-tools`] = {
+      servers[`${plugin.name}-tools`] = wrapMcpServer({
         command: plugin.mcpServer.command,
         args: [...plugin.mcpServer.args],
         env: baseEnv,
-      };
+      });
     } else if (plugin.mcpServerPath) {
       // Existing Node/tsx pattern
-      servers[`${plugin.name}-tools`] = {
+      servers[`${plugin.name}-tools`] = wrapMcpServer({
         command: process.platform === "win32" ? "npx" : "node",
         args:
           process.platform === "win32"
             ? ["tsx", plugin.mcpServerPath]
             : ["--import", tsxPath, plugin.mcpServerPath],
         env: baseEnv,
-      };
+      });
     }
   }
 
   // Include standalone MCP server entries from config
   for (const entry of registry.mcpEntries) {
     if (only !== undefined && !only.includes(entry.name)) continue;
-    servers[`${entry.name}-tools`] = {
+    servers[`${entry.name}-tools`] = wrapMcpServer({
       command: entry.command,
       args: [...(entry.args ?? [])],
       env: buildBridgeEnv(bridgeUrl, chatId, entry.env),
-    };
+    });
   }
 
   return servers;

package/src/plugins/mempalace/index.ts

@@ -7,8 +7,10 @@
  * Configuration in ~/.talon/config.json:
  *   "mempalace": {
  *     "enabled": true,
- *     "palacePath": "/path/to/palace",   // optional, defaults to ~/.talon/workspace/palace/
- *     "pythonPath": "/path/to/python"     // optional, defaults to mempalace venv python (bin/python on Unix, Scripts/python.exe on Windows)
+ *     "palacePath": "/path/to/palace",         // optional, defaults to ~/.talon/workspace/palace/
+ *     "pythonPath": "/path/to/python",         // optional, defaults to mempalace venv python (bin/python on Unix, Scripts/python.exe on Windows)
+ *     "entityLanguages": ["en", "ja"],         // optional, BCP 47 codes (mempalace >= 3.3)
+ *     "verbose": false                          // optional, enables MEMPAL_VERBOSE diagnostics
  *   }
  */
 
@@ -32,14 +34,28 @@ const PROMPT_PATH = resolve(dirs.prompts, "mempalace.md");
 export function createMempalacePlugin(config: {
   pythonPath: string;
   palacePath: string;
+  /** BCP 47 codes passed via MEMPALACE_ENTITY_LANGUAGES (mempalace >= 3.3). */
+  entityLanguages?: readonly string[];
+  /** When true, sets MEMPAL_VERBOSE=1 so the MCP server logs diagnostic diaries. */
+  verbose?: boolean;
 }): TalonPlugin {
-  const { pythonPath, palacePath } = config;
+  const { pythonPath, palacePath, entityLanguages, verbose } = config;
+
+  const envVars: Record<string, string> = {
+    MEMPALACE_PALACE_PATH: palacePath,
+  };
+  if (entityLanguages && entityLanguages.length > 0) {
+    envVars.MEMPALACE_ENTITY_LANGUAGES = entityLanguages.join(",");
+  }
+  if (verbose) {
+    envVars.MEMPAL_VERBOSE = "1";
+  }
 
   return {
     name: "mempalace",
     description:
       "Memory palace — structured long-term memory with vector search",
-    version: "1.0.0",
+    version: "1.1.0",
 
     mcpServer: {
       command: pythonPath,
@@ -122,25 +138,33 @@ export function createMempalacePlugin(config: {
         );
       }
 
-      log("mempalace", `Ready (palace: ${palacePath})`);
+      const langSuffix =
+        entityLanguages && entityLanguages.length > 0
+          ? ` (languages: ${entityLanguages.join(",")})`
+          : "";
+      log("mempalace", `Ready (palace: ${palacePath})${langSuffix}`);
     },
 
     getEnvVars() {
-      return {
-        MEMPALACE_PALACE_PATH: palacePath,
-      };
+      return { ...envVars };
     },
 
     getSystemPromptAddition() {
+      const languagesLine =
+        entityLanguages && entityLanguages.length > 0
+          ? entityLanguages.join(", ")
+          : "en (default)";
       try {
         const template = readFileSync(PROMPT_PATH, "utf-8");
-        return template.replace(/\{\{palacePath\}\}/g, palacePath);
+        return template
+          .replace(/\{\{palacePath\}\}/g, palacePath)
+          .replace(/\{\{entityLanguages\}\}/g, languagesLine);
       } catch (err) {
         logWarn(
           "mempalace",
           `Failed to load prompt from ${PROMPT_PATH}: ${err instanceof Error ? err.message : err}`,
         );
-        return `## MemPalace — Long-term Memory\n\nPalace location: \`${palacePath}\``;
+        return `## MemPalace — Long-term Memory\n\nPalace location: \`${palacePath}\`\nEntity languages: ${languagesLine}`;
       }
     },
   };

package/src/util/config.ts

@@ -151,6 +151,14 @@ const configSchema = z.object({
       palacePath: z.string().min(1).optional(),
       /** Python binary path (default: ~/.talon/mempalace-venv/bin/python) */
       pythonPath: z.string().min(1).optional(),
+      /**
+       * BCP 47 language codes for entity detection (mempalace >= 3.3).
+       * Supported: en, es, fr, de, ja, ko, zh-CN, zh-TW, pt-br, ru, it, hi, id.
+       * Sets MEMPALACE_ENTITY_LANGUAGES for the MCP server.
+       */
+      entityLanguages: z.array(z.string().min(2)).nonempty().optional(),
+      /** Enable mempalace diagnostic diaries (sets MEMPAL_VERBOSE=1). */
+      verbose: z.boolean().optional(),
     })
     .optional(),
 

package/src/util/log.ts

@@ -73,11 +73,6 @@ try {
   /* ignore */
 }
 
-// Detect if running as a bun compiled binary (pino-pretty can't be bundled).
-// import.meta.path is Bun-specific — undefined in Node.js/Vitest, so guard with ?.
-const isBunBinary =
-  (import.meta as { path?: string }).path?.startsWith("/$bunfs/") ?? false;
-
 // Suppress console output for terminal frontend (stdout belongs to the REPL)
 let quiet = process.env.TALON_QUIET === "1";
 if (!quiet) {
@@ -96,8 +91,8 @@ const logger = pino({
   level: "trace",
   transport: {
     targets: [
-      // Console output (disabled in quiet mode or compiled binary)
-      ...(!quiet && !isBunBinary
+      // Console output (disabled in quiet mode)
+      ...(!quiet
         ? [
             {
               target: "pino-pretty",

package/src/util/mcp-launcher.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+/**
+ * Supervises an MCP stdio child. Dies with the child when our own stdin
+ * pipe closes, which happens whenever the Claude Agent SDK side goes away.
+ */
+import { spawn } from "node:child_process";
+
+const [, , cmd, ...args] = process.argv;
+if (!cmd) {
+  process.stderr.write("mcp-launcher: missing command\n");
+  process.exit(2);
+}
+
+const child = spawn(cmd, args, {
+  stdio: ["pipe", "pipe", "pipe"],
+  env: process.env,
+});
+
+// Any pipe end-point can throw EPIPE if the other side closes mid-write.
+// We silence those; the exit and close paths already drive shutdown.
+const swallow = () => {};
+child.stdin.on("error", swallow);
+child.stdout.on("error", swallow);
+child.stderr.on("error", swallow);
+process.stdin.on("error", swallow);
+process.stdout.on("error", swallow);
+process.stderr.on("error", swallow);
+
+process.stdin.pipe(child.stdin);
+child.stdout.pipe(process.stdout);
+child.stderr.pipe(process.stderr);
+
+let terminating = false;
+
+function terminate(exitCode) {
+  if (terminating) return;
+  terminating = true;
+  try {
+    child.kill("SIGTERM");
+  } catch {}
+  const force = setTimeout(() => {
+    try {
+      child.kill("SIGKILL");
+    } catch {}
+  }, 1000);
+  force.unref?.();
+  child.once("exit", () => {
+    clearTimeout(force);
+    process.exit(exitCode);
+  });
+}
+
+process.stdin.on("end", () => terminate(0));
+process.stdin.on("close", () => terminate(0));
+
+child.once("exit", (code, signal) => {
+  if (terminating) return;
+  process.exit(code ?? (signal ? 1 : 0));
+});
+child.once("error", (err) => {
+  process.stderr.write(`mcp-launcher: spawn error: ${err.message}\n`);
+  process.exit(1);
+});
+
+const signals =
+  process.platform === "win32"
+    ? ["SIGTERM", "SIGINT"]
+    : ["SIGTERM", "SIGINT", "SIGHUP"];
+for (const sig of signals) {
+  process.on(sig, () => terminate(0));
+}

package/src/util/mcp-launcher.ts

@@ -0,0 +1,58 @@
+/**
+ * MCP supervisor launcher.
+ *
+ * Every MCP stdio server Talon hands to the Claude Agent SDK is wrapped
+ * through a checked-in Node supervisor:
+ * `node src/util/mcp-launcher.mjs <real-cmd> [args...]`.
+ *
+ * The supervisor proxies stdio between the SDK and the real child, and
+ * watches its own `process.stdin` for EOF. When the SDK's pipe closes —
+ * for any reason, including Talon crashing or being SIGKILLed — the
+ * kernel closes our stdin, we SIGTERM the child, then SIGKILL if it
+ * hasn't exited within a short grace, then exit. No orphans, no /proc
+ * scan, no per-plugin signature list.
+ *
+ * Talon now requires a normal source or package install with this launcher
+ * file present on disk. Standalone bun-compiled binaries are unsupported.
+ */
+
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const LAUNCHER_PATH = fileURLToPath(
+  new URL("./mcp-launcher.mjs", import.meta.url),
+);
+
+/**
+ * Resolve the checked-in launcher script path and verify it exists on disk.
+ */
+export function ensureLauncher(): string {
+  if (!existsSync(LAUNCHER_PATH)) {
+    throw new Error(
+      `MCP launcher missing at ${LAUNCHER_PATH}. Talon must run from a normal source or package install; bun-compiled binaries are not supported.`,
+    );
+  }
+  return LAUNCHER_PATH;
+}
+
+type StdioServer = {
+  command: string;
+  args: string[];
+  env?: Record<string, string>;
+};
+
+/**
+ * Rewrite `{command, args}` so the real command runs under the launcher.
+ *
+ * Plugin-agnostic: the launcher doesn't know or care what it's supervising.
+ * Platform-agnostic: relies on pipe EOF, which POSIX and Windows both
+ * deliver when the parent end of a pipe is closed.
+ */
+export function wrapMcpServer<T extends StdioServer>(server: T): T {
+  const launcher = ensureLauncher();
+  return {
+    ...server,
+    command: "node",
+    args: [launcher, server.command, ...server.args],
+  };
+}