arisa 3.1.4 → 3.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "3.1.4",
+  "version": "3.1.6",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

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

@@ -3,10 +3,12 @@ import { unlink } from "node:fs/promises";
 import { createAgentSession, SessionManager, defineTool } from "@mariozechner/pi-coding-agent";
 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 { withTimeout } from "./prompt-timeout.js";
 import { arisaHomeDir, getChatPiSessionsDir } from "../../runtime/paths.js";
 
+const piValidationTimeoutMs = 60_000;
+
 function isLocalBaseUrl(value) {
   if (typeof value !== "string" || !value.trim()) return false;
   try {
@@ -21,6 +23,32 @@ function requiresProviderAuth(model) {
   return !isLocalBaseUrl(model?.baseUrl);
 }
 
+function mimeMatches(pattern, mimeType = "") {
+  if (!pattern || !mimeType) return false;
+  if (pattern === mimeType) return true;
+  if (pattern.endsWith("/*")) return mimeType.startsWith(`${pattern.slice(0, -2)}/`);
+  return false;
+}
+
+function toolSupportsTextInput(tool) {
+  return (tool.input || []).some((input) => mimeMatches(input, "text/plain"));
+}
+
+function toolProducesAudio(tool) {
+  return (tool.output || []).some((output) => mimeMatches(output, "audio/ogg") || mimeMatches(output, "audio/*"));
+}
+
+function looksLikeTextToSpeechTool(tool) {
+  return /tts|text.?to.?speech|speech.?audio|speech/i.test(`${tool.name} ${tool.description || ""}`);
+}
+
+function selectMediaReplyTool(toolRegistry) {
+  const tools = toolRegistry.list()
+    .filter(toolSupportsTextInput)
+    .filter(toolProducesAudio);
+  return tools.find(looksLikeTextToSpeechTool) || tools[0] || null;
+}
+
 export class AgentManager {
   constructor({ config, artifactStore, toolRegistry, taskStore, logger }) {
     this.config = config;
@@ -75,7 +103,10 @@ export class AgentManager {
       model,
       sessionManager: SessionManager.inMemory(),
     });
-    await session.prompt("Reply with exactly: OK");
+    await withTimeout(session.prompt("Reply with exactly: OK"), {
+      timeoutMs: piValidationTimeoutMs,
+      label: "Pi validation prompt"
+    });
   }
 
   async getSessionContext(chatId, telegram) {
@@ -117,11 +148,8 @@ export class AgentManager {
     });
 
     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`);
+      this.logger?.log("agent", `created new session for chat ${sessionKey}`);
+      this.logger?.log("agent", `runtime context for chat ${sessionKey}:\n${buildAgentRuntimeContext()}`);
     }
 
     const ctx = { session, modelId: effectiveModelId };
@@ -323,7 +351,20 @@ export class AgentManager {
         }),
         execute: async (_id, params) => {
           await this.toolRegistry.load();
-          const toolName = params.toolName || "openai-tts";
+          const selectedTool = params.toolName
+            ? this.toolRegistry.get(params.toolName)
+            : selectMediaReplyTool(this.toolRegistry);
+          if (!selectedTool) {
+            const result = {
+              ok: false,
+              status: "failed",
+              error: params.toolName
+                ? `Tool not found: ${params.toolName}`
+                : "No registered text-to-speech tool can generate an audio reply."
+            };
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: result };
+          }
+          const toolName = selectedTool.name;
           this.logger?.log("agent", `send_media_reply via ${toolName}`);
           const result = await this.toolRegistry.run({
             name: toolName,

package/src/core/agent/prompt-timeout.js

@@ -0,0 +1,22 @@
+export class PromptTimeoutError extends Error {
+  constructor(label, timeoutMs) {
+    super(`${label} timed out after ${timeoutMs}ms`);
+    this.name = "PromptTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+export async function withTimeout(promise, { timeoutMs, label }) {
+  let timer = null;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new PromptTimeoutError(label, timeoutMs));
+    }, timeoutMs);
+  });
+
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/core/tools/daemon-processes.js

@@ -0,0 +1,134 @@
+import { spawn } from "node:child_process";
+import { closeSync, openSync } from "node:fs";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getToolStateDir, toolStateDir } from "../../runtime/paths.js";
+
+export const OWNER_HEARTBEAT_INTERVAL_MS = 2000;
+export const OWNER_HEARTBEAT_TTL_MS = 10000;
+
+export function daemonPaths(toolName) {
+  const root = getToolStateDir(toolName);
+  return {
+    root,
+    commandsDir: path.join(root, "commands"),
+    pidFile: path.join(root, "daemon.pid"),
+    metaFile: path.join(root, "daemon.meta.json"),
+    statusFile: path.join(root, "status.json"),
+    logFile: path.join(root, "daemon.log")
+  };
+}
+
+export async function readJson(file, fallback = {}) {
+  try {
+    return JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+export async function writeJson(file, value) {
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForExit(pid, timeoutMs) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (!isProcessAlive(pid)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return !isProcessAlive(pid);
+}
+
+export async function stopManagedDaemon(toolName, { signal = "SIGTERM", forceAfterMs = 3000 } = {}) {
+  const paths = daemonPaths(toolName);
+  const { pid } = await readJson(paths.pidFile, {});
+  if (isProcessAlive(pid)) {
+    try {
+      process.kill(pid, signal);
+    } catch {}
+    if (signal !== "SIGKILL" && forceAfterMs > 0 && !(await waitForExit(pid, forceAfterMs))) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {}
+    }
+  }
+  await rm(paths.pidFile, { force: true });
+}
+
+export async function startManagedDaemon({ toolName, entryPath, beforeStart = null, ownerEnv = {} }) {
+  const paths = daemonPaths(toolName);
+  await mkdir(paths.commandsDir, { recursive: true });
+
+  const current = await readJson(paths.pidFile, {});
+  if (isProcessAlive(current.pid)) {
+    const sameOwner = !ownerEnv.ARISA_TOOL_OWNER_TOKEN
+      || current.ownerToken === ownerEnv.ARISA_TOOL_OWNER_TOKEN;
+    if (sameOwner) return current.pid;
+    await stopManagedDaemon(toolName);
+  }
+
+  await rm(paths.commandsDir, { recursive: true, force: true });
+  await mkdir(paths.commandsDir, { recursive: true });
+  if (beforeStart) await beforeStart();
+
+  const out = openSync(paths.logFile, "a");
+  try {
+    const child = spawn(process.execPath, [entryPath, "daemon"], {
+      detached: false,
+      stdio: ["ignore", out, out],
+      env: { ...process.env, ...ownerEnv }
+    });
+    child.unref();
+
+    const startedAt = new Date().toISOString();
+    const record = {
+      pid: child.pid,
+      startedAt,
+      ownerPid: Number.parseInt(ownerEnv.ARISA_OWNER_PID || "", 10) || null,
+      ownerToken: ownerEnv.ARISA_TOOL_OWNER_TOKEN || ""
+    };
+    await writeJson(paths.pidFile, record);
+    await writeJson(paths.metaFile, {
+      toolName,
+      entryPath,
+      autoStart: true,
+      lastStartedAt: startedAt,
+      ownerFile: ownerEnv.ARISA_TOOL_OWNER_FILE || "",
+      ownerPid: record.ownerPid,
+      ownerToken: record.ownerToken
+    });
+    return child.pid;
+  } finally {
+    closeSync(out);
+  }
+}
+
+export async function listRegisteredDaemons() {
+  let entries = [];
+  try {
+    entries = await readdir(toolStateDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const paths = daemonPaths(entry.name);
+    const meta = await readJson(paths.metaFile, null);
+    if (meta?.toolName && meta?.entryPath) records.push(meta);
+  }
+  return records;
+}

package/src/core/tools/daemon-runtime.js

@@ -1,34 +1,16 @@
 import crypto from "node:crypto";
-import { spawn } from "node:child_process";
-import { openSync } from "node:fs";
-import { mkdir, readFile, readdir, rename, rm, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readdir, rename, unlink } from "node:fs/promises";
 import path from "node:path";
-import { getToolStateDir } from "../../runtime/paths.js";
-
-export function daemonPaths(toolName) {
-  const root = getToolStateDir(toolName);
-  return {
-    root,
-    commandsDir: path.join(root, "commands"),
-    pidFile: path.join(root, "daemon.pid"),
-    statusFile: path.join(root, "status.json"),
-    logFile: path.join(root, "daemon.log")
-  };
-}
-
-export async function readJson(file, fallback = {}) {
-  try { return JSON.parse(await readFile(file, "utf8")); } catch { return fallback; }
-}
-
-export async function writeJson(file, value) {
-  await mkdir(path.dirname(file), { recursive: true });
-  await writeFile(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-
-export function isProcessAlive(pid) {
-  if (!pid) return false;
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
+import {
+  OWNER_HEARTBEAT_INTERVAL_MS,
+  OWNER_HEARTBEAT_TTL_MS,
+  daemonPaths,
+  isProcessAlive,
+  readJson,
+  startManagedDaemon,
+  stopManagedDaemon,
+  writeJson
+} from "./daemon-processes.js";
 
 export function createDaemonRuntime({ toolName, entryPath, beforeStart = null }) {
   const paths = daemonPaths(toolName);
@@ -54,33 +36,54 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
     await writeJson(paths.statusFile, { ...current, ...patch, updatedAt: new Date().toISOString() });
   }
 
-  async function clearJobs() {
-    await rm(paths.commandsDir, { recursive: true, force: true });
-    await mkdir(paths.commandsDir, { recursive: true });
-  }
-
   async function start() {
-    await ensure();
-    const pid = await getPid();
-    if (isProcessAlive(pid)) return pid;
-
-    await clearJobs();
-    if (beforeStart) await beforeStart();
-    const out = openSync(paths.logFile, "a");
-    const child = spawn(process.execPath, [entryPath, "daemon"], {
-      detached: true,
-      stdio: ["ignore", out, out],
-      env: process.env
+    return startManagedDaemon({
+      toolName,
+      entryPath,
+      beforeStart,
+      ownerEnv: {
+        ARISA_OWNER_PID: process.env.ARISA_OWNER_PID,
+        ARISA_TOOL_OWNER_FILE: process.env.ARISA_TOOL_OWNER_FILE,
+        ARISA_TOOL_OWNER_TOKEN: process.env.ARISA_TOOL_OWNER_TOKEN
+      }
     });
-    child.unref();
-    await writeJson(paths.pidFile, { pid: child.pid, startedAt: new Date().toISOString() });
-    return child.pid;
   }
 
   async function stop() {
-    const pid = await getPid();
-    if (isProcessAlive(pid)) process.kill(pid, "SIGTERM");
-    await rm(paths.pidFile, { force: true });
+    await stopManagedDaemon(toolName);
+  }
+
+  function installOwnerWatch() {
+    const ownerFile = process.env.ARISA_TOOL_OWNER_FILE;
+    const ownerToken = process.env.ARISA_TOOL_OWNER_TOKEN;
+    if (!ownerFile || !ownerToken) return;
+
+    let exiting = false;
+    async function exitIfOrphaned(message) {
+      if (exiting) return;
+      exiting = true;
+      await writeStatus({ state: "stopped", message });
+      process.exit(0);
+    }
+
+    const timer = setInterval(async () => {
+      const owner = await readJson(ownerFile, null);
+      if (!owner || owner.token !== ownerToken) {
+        await exitIfOrphaned("Arisa owner stopped");
+        return;
+      }
+
+      const heartbeatAt = Date.parse(owner.heartbeatAt || "");
+      if (!Number.isFinite(heartbeatAt) || Date.now() - heartbeatAt > OWNER_HEARTBEAT_TTL_MS) {
+        await exitIfOrphaned("Arisa owner heartbeat expired");
+        return;
+      }
+
+      if (!isProcessAlive(owner.pid)) {
+        await exitIfOrphaned("Arisa owner process exited");
+      }
+    }, OWNER_HEARTBEAT_INTERVAL_MS);
+    timer.unref();
   }
 
   async function waitReady({ timeoutMs = 120000, readyStates = ["ready"] } = {}) {
@@ -140,6 +143,7 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
   }
 
   async function workLoop({ processJob, idleTimeoutMs = 0, intervalMs = 250 }) {
+    installOwnerWatch();
     let lastActivity = Date.now();
     setInterval(async () => {
       try {

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

@@ -25,8 +25,9 @@ function runProcess(command, args, options = {}) {
 }
 
 export class ToolRegistry {
-  constructor({ logger } = {}) {
+  constructor({ logger, processOwnerEnv = {} } = {}) {
     this.logger = logger;
+    this.processOwnerEnv = processOwnerEnv;
     this.tools = new Map();
     this.skillRegistry = new SkillRegistry();
   }
@@ -153,7 +154,7 @@ export class ToolRegistry {
     await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");
     const result = await runProcess("node", [tool.entry, "run", "--request-file", requestFile], {
       cwd: tool.dir,
-      env: process.env
+      env: { ...process.env, ...this.processOwnerEnv }
     });
     await unlink(requestFile).catch(() => {});
     await rmdir(tmpDir).catch(() => {});

package/src/index.js

@@ -4,7 +4,7 @@ import { createServer } from "node:http";
 import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
 import { createApp } from "./runtime/create-app.js";
 import { createLogger } from "./runtime/logger.js";
-import { getServiceStatus, registerServiceProcess, startService, stopService } from "./runtime/service-manager.js";
+import { getServiceStatus, registerServiceProcess, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
 import { flushArisaHome } from "./runtime/flush.js";
 import { installPiPackage, removePiPackage } from "./runtime/pi-package-manager.js";
 
@@ -17,6 +17,8 @@ const serviceRunner = Boolean(cli.flags["service-runner"]);
 const bootstrapOverrides = toBootstrapOverrides(cli.nestedFlags);
 const runtimeOverrides = toRuntimeOverrides(cli.nestedFlags);
 const logger = createLogger({ verbose });
+let activeApp = null;
+let shuttingDown = false;
 
 const httpPort = Number(process.env.PORT);
 let httpRequestHandler = null;
@@ -97,6 +99,35 @@ const bootstrapHttpOptions = httpPort ? { httpPort, setHttpRequestHandler } : {}
 const webhookUrl = bootstrapOverrides.webhook?.url || "";
 const appHttpOptions = httpPort ? { webhookUrl, setHttpRequestHandler } : {};
 
+async function shutdown(exitCode = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  try {
+    await activeApp?.stop?.();
+  } catch (error) {
+    logger.error("app", `shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
+    exitCode = exitCode || 1;
+  }
+  if (serviceRunner) {
+    await unregisterServiceProcess();
+  }
+  process.exit(exitCode);
+}
+
+process.once("SIGTERM", () => {
+  shutdown(0);
+});
+
+process.once("SIGINT", () => {
+  shutdown(0);
+});
+
+async function startRuntimeApp() {
+  const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
+  activeApp = app;
+  await app.start();
+}
+
 async function runForeground() {
   const hasRuntimePiOverrides = Boolean(
     runtimeOverrides?.pi?.model
@@ -106,11 +137,12 @@ async function runForeground() {
   logger.log("app", `starting${verbose ? " in verbose mode" : ""}`);
   await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...bootstrapHttpOptions });
   try {
-    const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
-    await app.start();
+    await startRuntimeApp();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (message.includes("No auth found")) {
+      await activeApp?.stop?.();
+      activeApp = null;
       console.log(`\n${message}\n`);
       if (hasRuntimePiOverrides) {
         console.log("Skipping automatic bootstrap because Pi runtime overrides were provided.");
@@ -119,8 +151,7 @@ async function runForeground() {
       }
       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, ...bootstrapHttpOptions });
-      const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
-      await app.start();
+      await startRuntimeApp();
       return;
     }
     throw error;
@@ -202,4 +233,9 @@ async function main() {
   await runForeground();
 }
 
-await main();
+try {
+  await main();
+} catch (error) {
+  logger.error("app", error instanceof Error ? error.message : String(error));
+  await shutdown(1);
+}

package/src/runtime/create-app.js

@@ -4,6 +4,7 @@ import { ToolRegistry } from "../core/tools/tool-registry.js";
 import { TaskStore } from "../core/tasks/task-store.js";
 import { AgentManager } from "../core/agent/agent-manager.js";
 import { createTelegramBot } from "../transport/telegram/bot.js";
+import { createToolProcessSupervisor } from "./tool-process-supervisor.js";
 
 function normalizeString(value) {
   const text = String(value ?? "").trim();
@@ -51,7 +52,8 @@ export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpR
   }
 
   const artifactStore = new ArtifactStore();
-  const toolRegistry = new ToolRegistry({ logger });
+  const toolProcessSupervisor = createToolProcessSupervisor({ logger });
+  const toolRegistry = new ToolRegistry({ logger, processOwnerEnv: toolProcessSupervisor.env() });
   const taskStore = new TaskStore();
   await toolRegistry.load();
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);
@@ -63,8 +65,19 @@ export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpR
     async start() {
       logger?.log("app", `validating Pi model ${config.pi.provider}/${config.pi.model}`);
       await agentManager.validatePiAgent();
+      await toolProcessSupervisor.start();
       logger?.log("app", "starting Telegram bot");
-      await bot.start();
+      try {
+        await bot.start();
+      } catch (error) {
+        await toolProcessSupervisor.stop();
+        throw error;
+      }
+    },
+
+    async stop() {
+      await bot.stop?.();
+      await toolProcessSupervisor.stop();
     }
   };
 }

