arisa 3.0.14 → 3.1.4

package/AGENTS.md

@@ -3,10 +3,21 @@
 ## Architecture
 - Telegram transport handles inbound and outbound messaging.
 - Pi Agent keeps one session per authorized chat.
-- Every incoming or generated message or file becomes an artifact.
+- Incoming messages and files (text, voice, photo, document) and generated files become artifacts.
 - A tool registry handles tool discovery, help lookup, config writes, and execution.
 - Tools are isolated and each one has its own manifest, entrypoint, and config defaults.
 
+## Runtime directory rules
+Do not build runtime paths by hand. Use `src/runtime/paths.js`:
+- `getToolDir(toolName)`: installed user tool package only; no runtime data here.
+- `getToolStateDir(toolName)`: global tool infrastructure only: daemons, queues, shared browser sessions, model caches.
+- `getChatToolStateDir(chatId, toolName)`: persistent user/chat data: tool DBs, indexes, inboxes, generated sites, vaults.
+- `getChatArtifactsDir(chatId)` / `getChatArtifactsIndexFile(chatId)`: chat artifacts and artifact index. Artifacts are never global.
+- `getChatToolConfigPath(chatId, toolName)`: chat-scoped config overrides.
+- `getToolTmpDir(toolName)` / `getChatToolTmpDir(chatId, toolName)`: ephemeral scratch. Create only while a request runs; remove when empty.
+
+Tools receive `chatId` from the registry. Any persisted or indexed user content must be scoped by chat. Avoid ad hoc roots like `~/.arisa/state/<toolName>`, `~/.arisa/state/chats`, or runtime data inside `~/.arisa/tools/<toolName>`.
+
 ## Main rule: everything is piped through artifacts
 A pipe transforms one input artifact into one output artifact.
 Examples:
@@ -18,6 +29,7 @@ Each tool declares in `tool.manifest.json`:
 - `input`: supported input types
 - `output`: produced output types
 - `configSchema`: required config fields
+- `skillHints`: optional skills to apply when using or editing the tool
 
 ## Conceptual pipe model
 There are two different moments where pipes can happen:
@@ -34,12 +46,11 @@ There are two different moments where pipes can happen:
    - Pi Agent may decide to chain tools to achieve a user goal.
    - Example: text -> TTS audio, or future multi-step workflows.
 
-This distinction is critical. Not every pipe should be decided by Pi Agent at runtime. Some pipes are part of the transport/input normalization layer and must happen before reasoning.
+Not every pipe should be decided by Pi Agent at runtime. Some pipes are part of the transport/input normalization layer and must happen before reasoning.
 
 ## Telegram inbound pipeline
-Current conceptual behavior:
 - text -> send directly to Pi Agent
-- audio/voice -> transcribe first -> send transcript to Pi Agent
+- voice -> transcribe first -> send transcript to Pi Agent
 - image/document/other media -> keep as artifacts, and add normalization pipes when needed
 
 If inbound media was normalized before reasoning, Pi Agent should use the normalized result as the actual message content.
@@ -50,12 +61,23 @@ Before using a tool, inspect its help:
 - via the custom tool: `tool_help`
 - or by running the CLI with `--help`
 
-Every CLI must support:
+Every CLI must support (the entrypoint comes from `manifest.entry`, currently always `index.js`):
 - `node index.js --help`
 - `node index.js run --request-file <json>`
 
-## Pipe behavior in V1
-V1 does not have a full automatic planner yet. The agent should:
+### Tools that need daemons
+A future 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, but no bundled tool uses it yet.
+When such a tool is built, implement it with the shared daemon runtime instead of custom ad hoc process management:
+- use `src/core/tools/daemon-runtime.js`
+- keep runtime files under the tool state directory (`~/.arisa/state/tools/<toolName>`)
+- 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
+- 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
+
+## Manual pipe behavior
+To run a pipe, the agent should:
 1. understand whether the needed pipe belongs to pre-reasoning normalization or post-reasoning tool chaining
 2. use `list_tools`
 3. use `tool_help` when it needs operational details
@@ -65,7 +87,28 @@ V1 does not have a full automatic planner yet. The agent should:
 Example manual pipe:
 1. `run_tool(openai-transcribe, artifact audio)`
 2. take the returned text `artifactId`
