arisa 5.1.13 → 5.1.49

package/AGENTS.md

@@ -47,6 +47,7 @@ Each tool declares in `tool.manifest.json`:
 - `category`: optional broad capability bucket for discovery
 - `keywords`: optional intent tags for capability discovery
 - `skillHints`: optional skills to apply when using or editing the tool
+- `toolDependencies`: optional required Arisa tools mapped to exact or caret semantic versions; use this only for hard runtime dependencies
 
 ## Text encoding
 All textual content generated or sent by Arisa or its tools must use UTF-8.
@@ -78,6 +79,8 @@ const result = await arisa.tools.run({
 
 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: tools (`list`, `help`, `skills`, `setConfig`, `setResourceNote`, `getResourceNote`, `run`), artifacts (`createText`, `listRecent`, `get`, `deliver`), tasks (`add`, `list`, `cancel`, `cancelAll`), agent events (`enqueueEvent`), and runtime paths (`getChatToolStateDir`, `getToolStateDir`, `getChatToolTmpDir`, `getToolTmpDir`, `getChatArtifactsDir`). Do not expose raw `agentManager`, `taskStore`, `artifactStore`, or `toolRegistry` access.
 
+`agent.enqueueEvent` may include an optional `acknowledgement` of at most 500 characters. Telegram delivers it before the event enters agent reasoning, so explicit authorization receipts cannot be delayed behind follow-up work. Keep it deterministic, concise, and free of credentials; the event prompt must not repeat it.
+
 ## Tool resource notes
 A tool resource may have one deterministic chat-scoped operational note of at most 200 characters, keyed by the exact pair `toolName:resourceId`. Notes live in the chat state file returned by `getChatToolResourceNotesFile(chatId)`. They are separate from semantic memory and contain no credentials.
 
@@ -130,6 +133,7 @@ When such a tool is built, implement it with the shared daemon runtime instead o
 - expose normal CLI behavior through `run --request-file`; callers should not manage daemon internals
 - use the runtime for `daemon.pid`, `daemon.log`, `status.json`, and `commands/*.request|processing|result.json`
 - keep one daemon owner per tool/session and avoid opening a second client over the same resource
+- daemons that receive unsolicited external traffic (webhooks, bridge imports, persistent sockets, or active watchers) must use `daemon.autoStart: true` and disable idle shutdown while ingress is expected; idle shutdown is only for capabilities that can be restarted by the request initiating their next use
 - 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

package/README.md

@@ -76,6 +76,8 @@ Each tool folder contains:
 
 `tool.manifest.json` may also include optional `skillHints`; Arisa resolves installed skills and passes them into `run_tool` requests as `skills` guidance, not runtime dependencies.
 
+A tool that requires another Arisa tool declares a versioned `toolDependencies` map, for example `{ "mcp-client": "^0.1.0" }`. Official installation resolves these dependencies first, rejects missing or cyclic lock entries, and validates installed versions. The registry blocks execution when a required tool is missing or incompatible, and `/doctor` reports the issue.
+
 Each tool is isolated from the root project and from other tools.
 That isolation is part of the architecture:
 

package/package.json

@@ -1,17 +1,12 @@
 {
   "name": "arisa",
-  "version": "5.1.13",
+  "version": "5.1.49",
   "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",
@@ -44,11 +39,14 @@
     "url": "https://github.com/clasen/Arisa/issues"
   },
   "homepage": "https://arisa.sh",
-  "packageManager": "pnpm@11.3.0+sha512.2c403d6594527287672b1f7056343a1f7c3634036a67ffabfcc2b3d7595d843768f8787148d1b57cf7956c90606bbd192857c363af19e96d2d0ec9ec5741d215",
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.80.6",
     "@sinclair/typebox": "^0.34.41",
-    "grammy": "^1.42.0",
-    "typebox": "1.1.38"
+    "grammy": "^1.42.0"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "bootstrap": "node src/index.js --bootstrap",
+    "test": "node --test"
   }
-}
+}

