arisa 4.0.16 → 4.0.20

package/AGENTS.md

@@ -31,7 +31,24 @@ Each tool declares in `tool.manifest.json`:
 - `output`: produced output types
 - `configSchema`: required config fields
 - `skillHints`: optional skills to apply when using or editing the tool
-- `web.routes`: optional HTTP routes exposed through Arisa's main server
+
+## Tool-to-Arisa IPC
+Arisa does not mount tool-provided web routes in core. If a tool needs to expose a web UI or HTTP endpoint, the tool owns that server, usually through the shared daemon runtime. The tool's server handles its own requests and uses Arisa IPC when it needs artifacts, tasks, agent events, or runtime paths.
+
+Installed tools can import the IPC client through `ARISA_PACKAGE_DIR`:
+
+```js
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const importCore = (relativePath) => import(pathToFileURL(path.join(process.env.ARISA_PACKAGE_DIR, "src", relativePath)).href);
+const { createArisaClient } = await importCore("core/tools/ipc-client.js");
+
+const arisa = createArisaClient({ toolName: "example-tool", chatId });
+await arisa.artifacts.createText({ text: "hello" });
+```
+
+The IPC channel is a local socket under `~/.arisa/state`. Every request must include `toolName`; chat-scoped capabilities also require `chatId`. Exposed capabilities are explicit: artifacts (`createText`, `listRecent`, `get`), tasks (`add`, `list`, `cancel`), agent events (`enqueueEvent`), and runtime paths (`getChatToolStateDir`, `getToolStateDir`, `getChatToolTmpDir`, `getToolTmpDir`, `getChatArtifactsDir`). Do not add raw access to `agentManager`, `taskStore`, `artifactStore`, or `toolRegistry`.
 
 ## Conceptual pipe model
 There are two different moments where pipes can happen:
@@ -72,27 +89,6 @@ Every CLI must support (the entrypoint comes from `manifest.entry`, currently al
 - `node index.js --help`
 - `node index.js run --request-file <json>`
 
-## Tool-provided web routes
-Tools may expose small web pages or HTTP endpoints through Arisa's main HTTP server by declaring `web.routes` in `tool.manifest.json`. See `tools/README.md` and `tools/web-hello` for the full contract and minimal example.
-
-```json
-{
-  "name": "example-tool",
-  "web": {
-    "routes": [
-      {
-        "path": "/example",
-        "handler": "web/index.js",
-        "methods": ["GET"],
-        "public": false
-      }
-    ]
-  }
-}
-```
-
-Handlers run in-process and export `handleWebRequest(req, res, context)`. Routes are protected by default with `config.web.token`; use `public: true` only for intentional public GET endpoints. Keep handlers inside the installed tool directory, avoid reserved paths (`/`, `/health`, `/api*`, `/auth*`, `/telegram-*`), and persist data only through `context.paths` runtime helpers such as `getChatToolStateDir(chatId, toolName)`.
-
 ### Tools that need daemons
 A tool may need a persistent process, for example to keep a browser session alive or a local model warm. The shared daemon runtime exists for this (the `whispermix-transcribe` catalog tool uses it).
 When such a tool is built, implement it with the shared daemon runtime instead of custom ad hoc process management:
@@ -103,6 +99,7 @@ When such a tool is built, implement it with the shared daemon runtime instead o
 - keep one daemon owner per tool/session and avoid opening a second client over the same resource
 - use `beforeStart` only for tool-specific cleanup such as stale browser locks, without deleting persistent session/model data
 - keep daemon tools headless/server-safe by default when they are meant to run on VPS machines
+- if the daemon exposes an HTTP server, keep that server inside the tool; Arisa core does not discover or mount tool routes
 
 ## Manual pipe behavior
 To run a pipe, the agent should:

package/README.md

@@ -114,6 +114,7 @@ arisa start              # start in background
 arisa stop               # stop background service
 arisa status             # show background service status
 arisa flush              # remove ~/.arisa
+arisa --silent           # run without verbose logs
 ```
 
 Runtime model override (current process only):
@@ -138,32 +139,7 @@ On first run, Arisa will:
 6. validate that Pi Agent works
 7. only then start listening to Telegram
 
-### Non-interactive bootstrap (CLI overrides)
-
-You can skip the interactive questions by providing `--telegram.token` and optional overrides:
-
-```bash
-node src/index.js --telegram.token <token>
-```
-
-With this mode, Arisa creates `~/.arisa/state/config.json` without prompts and applies these defaults when not provided:
-
-- `pi.provider`: `openai-codex` when available, otherwise first provider from the current Pi provider list
-- `pi.model`: first model after bootstrap sorting (currently prioritizes `openai-codex/gpt-5.5`)
-- `telegram.maxChatIds`: `1`
-
-Supported overrides:
-
-```bash
-node src/index.js --telegram.token <token> --telegram.maxChatIds 3 --pi.provider openai-codex --pi.model gpt-5.5 --pi.apiKey <optional-provider-key>
-```
-
-Notes:
-
-- interactive bootstrap remains unchanged when no CLI overrides are provided
-- `--bootstrap` can be combined with overrides to regenerate config non-interactively
-- Arisa's HTTP server listens on `ARISA_HTTP_PORT` (default `11970`); bootstrap OAuth pages and tool-provided web routes use this server
-- unknown `--pi.provider` or `--pi.model` values are ignored and replaced by safe defaults
+Arisa does not run a persistent HTTP health server or Telegram webhook; Telegram uses long polling.
 
 Telegram bot tokens can be created with:
 

package/package.json

@@ -1,17 +1,12 @@
 {
   "name": "arisa",
-  "version": "4.0.16",
+  "version": "4.0.20",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",
   "bin": {
     "arisa": "bin/arisa.js"
   },
-  "scripts": {
-    "start": "node src/index.js",
-    "bootstrap": "node src/index.js --bootstrap",
-    "test": "node --test"
-  },
   "keywords": [
     "telegram",
     "pi-agent",
@@ -41,10 +36,14 @@
     "url": "https://github.com/clasen/Arisa/issues"
   },
   "homepage": "https://github.com/clasen/Arisa#readme",
-  "packageManager": "pnpm@11.3.0+sha512.2c403d6594527287672b1f7056343a1f7c3634036a67ffabfcc2b3d7595d843768f8787148d1b57cf7956c90606bbd192857c363af19e96d2d0ec9ec5741d215",
   "dependencies": {
     "@earendil-works/pi-coding-agent": "^0.79.9",
     "@sinclair/typebox": "^0.34.41",
     "grammy": "^1.42.0"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "bootstrap": "node src/index.js --bootstrap",
+    "test": "node --test"
   }
-}
+}

package/src/core/tools/ipc-client.js

@@ -0,0 +1,94 @@
+import crypto from "node:crypto";
+import net from "node:net";
+import { arisaIpcSocketFile } from "../../runtime/paths.js";
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+
+function requestIpc({ socketPath, request, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    let buffer = "";
+    let settled = false;
+
+    function finish(fn, value) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      socket.end();
+      fn(value);
+    }
+
+    const timeout = setTimeout(() => {
+      socket.destroy();
+      finish(reject, new Error("Arisa IPC request timed out"));
+    }, timeoutMs);
+    timeout.unref?.();
+
+    socket.setEncoding("utf8");
+    socket.once("connect", () => {
+      socket.write(`${JSON.stringify(request)}\n`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) return;
+      const line = buffer.slice(0, newlineIndex);
+      try {
+        const response = JSON.parse(line);
+        if (!response.ok) {
+          finish(reject, new Error(response.error || "Arisa IPC request failed"));
+          return;
+        }
+        finish(resolve, response.result);
+      } catch (error) {
+        finish(reject, error);
+      }
+    });
+    socket.once("error", (error) => {
+      finish(reject, error);
+    });
+    socket.once("close", () => {
+      finish(reject, new Error("Arisa IPC connection closed before response"));
+    });
+  });
+}
+
+export function createArisaClient({ toolName, chatId = null, socketPath = process.env.ARISA_IPC_SOCKET || arisaIpcSocketFile } = {}) {
+  if (typeof toolName !== "string" || !toolName.trim()) {
+    throw new Error("toolName is required");
+  }
+
+  const call = (method, params = {}) => requestIpc({
+    socketPath,
+    request: {
+      id: crypto.randomUUID(),
+      method,
+      toolName,
+      chatId,
+      params
+    }
+  });
+
+  return {
+    artifacts: {
+      createText: (params) => call("artifacts.createText", params),
+      listRecent: (params) => call("artifacts.listRecent", params),
+      get: (params) => call("artifacts.get", params)
+    },
+    tasks: {
+      add: (params) => call("tasks.add", params),
+      list: (params) => call("tasks.list", params),
+      cancel: (params) => call("tasks.cancel", params)
+    },
+    agent: {
+      enqueueEvent: (params) => call("agent.enqueueEvent", params)
+    },
+    paths: {
+      getChatToolStateDir: () => call("paths.getChatToolStateDir"),
+      getToolStateDir: () => call("paths.getToolStateDir"),
+      getChatToolTmpDir: () => call("paths.getChatToolTmpDir"),
+      getToolTmpDir: () => call("paths.getToolTmpDir"),
+      getChatArtifactsDir: () => call("paths.getChatArtifactsDir")
+    }
+  };
+}

package/src/core/tools/tool-registry.js

@@ -1,14 +1,13 @@
 import { mkdir, readdir, readFile, rmdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
-import { arisaPackageDir, getToolConfigPath, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
-import { validateToolWebRoutes } from "../../runtime/web/route-validation.js";
+import { arisaIpcSocketFile, arisaPackageDir, getToolConfigPath, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 import { normalizeToolResult } from "./tool-result.js";
 import { SkillRegistry } from "../skills/skill-registry.js";
 
 function toolEnv() {
-  return { ...process.env, ARISA_PACKAGE_DIR: arisaPackageDir };
+  return { ...process.env, ARISA_PACKAGE_DIR: arisaPackageDir, ARISA_IPC_SOCKET: arisaIpcSocketFile };
 }
 
 function runProcess(command, args, options = {}) {
@@ -26,14 +25,11 @@ export class ToolRegistry {
   constructor({ logger } = {}) {
     this.logger = logger;
     this.tools = new Map();
-    this.webRoutes = [];
     this.skillRegistry = new SkillRegistry();
   }
 
   async load() {
     this.tools.clear();
-    this.webRoutes = [];
-    const claimedWebPaths = new Map();
 
     let entries = [];
     try {
@@ -54,7 +50,7 @@ export class ToolRegistry {
         const defaults = parseConfigModule(configSource);
         const config = await loadToolConfig(manifest.name, defaults);
         const skillHints = this.skillRegistry.normalizeHints(manifest);
-        const tool = {
+        this.tools.set(manifest.name, {
           ...manifest,
           skillHints,
           dir: toolDir,
@@ -63,13 +59,7 @@ export class ToolRegistry {
           configPath: getToolConfigPath(manifest.name),
           defaults,
           config
-        };
-        this.tools.set(manifest.name, tool);
-        const { routes, errors } = validateToolWebRoutes(manifest, toolDir, claimedWebPaths);
-        this.webRoutes.push(...routes);
-        for (const error of errors) {
-          this.logger?.log("web", `skipping route for ${manifest.name}: ${error.error}`);
-        }
+        });
       } catch {
         // ignore invalid tool dirs in v1
       }
@@ -89,13 +79,6 @@ export class ToolRegistry {
     }));
   }
 
-  listWebRoutes() {
-    return this.webRoutes.map((route) => ({
-      ...route,
-      methods: [...route.methods]
-    }));
-  }
-
   get(name) {
     return this.tools.get(name) || null;
   }

package/src/index.js

@@ -1,14 +1,11 @@
 #!/usr/bin/env node
 
-import { createServer } from "node:http";
-import { execFile } from "node:child_process";
 import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
 import { createApp } from "./runtime/create-app.js";
 import { createLogger } from "./runtime/logger.js";
 import { getServiceStatus, registerServiceProcess, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
 import { flushArisaHome } from "./runtime/flush.js";
 import { arisaPackageDir } from "./runtime/paths.js";
-import { parseProcessIds } from "./runtime/process-ids.js";
 
 process.env.ARISA_PACKAGE_DIR = arisaPackageDir;
 
@@ -16,136 +13,13 @@ const args = process.argv.slice(2);
 const cli = parseCliArgs(args);
 const command = cli.positionals[0] || "run";
 const forceBootstrap = Boolean(cli.flags.bootstrap);
-const verbose = Boolean(cli.flags.verbose);
+const verbose = !cli.flags.silent;
 const serviceRunner = Boolean(cli.flags["service-runner"]);
-const bootstrapOverrides = toBootstrapOverrides(cli.nestedFlags);
-const runtimeOverrides = toRuntimeOverrides(cli.nestedFlags);
+const runtimeOverrides = toNestedOverrides(cli.nestedFlags);
 const logger = createLogger({ verbose });
 let activeApp = null;
 let shuttingDown = false;
 
-const defaultHttpPort = 11970;
-const httpPort = Number(process.env.ARISA_HTTP_PORT || defaultHttpPort);
-const shouldStartHttpServer = Boolean(httpPort && !["stop", "status", "flush"].includes(command));
-let httpRequestHandler = null;
-let httpServerListening = false;
-let httpServer = null;
-
-function setHttpRequestHandler(handler) {
-  httpRequestHandler = handler;
-}
-
-const httpServerReady = shouldStartHttpServer
-  ? startHttpServer()
-  : Promise.resolve(false);
-
-async function runCommand(commandName, args = []) {
-  return new Promise((resolve) => {
-    execFile(commandName, args, (error, stdout = "") => {
-      resolve(error ? "" : stdout.trim());
-    });
-  });
-}
-
-async function getListeningPids(port) {
-  const lsofOutput = await runCommand("lsof", ["-tiTCP", `-sTCP:LISTEN`, `-iTCP:${port}`]);
-  if (lsofOutput) {
-    return parseProcessIds(lsofOutput);
-  }
-
-  const fuserOutput = await runCommand("fuser", ["-n", "tcp", String(port)]);
-  return parseProcessIds(fuserOutput);
-}
-
-async function getProcessCommand(pid) {
-  return runCommand("ps", ["-p", String(pid), "-o", "command="]);
-}
-
-function looksLikeArisaProcess(commandText) {
-  return /\barisa\b/.test(commandText) || /\/arisa\/src\/index\.js\b/i.test(commandText);
-}
-
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function waitForProcessExit(pid, timeoutMs = 3000) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!isProcessRunning(pid)) return true;
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  return !isProcessRunning(pid);
-}
-
-async function stopStaleArisaListeners(port) {
-  const pids = await getListeningPids(port);
-  for (const pid of pids) {
-    if (pid === process.pid) continue;
-    const commandText = await getProcessCommand(pid);
-    if (!looksLikeArisaProcess(commandText)) {
-      logger.error("http", `port ${port} is already used by pid ${pid}; not killing non-Arisa process`);
-      continue;
-    }
-
-    logger.log("http", `stopping stale Arisa listener on port ${port} (pid ${pid})`);
-    try {
-      process.kill(pid, "SIGTERM");
-      if (!await waitForProcessExit(pid)) {
-        process.kill(pid, "SIGKILL");
-        await waitForProcessExit(pid, 1000);
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error("http", `failed to stop stale Arisa listener pid ${pid}: ${message}`);
-    }
-  }
-}
-
-async function startHttpServer() {
-  await stopStaleArisaListeners(httpPort);
-  return new Promise((resolve) => {
-    const server = createServer((req, res) => {
-      if (httpRequestHandler) return httpRequestHandler(req, res);
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.end("ok");
-      return undefined;
-    });
-    httpServer = server;
-    server.on("error", (error) => {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error("http", `server failed on port ${httpPort}: ${message}`);
-      resolve(false);
-    });
-    server.listen(httpPort)
-      .on("listening", () => {
-        httpServerListening = true;
-        logger.log("http", `health server on port ${httpPort}`);
-        resolve(true);
-      });
-  });
-}
-
-async function getHttpOptions() {
-  await httpServerReady;
-  return httpServerListening ? { httpPort, setHttpRequestHandler } : {};
-}
-
-async function stopHttpServer() {
-  if (!httpServerListening || !httpServer) return;
-  await new Promise((resolve) => {
-    httpServer.close(() => resolve());
-  });
-  httpServer = null;
-  httpServerListening = false;
-  httpRequestHandler = null;
-}
-
 function parseCliArgs(rawArgs) {
   const flags = {};
   const nestedFlags = {};
@@ -176,7 +50,7 @@ function parseCliArgs(rawArgs) {
   return { flags, nestedFlags, positionals };
 }
 
-function toBootstrapOverrides(nestedFlags) {
+function toNestedOverrides(nestedFlags) {
   const overrides = {};
   for (const [flatKey, value] of Object.entries(nestedFlags)) {
     const parts = flatKey.split(".");
@@ -193,10 +67,6 @@ function toBootstrapOverrides(nestedFlags) {
   return overrides;
 }
 
-function toRuntimeOverrides(nestedFlags) {
-  return toBootstrapOverrides(nestedFlags);
-}
-
 function toServiceRunnerArgs(nestedFlags) {
   const args = [];
   if (nestedFlags["pi.model"]) {
@@ -205,14 +75,11 @@ function toServiceRunnerArgs(nestedFlags) {
   return args;
 }
 
-const webhookUrl = bootstrapOverrides.webhook?.url || "";
-
 async function shutdown(exitCode = 0) {
   if (shuttingDown) return;
   shuttingDown = true;
   try {
     await activeApp?.stop?.();
-    await stopHttpServer();
   } catch (error) {
     logger.error("app", `shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
     exitCode = exitCode || 1;
@@ -231,8 +98,8 @@ process.once("SIGINT", () => {
   shutdown(0);
 });
 
-async function startRuntimeApp(httpOptions = {}) {
-  const app = await createApp({ logger, runtimeOverrides, webhookUrl, ...httpOptions });
+async function startRuntimeApp() {
+  const app = await createApp({ logger, runtimeOverrides });
   activeApp = app;
   await app.start();
 }
@@ -244,10 +111,9 @@ async function runForeground() {
     || runtimeOverrides?.pi?.apiKey
   );
   logger.log("app", `starting${verbose ? " in verbose mode" : ""}`);
-  const httpOptions = await getHttpOptions();
-  await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...httpOptions });
+  await bootstrapIfNeeded({ force: forceBootstrap });
   try {
-    await startRuntimeApp(httpOptions);
+    await startRuntimeApp();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (message.includes("No auth found")) {
@@ -260,8 +126,8 @@ async function runForeground() {
         throw error;
       }
       console.log("Reopening bootstrap so you can provide a Pi API key or switch to a provider you already authenticated with.\n");
-      await bootstrapIfNeeded({ force: true, cliConfigOverrides: bootstrapOverrides, ...httpOptions });
-      await startRuntimeApp(httpOptions);
+      await bootstrapIfNeeded({ force: true });
+      await startRuntimeApp();
       return;
     }
     throw error;
@@ -276,9 +142,7 @@ async function main() {
   }
 
   if (command === "start") {
-    const httpOptions = await getHttpOptions();
-    await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...httpOptions });
-    await stopHttpServer();
+    await bootstrapIfNeeded({ force: forceBootstrap });
     const result = await startService({ verbose, cliArgs: toServiceRunnerArgs(cli.nestedFlags) });
     if (!result.ok) {
       console.log(`Arisa is already running in background (pid ${result.pid}).`);

package/src/runtime/arisa-capabilities.js

@@ -0,0 +1,123 @@
+import {
+  getChatArtifactsDir,
+  getChatToolStateDir,
+  getChatToolTmpDir,
+  getToolStateDir,
+  getToolTmpDir
+} from "./paths.js";
+
+function requireToolName(toolName) {
+  if (typeof toolName !== "string" || !toolName.trim()) {
+    throw new Error("toolName is required");
+  }
+  return toolName.trim();
+}
+
+function requireChatId(chatId, method) {
+  if (chatId == null || chatId === "") {
+    throw new Error(`${method} requires chatId`);
+  }
+  return chatId;
+}
+
+function requireString(value, fieldName) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${fieldName} is required`);
+  }
+  return value;
+}
+
+function normalizeLimit(limit) {
+  const value = Number(limit);
+  if (!Number.isInteger(value) || value <= 0) return 20;
+  return Math.min(value, 100);
+}
+
+export function createArisaCapabilities({ artifactStore, taskStore } = {}) {
+  async function dispatch({ method, toolName, chatId = null, params = {} } = {}) {
+    const scopedToolName = requireToolName(toolName);
+
+    if (method === "artifacts.createText") {
+      const scopedChatId = requireChatId(chatId, method);
+      return artifactStore.forChat(scopedChatId).createText({
+        text: requireString(params.text, "text"),
+        mimeType: params.mimeType || "text/plain",
+        source: { type: "tool", toolName: scopedToolName, chatId: scopedChatId },
+        metadata: params.metadata || {}
+      });
+    }
+
+    if (method === "artifacts.listRecent") {
+      const scopedChatId = requireChatId(chatId, method);
+      return artifactStore.forChat(scopedChatId).listRecent(normalizeLimit(params.limit));
+    }
+
+    if (method === "artifacts.get") {
+      const scopedChatId = requireChatId(chatId, method);
+      return artifactStore.forChat(scopedChatId).get(requireString(params.artifactId, "artifactId"));
+    }
+
+    if (method === "tasks.add") {
+      const scopedChatId = requireChatId(chatId, method);
+      return taskStore.add(params.task || {}, {
+        payload: { chatId: scopedChatId },
+        source: { type: "tool", toolName: scopedToolName, chatId: scopedChatId }
+      });
+    }
+
+    if (method === "tasks.list") {
+      const scopedChatId = requireChatId(chatId, method);
+      return taskStore.list({
+        chatId: scopedChatId,
+        status: params.status || undefined,
+        kind: params.kind || undefined
+      });
+    }
+
+    if (method === "tasks.cancel") {
+      const scopedChatId = requireChatId(chatId, method);
+      const taskId = requireString(params.taskId, "taskId");
+      const task = await taskStore.get(taskId);
+      if (!task) return null;
+      if (String(task.payload?.chatId) !== String(scopedChatId)) {
+        throw new Error("task does not belong to chatId");
+      }
+      return taskStore.cancel(taskId);
+    }
+
+    if (method === "agent.enqueueEvent") {
+      const scopedChatId = requireChatId(chatId, method);
+      return taskStore.add({
+        kind: "agent_event",
+        payload: { prompt: requireString(params.prompt, "prompt") }
+      }, {
+        payload: { chatId: scopedChatId },
+        source: { type: "tool", toolName: scopedToolName, chatId: scopedChatId }
+      });
+    }
+
+    if (method === "paths.getChatToolStateDir") {
+      return getChatToolStateDir(requireChatId(chatId, method), scopedToolName);
+    }
+
+    if (method === "paths.getToolStateDir") {
+      return getToolStateDir(scopedToolName);
+    }
+
+    if (method === "paths.getChatToolTmpDir") {
+      return getChatToolTmpDir(requireChatId(chatId, method), scopedToolName);
+    }
+
+    if (method === "paths.getToolTmpDir") {
+      return getToolTmpDir(scopedToolName);
+    }
+
+    if (method === "paths.getChatArtifactsDir") {
+      return getChatArtifactsDir(requireChatId(chatId, method));
+    }
+
+    throw new Error(`unknown IPC method: ${method}`);
+  }
+
+  return { dispatch };
+}