-3. `run_tool(openai-tts, artifact text)` or `send_audio_reply(text)`
+3. `run_tool(openai-tts, artifact text)` or `send_media_reply(text)`
+
+## Async event queue flow
+Beyond time-based scheduling, tools can drive an event queue that wakes the agent only when there is something to evaluate. Everything goes through the `asyncTask` (single) or `asyncTasks` (array) field the pipeline already supports; no new Pi tools are needed. The 1s poller drains tasks by `kind`:
+
+- `agent_task`: a scheduled prompt. The poller delivers it as a prompt for Pi to fulfill (time-based work).
+- `poll_tool`: a recurring checker the poller **runs directly as a tool** (no agent turn spent). The poller materializes its output with the same logic as `run_tool`, so any `agent_event` the checker emits is enqueued for the next tick. Its `recurrence` reschedules the next poll.
+- `agent_event`: an incoming event. The poller delivers it as a prompt so Pi evaluates it and decides the next action (it may stay silent).
+
+Tasks without a `runAt` fire immediately, so `agent_event` and the first `poll_tool` run on the next tick.
+
+The poller dispatches all three kinds, but only `agent_task` is exercised by a bundled tool today (`schedule-agent-task`). The following is the pattern to follow when a checker tool is built:
+
+How a tool wires its own polling:
+1. From any tool `run`, start the poll by returning an `asyncTask` (or several in `asyncTasks`):
+   `{ kind: "poll_tool", payload: { toolName, args }, recurrence: { type: "interval", everySeconds: N } }`.
+2. On each poll the checker tool (`toolName`) runs headless. It keeps its own cursor of seen state in its config/tmp per chat, so it knows what is new.
+3. When the checker finds something new, it emits an event from its `run`:
+   `{ kind: "agent_event", payload: { prompt: "<content to evaluate>" } }`.
+4. The agent reasons over the `agent_event` and decides what to do.
+
+`list_scheduled_tasks`, `cancel_scheduled_task`, and `cancel_all_scheduled_tasks` are kind-agnostic, so they already work to inspect or cancel active polls.
 
 ## Missing config flow
 If `run_tool` returns `missingConfig`, the agent should:
@@ -90,13 +133,26 @@ The default attitude is:
 - propose or start creating the needed tool
 
 When creating or editing tools:
-- use the shared path helpers and the runtime paths provided in the prompt instead of assuming fixed locations
-- consult the local skill for that workflow when building new tools
+- use the path helpers in `src/runtime/paths.js`
+- follow the existing bundled tools under `tools/` as the reference pattern for new tools
 - keep all help text, usage instructions, manifests, and user-facing operational strings in English
 - follow the One Thing Rule: each function or method should do one thing well; if it mixes low-level operations with high-level policy, split it into smaller focused units
 
+### Tool skill hints
+Tools may declare skills in `tool.manifest.json`:
+
+```json
+{
+  "skillHints": [
+    { "name": "stop-slop", "when": "writing public page copy" }
+  ]
+}
+```
+
+The tool registry resolves these from the installed skills directory and injects them into the tool request as `skills`. `list_tools` exposes the hints and `tool_help` shows their resolution status. Skills are guidance for the agent/tool; they are not separate runtime dependencies.
+
 ## Dependency installation
-Arisa installs tool dependencies itself.
+Tool dependencies are installed as part of building or running the tool, not delegated to the user.
 - Prefer `pnpm install`.
 - Fall back to `npm install`.
 - Do not ask the user to do it manually.

package/README.md