package/src/core/agent/agent-manager.js

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { readFile, stat, unlink } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
 import { createAgentSession, DefaultResourceLoader, SessionManager, SettingsManager, defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { createPiRuntime, hasProviderAuth } from "./pi-runtime.js";
@@ -10,9 +11,10 @@ import { buildPiToolPolicy, getCoreCodingTools } from "./core-tools.js";
 import { createSystemShellTool } from "./system-shell-tool.js";
 import { clampModelThinkingLevel } from "./pi-runtime.js";
 import { clampModelSpeed, createModelSpeedController } from "./model-speed.js";
-import { arisaHomeDir, getChatPiSessionsDir } from "../../runtime/paths.js";
+import { arisaHomeDir, getChatPiSessionsDir, sessionStartOperationalNotesFile } from "../../runtime/paths.js";
 import { searchOfficialToolCatalog } from "../tools/official-tool-catalog.js";
 import { ToolResourceNoteStore } from "../tools/tool-resource-note-store.js";
+import { materializeToolOutput } from "../tools/tool-output-materializer.js";
 
 const piValidationTimeoutMs = 60_000;
 const arisaToolNames = [
@@ -25,33 +27,38 @@ const arisaToolNames = [
   "list_scheduled_tasks",
   "cancel_scheduled_task",
   "cancel_all_scheduled_tasks",
+  "create_telegram_topic",
+  "initialize_telegram_topic",
   "send_artifact"
 ];
 
-function messageText(content) {
-  if (typeof content === "string") return content.trim();
-  if (!Array.isArray(content)) return "";
-  return content
-    .filter((item) => item?.type === "text" && typeof item.text === "string")
-    .map((item) => item.text.trim())
-    .filter(Boolean)
-    .join("\n");
+const operationalNoteMaxChars = 220;
+
+function normalizeOperationalNote(note) {
+  const text = typeof note === "string" ? note : note?.text;
+  const trimmed = String(text || "").replace(/\s+/g, " ").trim();
+  if (!trimmed) return "";
+  return trimmed.length <= operationalNoteMaxChars ? trimmed : `${trimmed.slice(0, operationalNoteMaxChars - 1).trim()}…`;
+}
+
+export function loadSessionStartOperationalNotes() {
+  try {
+    const raw = readFileSync(sessionStartOperationalNotesFile, "utf8");
+    const parsed = JSON.parse(raw);
+    const notes = Array.isArray(parsed) ? parsed : parsed?.notes;
+    if (!Array.isArray(notes)) return [];
+    return notes.map(normalizeOperationalNote).filter(Boolean).slice(0, 20);
+  } catch {
+    return [];
+  }
 }
 
-export function formatPortableSessionHistory(messages = []) {
-  return messages
-    .map((message) => {
-      const text = messageText(message?.content);
-      if (!text) return "";
-      const role = message.role === "assistant"
-        ? "Assistant"
-        : message.role === "user"
-          ? "User"
-          : (message.customType ? `Session memory (${message.customType})` : "Session context");
-      return `${role}:\n${text}`;
-    })
-    .filter(Boolean)
-    .join("\n\n");
+function formatSessionStartOperationalNotes(notes) {
+  if (!notes.length) return "";
+  return [
+    "Durable operating notes for this Arisa session:",
+    ...notes.map((note) => `- ${note}`)
+  ].join("\n");
 }
 
 const estimatedImageTokens = 1_200;
@@ -102,6 +109,16 @@ function summarizeRetainedContext(messages = []) {
   };
 }
 
+function guardTools(tools, accessGuard) {
+  return tools.map((tool) => ({
+    ...tool,
+    execute: async (...args) => {
+      await accessGuard();
+      return tool.execute(...args);
+    }
+  }));
+}
+
 function closeAgentSession(session) {
   if (session?.close) return session.close();
   if (session?.dispose) return session.dispose();
@@ -301,7 +318,7 @@ export class AgentManager {
     this.closeCachedSession(String(chatId));
   }
 
-  async getRuntimeDiagnostic({ contextInspectionTimeoutMs } = {}) {
+  async getRuntimeDiagnostic() {
     const contexts = await Promise.all([...this.sessions.entries()].map(async ([chatId, context]) => {
       const base = { chatId };
       try {
@@ -322,7 +339,6 @@ export class AgentManager {
       harness: "pi",
       sessions: this.sessions.size,
       closingSessions: this.sessionClosePromises.size,
-      managedProcessIds: [],
       contexts
     };
   }
@@ -338,6 +354,15 @@ export class AgentManager {
         sessionDir,
         handoff?.parentSession ? { parentSession: handoff.parentSession } : undefined
       );
+      const operationalNotes = formatSessionStartOperationalNotes(loadSessionStartOperationalNotes());
+      if (operationalNotes) {
+        sessionManager.appendCustomMessageEntry(
+          "arisa-operational-notes",
+          operationalNotes,
+          false,
+          { source: "session-start" }
+        );
+      }
       if (handoff?.text) {
         sessionManager.appendCustomMessageEntry(
           "arisa-session-handoff",
@@ -388,7 +413,7 @@ export class AgentManager {
     return this.validatePiAgent(config);
   }
 
-  async getSessionContext(chatId, telegram) {
+  async getSessionContext(chatId, telegram, { scopeChatId = chatId, accessGuard = async () => {} } = {}) {
     const sessionKey = String(chatId);
     const modelSelection = resolveChatModelSelection(this.config, sessionKey);
     const effectiveModelId = modelSelection.model;
@@ -406,6 +431,8 @@ export class AgentManager {
           this.logger?.log("agent", `updating speed for chat ${sessionKey}: ${existing.speedController.speed}x -> ${desiredSpeed}x`);
           existing.speedController.setSpeed(desiredSpeed);
         }
+        existing.telegramTarget.current = telegram;
+        existing.accessGuardTarget.current = accessGuard;
         this.logger?.log("agent", `reusing session for chat ${sessionKey}`);
         return existing;
       }
@@ -438,10 +465,26 @@ export class AgentManager {
     );
     const hasExistingSession = sessionManager.buildSessionContext().messages.length > 0;
     this.logger?.log("agent", `${hasExistingSession ? "resuming" : "creating"} session for chat ${sessionKey} with model ${effectiveModelId} effort ${thinkingLevel} speed ${speed}x`);
-    const customTools = [
-      ...this.createTools(telegram, chatId, policy),
-      createSystemShellTool({ workspaceDir: policy.workspaceDir, shell: policy.shell })
-    ];
+    const telegramTarget = { current: telegram };
+    const accessGuardTarget = { current: accessGuard };
+    const telegramProxy = {
+      sendMedia: (...args) => telegramTarget.current.sendMedia(...args),
+      createForumTopic: (...args) => telegramTarget.current.createForumTopic(...args),
+      initializeForumTopic: (...args) => telegramTarget.current.initializeForumTopic(...args),
+      prepareRestartReceipt: (...args) => telegramTarget.current.prepareRestartReceipt(...args),
+      cancelRestartReceipt: (...args) => telegramTarget.current.cancelRestartReceipt(...args),
+      getTaskContext: (...args) => telegramTarget.current.getTaskContext?.(...args) || null
+    };
+    const assertAccess = () => accessGuardTarget.current();
+    const customTools = guardTools([
+      ...this.createTools(telegramProxy, scopeChatId, policy),
+      createSystemShellTool({
+        workspaceDir: policy.workspaceDir,
+        shell: policy.shell,
+        beforeRestart: (summary) => telegramProxy.prepareRestartReceipt(summary),
+        cancelRestart: (receiptId) => telegramProxy.cancelRestartReceipt(receiptId)
+      })
+    ], assertAccess);
     const settingsManager = createPiSettingsManager(this.config);
     const resourceLoader = await createArisaResourceLoader({
       cwd: policy.workspaceDir,
@@ -473,7 +516,14 @@ export class AgentManager {
       })}`);
     }
 
-    const ctx = { session, modelId: effectiveModelId, modelKey: effectiveModelKey, speedController };
+    const ctx = {
+      session,
+      modelId: effectiveModelId,
+      modelKey: effectiveModelKey,
+      speedController,
+      telegramTarget,
+      accessGuardTarget
+    };
     this.sessions.set(sessionKey, ctx);
     if (isNewSession) {
       this.pendingNewSessions.delete(sessionKey);
@@ -505,10 +555,9 @@ export class AgentManager {
     ]);
   }
 
-  async runTool({ name, request, chatId }) {
+  async runTool({ name, request, chatId, taskContext = null }) {
     await this.toolRegistry.load();
     this.logger?.log("agent", `run_tool ${name}`);
-    const chatArtifactStore = this.artifactStore.forChat(chatId);
     const resourceId = String(request?.resourceId || "").trim();
     const resourceNote = resourceId
       ? await this.resourceNotes.get(chatId, name, resourceId)
@@ -516,41 +565,14 @@ export class AgentManager {
     const enrichedRequest = resourceNote ? { ...request, resourceId, resourceNote } : request;
     const result = await this.toolRegistry.run({ name, request: enrichedRequest, chatId });
 
-    if (result.output?.text) {
-      const outArtifact = await chatArtifactStore.createText({
-        text: result.output.text,
-        source: { type: "tool", toolName: name },
-        metadata: { tool: name }
-      });
-      result.output.artifactId = outArtifact.id;
-    }
-
-    if (result.output?.filePath) {
-      const generated = await chatArtifactStore.createFromFile({
-        originalPath: result.output.filePath,
-        fileName: result.output.fileName || path.basename(result.output.filePath),
-        kind: result.output.kind || "file",
-        mimeType: result.output.mimeType || "application/octet-stream",
-        source: { type: "tool", toolName: name },
-        metadata: { tool: name, delivery: result.output.delivery }
-      });
-      result.output.artifactId = generated.id;
-      await unlink(result.output.filePath).catch(() => {});
-    }
-
-    if (result.asyncTask || result.asyncTasks?.length) {
-      const scheduled = await this.taskStore.addMany(
-        result.asyncTasks || [result.asyncTask],
-        {
-          payload: { chatId },
-          source: { type: "tool", toolName: name, chatId }
-        }
-      );
-      result.asyncTasks = scheduled;
-      delete result.asyncTask;
-    }
-
-    return result;
+    return materializeToolOutput({
+      result,
+      name,
+      chatId,
+      artifactStore: this.artifactStore,
+      taskStore: this.taskStore,
+      taskContext
+    });
   }
 
   createTools(telegram, chatId, policy = buildPiToolPolicy({ config: this.config, customToolNames: arisaToolNames })) {
@@ -688,7 +710,8 @@ export class AgentManager {
               resourceId: params.resourceId,
               args: params.args || {}
             },
-            chatId
+            chatId,
+            taskContext: telegram.getTaskContext()
           });
 
           if (params.deliver && result.output?.artifactId) {
@@ -757,6 +780,45 @@ export class AgentManager {
           };
         }
       }),
+      defineTool({
+        name: "create_telegram_topic",
+        label: "Create Telegram topic",
+        description: "Create and initialize a new topic in the current owner-only Telegram forum. Topic names are dynamic, and context seeds the isolated session without copying unrelated history.",
+        parameters: Type.Object({
+          name: Type.String({ minLength: 1, maxLength: 128 }),
+          context: Type.String({ minLength: 1, maxLength: 4000 })
+        }),
+        execute: async (_id, params) => {
+          if (typeof telegram.createForumTopic !== "function") {
+            const result = { ok: false, error: "Telegram topic creation is unavailable in this chat." };
+            return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+          }
+          const result = await telegram.createForumTopic(params.name.trim(), params.context.trim());
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: result };
+        }
+      }),
+      defineTool({
+        name: "initialize_telegram_topic",
+        label: "Initialize Telegram topic",
+        description: "Seed or replace the isolated context of an existing topic in the current owner-only Telegram forum.",
+        parameters: Type.Object({
+          messageThreadId: Type.Integer({ minimum: 2 }),
+          name: Type.String({ minLength: 1, maxLength: 128 }),
+          context: Type.String({ minLength: 1, maxLength: 4000 })
+        }),
+        execute: async (_id, params) => {
+          if (typeof telegram.initializeForumTopic !== "function") {
+            const result = { ok: false, error: "Telegram topic initialization is unavailable in this chat." };
+            return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+          }
+          const result = await telegram.initializeForumTopic({
+            messageThreadId: params.messageThreadId,
+            name: params.name.trim(),
+            context: params.context.trim()
+          });
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: result };
+        }
+      }),
       defineTool({
         name: "send_artifact",
         label: "Send artifact",

package/src/core/agent/pi-runtime.js

@@ -101,11 +101,3 @@ export function clampModelThinkingLevel(model, level) {
 export function modelSupportsThinking(model) {
   return listModelThinkingLevels(model).some((level) => level !== "off");
 }
-
-export function findPiModel({ provider, model, apiKey } = {}) {
-  const runtime = createPiRuntime({ provider, apiKey });
-  return {
-    ...runtime,
-    model: provider && model ? runtime.modelRegistry.find(provider, model) : null
-  };
-}

package/src/core/agent/system-shell-tool.js

@@ -164,25 +164,36 @@ async function runShellCommand({ command, cwd, shellPath, timeoutMs }) {
   });
 }
 
-export function createSystemShellTool({ workspaceDir, shell = {} }) {
+export function isArisaRestartCommand(command) {
+  return /(?:^|[;&|]\s*)arisa\s+restart(?:\s*(?:$|[;&|]))/i.test(String(command || ""));
+}
+
+export function createSystemShellTool({ workspaceDir, shell = {}, beforeRestart, cancelRestart }) {
   return defineTool({
     name: "system_shell",
     label: "System Shell",
     description: "Run a command in the active Arisa workspace using the native system shell: PowerShell on Windows, and sh/bash-compatible shell on Unix.",
     parameters: Type.Object({
       command: Type.String({ description: "Command to execute in the active workspace." }),
-      timeoutMs: Type.Optional(Type.Number({ description: "Optional timeout in milliseconds for this command." }))
+      timeoutMs: Type.Optional(Type.Number({ description: "Optional timeout in milliseconds for this command." })),
+      restartSummary: Type.Optional(Type.String({ maxLength: 500, description: "Concrete user-facing result to report after an arisa restart succeeds." }))
     }),
     execute: async (_id, params) => {
       const timeoutMs = Number.isFinite(Number(params.timeoutMs)) && Number(params.timeoutMs) > 0
         ? Math.floor(Number(params.timeoutMs))
         : (shell.timeoutMs || defaultTimeoutMs);
+      const restartReceipt = isArisaRestartCommand(params.command) && typeof beforeRestart === "function"
+        ? await beforeRestart(params.restartSummary)
+        : null;
       const result = await runShellCommand({
         command: params.command,
         cwd: workspaceDir,
         shellPath: shell.shellPath,
         timeoutMs
       });
+      if (!result.ok && restartReceipt?.id && typeof cancelRestart === "function") {
+        await cancelRestart(restartReceipt.id).catch(() => {});
+      }
       const details = {
         stdout: result.stdout,
         stderr: result.stderr,

package/src/core/artifacts/artifact-store.js

@@ -86,14 +86,14 @@ class ChatArtifactStore {
     return artifact;
   }
 
-  async createFromFile({ originalPath, fileName, kind, mimeType, source, metadata = {} }) {
+  async createFileArtifact({ fileName, kind, mimeType, source, metadata = {}, writeFileContent }) {
     await this.init();
     await this.reload();
     const artifactId = id();
     const dir = path.join(this.rootDir, artifactId);
     await mkdir(dir, { recursive: true });
     const destPath = path.join(dir, fileName);
-    await copyArtifactFile(originalPath, destPath, mimeType);
+    await writeFileContent(destPath);
     const artifact = {
       id: artifactId,
       chatId: this.chatId,
@@ -109,27 +109,26 @@ class ChatArtifactStore {
     return artifact;
   }
 
+  async createFromFile({ originalPath, fileName, kind, mimeType, source, metadata = {} }) {
+    return this.createFileArtifact({
+      fileName,
+      kind,
+      mimeType,
+      source,
+      metadata,
+      writeFileContent: (destPath) => copyArtifactFile(originalPath, destPath, mimeType)
+    });
+  }
+
   async createGeneratedFile({ fileName, content, kind, mimeType, source, metadata = {} }) {
-    await this.init();
-    await this.reload();
-    const artifactId = id();
-    const dir = path.join(this.rootDir, artifactId);
-    await mkdir(dir, { recursive: true });
-    const destPath = path.join(dir, fileName);
-    await writeArtifactFile(destPath, content);
-    const artifact = {
-      id: artifactId,
-      chatId: this.chatId,
+    return this.createFileArtifact({
+      fileName,
       kind,
       mimeType,
-      path: destPath,
       source,
       metadata,
-      createdAt: new Date().toISOString()
-    };
-    this.items.push(artifact);
-    await this.saveIndex();
-    return artifact;
+      writeFileContent: (destPath) => writeArtifactFile(destPath, content)
+    });
   }
 
   async get(artifactId) {

package/src/core/config/config-defaults.js

@@ -18,11 +18,11 @@ export const daemonConfigDefaults = Object.freeze({
 
 export const telegramConfigDefaults = Object.freeze({
   modelPickerPageSize: 8,
-  busyMessageMode: "steer"
+  busyMessageMode: "steer",
+  ownerWorkspaceGroups: Object.freeze({})
 });
 
 export const doctorConfigDefaults = Object.freeze({
-  contextInspectionTimeoutMs: 5_000,
   contextWarningPercent: 70,
   contextCriticalPercent: 90,
   contextInefficientMinTokens: 32_000,

package/src/core/conversation/session-seed-store.js

@@ -0,0 +1,85 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import {
+  getChatLegacyConversationHistoryFile,
+  getChatSessionSeedFile
+} from "../../runtime/paths.js";
+
+function parseRecords(contents) {
+  return String(contents || "")
+    .replace(/^\uFEFF/, "")
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+}
+
+function seedText(record) {
+  return String(record?.context || record?.history || "").trim();
+}
+
+export class SessionSeedStore {
+  constructor({
+    seedFile = getChatSessionSeedFile,
+    legacyFile = getChatLegacyConversationHistoryFile
+  } = {}) {
+    this.seedFile = seedFile;
+    this.legacyFile = legacyFile;
+    this.locks = new Map();
+  }
+
+  async withChatLock(chatId, work) {
+    const key = String(chatId);
+    const previous = this.locks.get(key) || Promise.resolve();
+    const current = previous.catch(() => {}).then(work);
+    this.locks.set(key, current);
+    try {
+      return await current;
+    } finally {
+      if (this.locks.get(key) === current) this.locks.delete(key);
+    }
+  }
+
+  async write(chatId, record = null) {
+    const file = this.seedFile(chatId);
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const body = record ? `${JSON.stringify(record)}\n` : "";
+    await writeFile(file, body, { encoding: "utf8", mode: 0o600 });
+  }
+
+  async set(chatId, context) {
+    const normalized = String(context || "").trim();
+    return this.withChatLock(chatId, async () => {
+      await this.write(chatId, normalized ? { kind: "seed", context: normalized } : null);
+      return Boolean(normalized);
+    });
+  }
+
+  async clear(chatId) {
+    return this.withChatLock(chatId, () => this.write(chatId));
+  }
+
+  async readPendingRecords(chatId) {
+    try {
+      return parseRecords(await readFile(this.seedFile(chatId), "utf8"));
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+    try {
+      return parseRecords(await readFile(this.legacyFile(chatId), "utf8"));
+    } catch (error) {
+      if (error?.code === "ENOENT") return [];
+      throw error;
+    }
+  }
+
+  async consume(chatId) {
+    return this.withChatLock(chatId, async () => {
+      const records = await this.readPendingRecords(chatId);
+      const pendingSeed = records.length === 1 && records[0]?.kind === "seed"
+        ? seedText(records[0])
+        : "";
+      await this.write(chatId);
+      return pendingSeed;
+    });
+  }
+}

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

@@ -56,7 +56,6 @@ function requestIpc({ socketPath, request, timeoutMs = DEFAULT_TIMEOUT_MS }) {
 export function createArisaClient({
   toolName,
   chatId = null,
-  capabilityToken = process.env.ARISA_IPC_TOKEN || "",
   socketPath = process.env.ARISA_IPC_SOCKET || arisaIpcSocketFile
 } = {}) {
   if (typeof toolName !== "string" || !toolName.trim()) {
@@ -71,7 +70,6 @@ export function createArisaClient({
       method,
       toolName,
       chatId,
-      capabilityToken,
       params
     }
   });