package/src/runtime/paths.js

@@ -7,6 +7,7 @@ export const stateDir = path.join(arisaHomeDir, "state");
 export const configFile = path.join(stateDir, "config.json");
 export const servicePidFile = path.join(stateDir, "arisa.pid");
 export const serviceLogFile = path.join(stateDir, "arisa.log");
+export const toolDaemonOwnerFile = path.join(stateDir, "tool-daemon-owner.json");
 export const tasksFile = path.join(stateDir, "tasks.json");
 export const toolsDir = path.join(arisaHomeDir, "tools");
 export const chatsDir = path.join(arisaHomeDir, "chats");

package/src/runtime/service-manager.js

@@ -74,24 +74,14 @@ export async function stopService() {
   return { ok: true, pid: status.pid };
 }
 
+export async function unregisterServiceProcess() {
+  await rm(servicePidFile, { force: true }).catch(() => {});
+}
+
 export async function registerServiceProcess() {
   await ensureArisaHome();
   await writeFile(servicePidFile, `${process.pid}\n`, "utf8");
 
-  const cleanup = async () => {
-    await rm(servicePidFile, { force: true }).catch(() => {});
-  };
-
-  process.on("SIGTERM", async () => {
-    await cleanup();
-    process.exit(0);
-  });
-
-  process.on("SIGINT", async () => {
-    await cleanup();
-    process.exit(0);
-  });
-
   process.on("exit", () => {
     rm(servicePidFile, { force: true }).catch(() => {});
   });

package/src/runtime/tool-process-supervisor.js

@@ -0,0 +1,110 @@
+import crypto from "node:crypto";
+import { access, rm } from "node:fs/promises";
+import {
+  daemonPaths,
+  listRegisteredDaemons,
+  readJson,
+  startManagedDaemon,
+  stopManagedDaemon,
+  writeJson
+} from "../core/tools/daemon-processes.js";
+import { ensureArisaHome, toolDaemonOwnerFile } from "./paths.js";
+
+async function fileExists(file) {
+  try {
+    await access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function createToolProcessSupervisor({ logger } = {}) {
+  const token = crypto.randomUUID();
+  let heartbeatTimer = null;
+  let running = false;
+
+  const ownerEnv = {
+    ARISA_OWNER_PID: String(process.pid),
+    ARISA_TOOL_OWNER_FILE: toolDaemonOwnerFile,
+    ARISA_TOOL_OWNER_TOKEN: token
+  };
+
+  async function writeHeartbeat() {
+    await writeJson(toolDaemonOwnerFile, {
+      pid: process.pid,
+      token,
+      heartbeatAt: new Date().toISOString()
+    });
+  }
+
+  async function startHeartbeat() {
+    await ensureArisaHome();
+    await writeHeartbeat();
+    heartbeatTimer = setInterval(() => {
+      writeHeartbeat().catch((error) => {
+        logger?.error("tools", `tool daemon heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    }, 2000);
+    heartbeatTimer.unref();
+  }
+
+  async function restartRegisteredDaemons() {
+    for (const record of await listRegisteredDaemons()) {
+      if (!record.autoStart) continue;
+      if (!(await fileExists(record.entryPath))) {
+        logger?.log("tools", `skipping daemon ${record.toolName}: missing entry ${record.entryPath}`);
+        continue;
+      }
+
+      const paths = daemonPaths(record.toolName);
+      const { pid } = await readJson(paths.pidFile, {});
+      if (pid) {
+        await stopManagedDaemon(record.toolName);
+      }
+
+      logger?.log("tools", `starting managed daemon ${record.toolName}`);
+      await startManagedDaemon({
+        toolName: record.toolName,
+        entryPath: record.entryPath,
+        ownerEnv
+      });
+    }
+  }
+
+  async function stopRegisteredDaemons() {
+    for (const record of await listRegisteredDaemons()) {
+      logger?.log("tools", `stopping managed daemon ${record.toolName}`);
+      await stopManagedDaemon(record.toolName);
+    }
+  }
+
+  async function removeOwnerFile() {
+    const current = await readJson(toolDaemonOwnerFile, null);
+    if (current?.token === token) {
+      await rm(toolDaemonOwnerFile, { force: true });
+    }
+  }
+
+  return {
+    env() {
+      return ownerEnv;
+    },
+
+    async start() {
+      if (running) return;
+      running = true;
+      await startHeartbeat();
+      await restartRegisteredDaemons();
+    },
+
+    async stop() {
+      if (!running) return;
+      running = false;
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+      await stopRegisteredDaemons();
+      await removeOwnerFile();
+    }
+  };
+}

package/src/transport/telegram/bot.js

@@ -3,8 +3,11 @@ import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact } from "./media.js";
 import { renderTelegramHtml } from "./text-format.js";
+import { withTimeout } from "../../core/agent/prompt-timeout.js";
 import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
 
+const promptTimeoutMs = 300_000;
+
 function quotedMessageSummary(message) {
   if (!message) return [];
 
@@ -154,15 +157,52 @@ async function normalizeIncomingArtifact({ artifact, toolRegistry, chatArtifactS
   return { transcript: normalizedArtifact, toolResult };
 }
 
-async function collectText(session, prompt) {
+function sessionEventLogMessage(event) {
+  if (event.type === "tool_execution_start") {
+    return `tool ${event.toolName} started`;
+  }
+  if (event.type === "tool_execution_end") {
+    return `tool ${event.toolName} ${event.isError ? "failed" : "finished"}`;
+  }
+  if (event.type === "auto_retry_start") {
+    return `auto retry ${event.attempt}/${event.maxAttempts} in ${event.delayMs}ms: ${event.errorMessage}`;
+  }
+  if (event.type === "auto_retry_end") {
+    return event.success
+      ? `auto retry succeeded after ${event.attempt} attempt(s)`
+      : `auto retry failed after ${event.attempt} attempt(s): ${event.finalError || "unknown error"}`;
+  }
+  if (event.type === "compaction_start") {
+    return `compaction started (${event.reason})`;
+  }
+  if (event.type === "compaction_end") {
+    return `compaction ${event.aborted ? "aborted" : "finished"} (${event.reason})`;
+  }
+  if (event.type === "message_end" && event.message?.stopReason === "error") {
+    return `assistant message ended with error: ${event.message.errorMessage || "unknown error"}`;
+  }
+  return "";
+}
+
+async function collectText(session, prompt, { logger, chatId } = {}) {
   let text = "";
   const unsubscribe = session.subscribe((event) => {
     if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
       text += event.assistantMessageEvent.delta;
     }
+    const logMessage = sessionEventLogMessage(event);
+    if (logMessage) logger?.log("agent", `chat ${chatId} ${logMessage}`);
   });
-  await session.prompt(prompt);
-  unsubscribe();
+
+  try {
+    await withTimeout(session.prompt(prompt), {
+      timeoutMs: promptTimeoutMs,
+      label: `Telegram prompt for chat ${chatId}`
+    });
+  } finally {
+    unsubscribe();
+  }
+
   return text.trim();
 }
 
@@ -182,6 +222,7 @@ async function withTyping(ctx, work) {
 export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger, webhookUrl, setHttpRequestHandler }) {
   const bot = new Bot(config.telegram.token);
   const perChatState = new Map();
+  let taskTimer = null;
 
   function getIncomingChatMeta(ctx) {
     return {
@@ -252,7 +293,13 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   async function processPromptForChat({ chatId, prompt, ctx = null }) {
     const work = async () => {
       const { session } = await agentManager.getSessionContext(chatId, createTelegramSessionBridge(chatId));
-      const text = await collectText(session, prompt);
+      let text = "";
+      try {
+        text = await collectText(session, prompt, { logger, chatId });
+      } catch (error) {
+        agentManager.resetSession(chatId);
+        throw error;
+      }
       if (text) {
         await sendTextReply({
           sendText: (message, extra) => bot.api.sendMessage(chatId, message, extra),
@@ -283,12 +330,19 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     let currentPrompt = prompt;
     let currentCtx = ctx;
 
-    while (currentPrompt) {
-      try {
-        logger?.log("telegram", `prompt dispatch for chat ${chatId}`);
-        await processPromptForChat({ chatId, prompt: currentPrompt, ctx: currentCtx });
-      } finally {
-        currentCtx = null;
+    try {
+      while (currentPrompt) {
+        try {
+          logger?.log("telegram", `prompt dispatch for chat ${chatId}`);
+          await processPromptForChat({ chatId, prompt: currentPrompt, ctx: currentCtx });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          logger?.error("telegram", `${label} failed for chat ${chatId}: ${message}`);
+          throw error;
+        } finally {
+          currentCtx = null;
+        }
+
         if (chatState.nextPrompt) {
           currentPrompt = chatState.nextPrompt;
           chatState.nextPrompt = "";
@@ -296,9 +350,9 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
           currentPrompt = "";
         }
       }
+    } finally {
+      chatState.processing = false;
     }
-
-    chatState.processing = false;
   }
 
   async function enqueueOrProcess(ctx) {
@@ -460,11 +514,14 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       await bot.api.setMyCommands([
         { command: "new", description: "Start a new chat context" }
       ]);
-      setInterval(() => {
-        dispatchDueTasks().catch((error) => {
-          logger?.error("tasks", `dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
-        });
-      }, 1000).unref();
+      if (!taskTimer) {
+        taskTimer = setInterval(() => {
+          dispatchDueTasks().catch((error) => {
+            logger?.error("tasks", `dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+          });
+        }, 1000);
+        taskTimer.unref();
+      }
       if (webhookUrl && setHttpRequestHandler) {
         const webhookPath = `/telegram-${config.telegram.token.slice(-8)}`;
         const handleUpdate = webhookCallback(bot, "http", {
@@ -485,6 +542,14 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         logger?.log("telegram", "bot polling started");
         await bot.start({ drop_pending_updates: true });
       }
+    },
+
+    async stop() {
+      if (taskTimer) clearInterval(taskTimer);
+      taskTimer = null;
+      try {
+        bot.stop();
+      } catch {}
     }
   };
 }

package/tools/openai-tts/index.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import defaults from "./config.js";
 import { loadToolConfig } from "../../src/core/tools/tool-config.js";
 import { toolError, toolNeedsConfig, toolOk } from "../../src/core/tools/tool-result.js";
-import { getToolConfigPath, getToolOutDir } from "../../src/runtime/paths.js";
+import { getChatToolTmpDir, getToolConfigPath, getToolTmpDir } from "../../src/runtime/paths.js";
 
 const toolName = "openai-tts";
 const config = await loadToolConfig(toolName, defaults);
@@ -49,7 +49,9 @@ async function run(requestFile) {
     return;
   }
 
-  const outDir = getToolOutDir(toolName);
+  const outDir = request.chatId != null
+    ? getChatToolTmpDir(request.chatId, toolName)
+    : getToolTmpDir(toolName);
   await mkdir(outDir, { recursive: true });
   const filePath = path.join(outDir, `speech-${Date.now()}.ogg`);
   const buffer = Buffer.from(await response.arrayBuffer());

package/src/core/agent/project-instructions.js

@@ -1,11 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-
-const instructionsPath = fileURLToPath(new URL("../../../AGENTS.md", import.meta.url));
-let cachedInstructions = null;
-
-export async function loadProjectInstructions() {
-  if (cachedInstructions !== null) return cachedInstructions;
-  cachedInstructions = await readFile(instructionsPath, "utf8");
-  return cachedInstructions;
-}