@@ -101,6 +101,16 @@ arisa install <source>   # install a Pi package into Arisa's runtime
 arisa remove <source>    # remove a Pi package from Arisa's runtime
 ```
 
+Runtime model override (current process only):
+
+```bash
+arisa --pi.model lmstudio/google/gemma-4-26b-a4b
+```
+
+Notes:
+
+- it only affects the current Arisa process and does not update `~/.arisa/state/config.json`
+
 ## Experimental features
 
 ### Pi Agent packages
@@ -124,6 +134,33 @@ 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
+- when `--pi.apiKey` is omitted and the provider supports OAuth, Arisa starts a temporary web page on `PORT` (default `10000`) where you can complete authentication from any browser
+- unknown `--pi.provider` or `--pi.model` values are ignored and replaced by safe defaults
+
 Telegram bot tokens can be created with:
 
 - https://t.me/BotFather
@@ -134,7 +171,7 @@ For providers with internal Pi login support, such as Codex, leaving the API key
 
 For example, selecting:
 
-- `openai-codex/gpt-5.4`
+- `openai-codex/gpt-5.5`
 
 allows Arisa to authenticate through Pi's Codex OAuth flow instead of requiring a normal OpenAI API key.
 

package/package.json

@@ -1,16 +1,12 @@
 {
   "name": "arisa",
-  "version": "3.0.14",
+  "version": "3.1.4",
   "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"
-  },
   "keywords": [
     "telegram",
     "pi-agent",
@@ -32,10 +28,13 @@
   ],
   "author": "Martin Clasen",
   "license": "MIT",
-  "packageManager": "pnpm@10.32.1",
   "dependencies": {
-    "@mariozechner/pi-coding-agent": "^0.65.0",
+    "@mariozechner/pi-coding-agent": "^0.73.1",
     "@sinclair/typebox": "^0.34.41",
     "grammy": "^1.42.0"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "bootstrap": "node src/index.js --bootstrap"
   }
-}
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,12 @@
+overrides:
+  '@protobufjs/utf8@<=1.1.0': '>=1.1.1'
+  basic-ftp@<=5.2.1: '>=5.2.2'
+  basic-ftp@<=5.2.2: '>=5.3.0'
+  basic-ftp@<=5.3.0: '>=5.3.1'
+  basic-ftp@=5.2.0: '>=5.2.1'
+  brace-expansion@>=5.0.0 <5.0.6: '>=5.0.6'
+  ip-address@<=10.1.0: '>=10.1.1'
+  protobufjs@<7.5.5: '>=7.5.5'
+  protobufjs@<=7.5.5: '>=7.5.6'
+  protobufjs@<=7.5.7: '>=7.5.8'
+  ws@>=8.0.0 <8.20.1: '>=8.20.1'

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

@@ -5,7 +5,21 @@ import { Type } from "@sinclair/typebox";
 import { createPiRuntime, hasProviderAuth } from "./pi-runtime.js";
 import { loadProjectInstructions } from "./project-instructions.js";
 import { arisaInstallDir, buildAgentRuntimeContext } from "./runtime-context.js";
-import { arisaHomeDir } from "../../runtime/paths.js";
+import { arisaHomeDir, getChatPiSessionsDir } from "../../runtime/paths.js";
+
+function isLocalBaseUrl(value) {
+  if (typeof value !== "string" || !value.trim()) return false;
+  try {
+    const parsed = new URL(value);
+    return parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost";
+  } catch {
+    return false;
+  }
+}
+
+function requiresProviderAuth(model) {
+  return !isLocalBaseUrl(model?.baseUrl);
+}
 
 export class AgentManager {
   constructor({ config, artifactStore, toolRegistry, taskStore, logger }) {
@@ -15,15 +29,30 @@ export class AgentManager {
     this.taskStore = taskStore;
     this.logger = logger;
     this.sessions = new Map();
+    this.pendingNewSessions = new Set();
   }
 
   setConfig(config) {
     this.config = config;
     this.sessions.clear();
+    this.pendingNewSessions.clear();
   }
 
   resetSession(chatId) {
-    this.sessions.delete(chatId);
+    const sessionKey = String(chatId);
+    this.sessions.delete(sessionKey);
+    this.pendingNewSessions.add(sessionKey);
+  }
+
+  createSessionManager(chatId) {
+    const sessionKey = String(chatId);
+    const sessionDir = getChatPiSessionsDir(sessionKey);
+    if (this.pendingNewSessions.has(sessionKey)) {
+      this.logger?.log("agent", `starting new persisted session for chat ${sessionKey}`);
+      return { sessionManager: SessionManager.create(arisaInstallDir, sessionDir), isNewSession: true };
+    }
+    this.logger?.log("agent", `recovering persisted session for chat ${sessionKey}`);
+    return { sessionManager: SessionManager.continueRecent(arisaInstallDir, sessionDir), isNewSession: false };
   }
 
   async validatePiAgent() {
@@ -36,7 +65,7 @@ export class AgentManager {
     if (!model) {
       throw new Error(`Model not found: ${this.config.pi.provider}/${this.config.pi.model}`);
     }
-    if (!this.config.pi.apiKey && !hasProviderAuth(this.config.pi.provider, { authStorage, modelRegistry })) {
+    if (requiresProviderAuth(model) && !this.config.pi.apiKey && !hasProviderAuth(this.config.pi.provider, { authStorage, modelRegistry })) {
       throw new Error(`No auth found for ${this.config.pi.provider}. Provide a Pi API key in bootstrap, or authenticate with Pi login for this provider during bootstrap.`);
     }
 
@@ -50,22 +79,32 @@ export class AgentManager {
   }
 
   async getSessionContext(chatId, telegram) {
-    if (this.sessions.has(chatId)) {
-      this.logger?.log("agent", `reusing session for chat ${chatId}`);
-      return this.sessions.get(chatId);
+    const sessionKey = String(chatId);
+    const effectiveModelId = this.config.pi.model;
+    if (this.sessions.has(sessionKey)) {
+      const existing = this.sessions.get(sessionKey);
+      if (existing?.modelId === effectiveModelId) {
+        this.logger?.log("agent", `reusing session for chat ${sessionKey}`);
+        return existing;
+      }
+      this.logger?.log("agent", `model changed for chat ${sessionKey}: ${existing?.modelId || "unknown"} -> ${effectiveModelId}; recreating session`);
+      this.sessions.delete(sessionKey);
+      this.pendingNewSessions.add(sessionKey);
     }
 
     const { authStorage, modelRegistry } = createPiRuntime({
       provider: this.config.pi.provider,
       apiKey: this.config.pi.apiKey
     });
-    const model = modelRegistry.find(this.config.pi.provider, this.config.pi.model);
-    if (!model) throw new Error(`Model not found: ${this.config.pi.provider}/${this.config.pi.model}`);
-    if (!this.config.pi.apiKey && !hasProviderAuth(this.config.pi.provider, { authStorage, modelRegistry })) {
+    const model = modelRegistry.find(this.config.pi.provider, effectiveModelId);
+    if (!model) throw new Error(`Model not found: ${this.config.pi.provider}/${effectiveModelId}`);
+    if (requiresProviderAuth(model) && !this.config.pi.apiKey && !hasProviderAuth(this.config.pi.provider, { authStorage, modelRegistry })) {
       throw new Error(`No auth found for ${this.config.pi.provider}. Re-run bootstrap and complete login for this provider before Telegram starts.`);
     }
 
-    this.logger?.log("agent", `creating session for chat ${chatId}`);
+    const { sessionManager, isNewSession } = this.createSessionManager(sessionKey);
+    const hasExistingSession = sessionManager.buildSessionContext().messages.length > 0;
+    this.logger?.log("agent", `${hasExistingSession ? "resuming" : "creating"} session for chat ${sessionKey} with model ${effectiveModelId}`);
     const customTools = this.createTools(telegram, chatId);
     const { session } = await createAgentSession({
       cwd: arisaInstallDir,
@@ -74,21 +113,71 @@ export class AgentManager {
       modelRegistry,
       model,
       customTools,
-      sessionManager: SessionManager.inMemory()
+      sessionManager
     });
 
-    const instructions = await loadProjectInstructions();
-    const runtimeContext = buildAgentRuntimeContext();
-    this.logger?.log("agent", `injecting project instructions for chat ${chatId}`);
-    this.logger?.log("agent", `runtime context for chat ${chatId}:\n${runtimeContext}`);
-    await session.prompt(`${instructions}\n\n${runtimeContext}\n\nAcknowledge with exactly: OK`);
+    if (!hasExistingSession) {
+      const instructions = await loadProjectInstructions();
+      const runtimeContext = buildAgentRuntimeContext();
+      this.logger?.log("agent", `injecting project instructions for chat ${sessionKey}`);
+      this.logger?.log("agent", `runtime context for chat ${sessionKey}:\n${runtimeContext}`);
+      await session.prompt(`${instructions}\n\n${runtimeContext}\n\nAcknowledge with exactly: OK`);
+    }
 
-    const ctx = { session };
-    this.sessions.set(chatId, ctx);
+    const ctx = { session, modelId: effectiveModelId };
+    this.sessions.set(sessionKey, ctx);
+    if (isNewSession) {
+      this.pendingNewSessions.delete(sessionKey);
+    }
     return ctx;
   }
 
+  async runTool({ name, request, chatId }) {
+    await this.toolRegistry.load();
+    this.logger?.log("agent", `run_tool ${name}`);
+    const chatArtifactStore = this.artifactStore.forChat(chatId);
+    const result = await this.toolRegistry.run({ name, request, 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 }
+      });
+      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;
+  }
+
   createTools(telegram, chatId) {
+    const chatArtifactStore = this.artifactStore.forChat(chatId);
+
     return [
       defineTool({
         name: "list_tools",
@@ -114,14 +203,26 @@ export class AgentManager {
           return { content: [{ type: "text", text: help }], details: { help } };
         }
       }),
+      defineTool({
+        name: "tool_skills",
+        label: "Tool skills",
+        description: "Show skills assigned to a CLI tool via its manifest skillHints.",
+        parameters: Type.Object({ name: Type.String() }),
+        execute: async (_id, params) => {
+          await this.toolRegistry.load();
+          const skills = await this.toolRegistry.resolveSkills(params.name);
+          const visible = skills.map(({ content, ...item }) => item);
+          return { content: [{ type: "text", text: JSON.stringify(visible, null, 2) }], details: visible };
+        }
+      }),
       defineTool({
         name: "set_tool_config",
         label: "Set tool config",
-        description: "Write a value into ~/.arisa/tools/<tool>/config.js.",
+        description: "Write a tool config value scoped to the current chat.",
         parameters: Type.Object({ name: Type.String(), field: Type.String(), value: Type.String() }),
         execute: async (_id, params) => {
           await this.toolRegistry.load();
-          const result = await this.toolRegistry.setConfig(params.name, params.field, params.value);
+          const result = await this.toolRegistry.setConfig(params.name, params.field, params.value, chatId);
           return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
         }
       }),
@@ -136,58 +237,23 @@ export class AgentManager {
           args: Type.Optional(Type.Record(Type.String(), Type.String()))
         }),
         execute: async (_id, params) => {
-          await this.toolRegistry.load();
-          this.logger?.log("agent", `run_tool ${params.name}`);
           let artifact = null;
           if (params.artifactId) {
-            artifact = await this.artifactStore.get(params.artifactId);
+            artifact = await chatArtifactStore.get(params.artifactId);
             if (!artifact) {
               return { content: [{ type: "text", text: `Artifact not found: ${params.artifactId}` }], details: { ok: false } };
             }
           }
-          const result = await this.toolRegistry.run({
+          const result = await this.runTool({
             name: params.name,
             request: {
               artifact,
               text: params.text,
               args: params.args || {}
-            }
+            },
+            chatId
           });
 
-          if (result.output?.text) {
-            const outArtifact = await this.artifactStore.createText({
-              text: result.output.text,
-              source: { type: "tool", toolName: params.name },
-              metadata: { tool: params.name }
-            });
-            result.output.artifactId = outArtifact.id;
-          }
-
-          if (result.output?.filePath) {
-            const generated = await this.artifactStore.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: params.name },
-              metadata: { tool: params.name }
-            });
-            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: params.name, chatId }
-              }
-            );
-            result.asyncTasks = scheduled;
-            delete result.asyncTask;
-          }
-
           return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
             details: result
@@ -261,7 +327,8 @@ export class AgentManager {
           this.logger?.log("agent", `send_media_reply via ${toolName}`);
           const result = await this.toolRegistry.run({
             name: toolName,
-            request: { text: params.text, args: {} }
+            request: { text: params.text, args: {} },
+            chatId
           });
           if (!result.ok || !result.output?.filePath) {
             return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: result };

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

@@ -1,5 +1,5 @@
 import { fileURLToPath } from "node:url";
-import { arisaHomeDir, artifactsDir, stateDir, toolsDir } from "../../runtime/paths.js";
+import { arisaHomeDir, chatsDir, stateDir, toolStateDir, toolsDir } from "../../runtime/paths.js";
 
 export const arisaInstallDir = fileURLToPath(new URL("../../..", import.meta.url));
 export const bundledToolsDir = fileURLToPath(new URL("../../../tools", import.meta.url));
@@ -10,7 +10,8 @@ export function buildAgentRuntimeContext() {
     `arisaInstallDir: ${arisaInstallDir}`,
     `bundledToolsDir: ${bundledToolsDir}`,
     `userToolsDir: ${toolsDir}`,
-    `artifactsDir: ${artifactsDir}`,
+    `toolStateDir: ${toolStateDir}`,
+    `chatsDir: ${chatsDir}`,
     `stateDir: ${stateDir}`
   ].join("\n");
 }