arisa 4.3.4 → 5.0.2

package/src/core/agent/model-speed.js

@@ -0,0 +1,59 @@
+export const MODEL_SPEEDS = Object.freeze([1, 1.5]);
+
+export function normalizeModelSpeed(speed) {
+  const value = Number(speed);
+  if (!MODEL_SPEEDS.includes(value)) {
+    throw new Error(`Invalid model speed: ${speed}`);
+  }
+  return value;
+}
+
+export function modelSupportsSpeed(model) {
+  return model?.provider === "openai-codex"
+    && model.api === "openai-codex-responses"
+    && typeof model.id === "string"
+    && (
+      model.id === "gpt-5.4"
+      || model.id === "gpt-5.5"
+      || model.id === "gpt-5.6"
+      || model.id.startsWith("gpt-5.6-")
+    );
+}
+
+export function clampModelSpeed(model, speed) {
+  const normalized = normalizeModelSpeed(speed);
+  return normalized === 1.5 && !modelSupportsSpeed(model) ? 1 : normalized;
+}
+
+export function speedToServiceTier(speed) {
+  return normalizeModelSpeed(speed) === 1.5 ? "priority" : "default";
+}
+
+export function createModelSpeedController(streamFn, initialSpeed) {
+  if (typeof streamFn !== "function") throw new Error("Pi stream function is unavailable");
+  let speed = normalizeModelSpeed(initialSpeed);
+  return {
+    get speed() {
+      return speed;
+    },
+    setSpeed(nextSpeed) {
+      speed = normalizeModelSpeed(nextSpeed);
+    },
+    streamFn(model, context, options) {
+      const serviceTier = speedToServiceTier(speed);
+      const onPayload = options?.onPayload;
+      return streamFn(model, context, {
+        ...options,
+        serviceTier,
+        async onPayload(payload, requestModel) {
+          const replacement = await onPayload?.(payload, requestModel);
+          const effectivePayload = replacement === undefined ? payload : replacement;
+          if (!effectivePayload || typeof effectivePayload !== "object" || Array.isArray(effectivePayload)) {
+            throw new Error("Pi provider payload is not an object");
+          }
+          return { ...effectivePayload, service_tier: serviceTier };
+        }
+      });
+    }
+  };
+}

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

@@ -15,23 +15,75 @@ export const daemonConfigDefaults = Object.freeze({
 });
 
 export const telegramConfigDefaults = Object.freeze({
-  modelPickerPageSize: 8
+  modelPickerPageSize: 8,
+  busyMessageMode: "steer"
+});
+
+export const doctorConfigDefaults = Object.freeze({
+  contextInspectionTimeoutMs: 5_000,
+  contextWarningPercent: 70,
+  contextCriticalPercent: 90,
+  contextInefficientMinTokens: 32_000,
+  contextToolResultWarningPercent: 60,
+  contextSingleMessageWarningPercent: 50
+});
+
+export const cliLogConfig = Object.freeze({
+  recentLines: 100,
+  followPollIntervalMs: 250
+});
+
+export const serviceConfigDefaults = Object.freeze({
+  shutdownTimeoutMs: 15_000,
+  shutdownPollIntervalMs: 100
 });
 
 export const piConfigDefaults = Object.freeze({
-  thinkingLevel: "medium"
+  thinkingLevel: "medium",
+  speed: 1,
+  compaction: Object.freeze({
+    enabled: true,
+    reserveTokens: 16_384,
+    keepRecentTokens: 20_000
+  })
 });
 
+function cloneChatModels(chatModels) {
+  if (!chatModels || typeof chatModels !== "object") return chatModels;
+  return Object.fromEntries(Object.entries(chatModels).map(([chatId, selection]) => [
+    chatId,
+    selection && typeof selection === "object" ? { ...selection } : selection
+  ]));
+}
+
 export function applyConfigDefaults(config) {
+  const normalized = { ...config };
+  delete normalized.agent;
+  delete normalized.prime;
+  const configuredPi = normalized.pi || {};
+
   return {
-    ...config,
+    ...normalized,
     telegram: {
       ...telegramConfigDefaults,
       ...(config.telegram || {})
     },
+    doctor: {
+      ...doctorConfigDefaults,
+      ...(config.doctor || {})
+    },
+    service: {
+      ...serviceConfigDefaults,
+      ...(config.service || {})
+    },
     pi: {
       ...piConfigDefaults,
-      ...(config.pi || {})
+      ...configuredPi,
+      compaction: {
+        ...piConfigDefaults.compaction,
+        ...(configuredPi.compaction || {})
+      },
+      chatModels: cloneChatModels(configuredPi.chatModels)
     },
     daemons: {
       ...daemonConfigDefaults,

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

@@ -3,6 +3,10 @@ import path from "node:path";
 import { configFile } from "../../runtime/paths.js";
 import { applyConfigDefaults } from "./config-defaults.js";
 
+export function prepareConfigForSave(config) {
+  return applyConfigDefaults(config);
+}
+
 export async function loadConfig() {
   const raw = await readFile(configFile, "utf8");
   return applyConfigDefaults(JSON.parse(raw));
@@ -10,7 +14,7 @@ export async function loadConfig() {
 
 export async function saveConfig(config) {
   await mkdir(path.dirname(configFile), { recursive: true });
-  await writeFile(configFile, `${JSON.stringify(applyConfigDefaults(config), null, 2)}\n`, "utf8");
+  await writeFile(configFile, `${JSON.stringify(prepareConfigForSave(config), null, 2)}\n`, "utf8");
 }
 
 export async function updateConfig(mutator) {

package/src/core/conversation/conversation-history-store.js

@@ -0,0 +1,142 @@
+import crypto from "node:crypto";
+import { mkdir, open, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getChatConversationHistoryFile } from "../../runtime/paths.js";
+
+const utf8Bom = "\uFEFF";
+
+function normalizeText(value) {
+  return String(value || "").trim();
+}
+
+function parseHistory(contents) {
+  return String(contents || "")
+    .replace(/^\uFEFF/, "")
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+}
+
+function serializeRecord(record) {
+  return `${JSON.stringify(record)}\n`;
+}
+
+export function formatPortableConversation(records) {
+  if (!records.length) return "";
+  const sections = [
+    "Portable Arisa conversation history.",
+    "This portable history belongs to the same Telegram chat and is independent of the active agent harness.",
+    "Use it as prior conversation context. Do not repeat it unless the user asks."
+  ];
+
+  for (const record of records) {
+    if (record.kind === "seed") {
+      sections.push(`Imported earlier conversation:\n${record.history}`);
+      continue;
+    }
+    const parts = [];
+    if (record.prompt) parts.push(`User or system request:\n${record.prompt}`);
+    if (record.response) parts.push(`Assistant response:\n${record.response}`);
+    if (parts.length) sections.push(parts.join("\n\n"));
+  }
+  return sections.join("\n\n---\n\n");
+}
+
+export class ConversationHistoryStore {
+  constructor({ historyFile = getChatConversationHistoryFile } = {}) {
+    this.locks = new Map();
+    this.historyFile = historyFile;
+  }
+
+  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 read(chatId) {
+    try {
+      return parseHistory(await readFile(this.historyFile(chatId), "utf8"));
+    } catch (error) {
+      if (error?.code === "ENOENT") return [];
+      throw error;
+    }
+  }
+
+  async hasEntries(chatId) {
+    return (await this.read(chatId)).length > 0;
+  }
+
+  async appendRecord(chatId, record) {
+    const file = this.historyFile(chatId);
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const handle = await open(file, "a+", 0o600);
+    try {
+      const stats = await handle.stat();
+      if (stats.size === 0) await handle.write(utf8Bom);
+      await handle.write(serializeRecord(record));
+    } finally {
+      await handle.close();
+    }
+  }
+
+  async ensureSeed(chatId, { runtime, history }) {
+    const normalizedHistory = normalizeText(history);
+    if (!normalizedHistory) return false;
+    return this.withChatLock(chatId, async () => {
+      if ((await this.read(chatId)).length) return false;
+      await this.appendRecord(chatId, {
+        id: crypto.randomUUID(),
+        kind: "seed",
+        runtime,
+        history: normalizedHistory,
+        createdAt: new Date().toISOString()
+      });
+      return true;
+    });
+  }
+
+  async appendTurn(chatId, { runtime, prompt, response }) {
+    const normalizedPrompt = normalizeText(prompt);
+    const normalizedResponse = normalizeText(response);
+    if (!normalizedPrompt && !normalizedResponse) return null;
+    const record = {
+      id: crypto.randomUUID(),
+      kind: "turn",
+      runtime,
+      prompt: normalizedPrompt,
+      response: normalizedResponse,
+      createdAt: new Date().toISOString()
+    };
+    await this.withChatLock(chatId, () => this.appendRecord(chatId, record));
+    return record;
+  }
+
+  async reset(chatId, { runtime, history = "" } = {}) {
+    return this.withChatLock(chatId, async () => {
+      const file = this.historyFile(chatId);
+      await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+      const normalizedHistory = normalizeText(history);
+      const seed = normalizedHistory
+        ? serializeRecord({
+            id: crypto.randomUUID(),
+            kind: "seed",
+            runtime,
+            history: normalizedHistory,
+            createdAt: new Date().toISOString()
+          })
+        : "";
+      await writeFile(file, `${utf8Bom}${seed}`, { encoding: "utf8", mode: 0o600 });
+    });
+  }
+
+  async buildHandoff(chatId) {
+    return formatPortableConversation(await this.read(chatId));
+  }
+}

package/src/core/tasks/task-store.js

@@ -99,6 +99,22 @@ export class TaskStore {
     return due;
   }
 
+  async recoverInterrupted() {
+    await this.reload();
+    const recovered = [];
+    const updatedAt = new Date().toISOString();
+
+    for (const task of this.tasks) {
+      if (task.status !== "running") continue;
+      task.status = "pending";
+      task.updatedAt = updatedAt;
+      recovered.push({ ...task });
+    }
+
+    if (recovered.length) await this.save();
+    return recovered;
+  }
+
   async complete(taskId) {
     await this.init();
     const task = this.tasks.find((item) => item.id === taskId);

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

@@ -17,7 +17,8 @@ function errorRecord(phase, error) {
   return {
     at: new Date().toISOString(),
     phase,
-    message: error?.message || String(error)
+    message: error?.message || String(error),
+    ...(error?.code ? { code: error.code } : {})
   };
 }
 
@@ -25,6 +26,13 @@ function isTimeout(error) {
   return ["DAEMON_JOB_TIMEOUT", "DAEMON_OPERATION_TIMEOUT"].includes(error?.code);
 }
 
+function recordedError(status, fallback) {
+  if (!status.lastError?.message) return fallback;
+  const error = new Error(status.lastError.message);
+  if (status.lastError.code) error.code = status.lastError.code;
+  return error;
+}
+
 function healthDue(status, policy, now = Date.now()) {
   const heartbeatAt = new Date(status.heartbeatAt || 0).getTime();
   const healthAt = new Date(status.lastHealthCheckAt || 0).getTime();
@@ -156,6 +164,7 @@ export async function superviseDaemon(record, policy) {
   const alive = isProcessAlive(pid);
 
   if (!alive) {
+    if (status.state === "failed") return "failed";
     if (!record.autoStart && !status.restartRequested && ["stopped", "unhealthy", "failed"].includes(status.state)) {
       return status.state;
     }
@@ -165,7 +174,7 @@ export async function superviseDaemon(record, policy) {
     if (status.state === "restarting") {
       return restartIfDue(record, paths, status, policy);
     }
-    return scheduleRestart(record, paths, status, policy, new Error("Daemon process exited"));
+    return scheduleRestart(record, paths, status, policy, recordedError(status, new Error("Daemon process exited")));
   }
 
   if (!healthDue(status, policy)) return "healthy";

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

@@ -97,6 +97,59 @@ export async function writeDaemonStatus(pathsOrIdentity, patch) {
   return next;
 }
 
+function daemonDisposition({ state, alive, autoStart, restartRequested }) {
+  if (state === "failed") return "requires-attention";
+  if (state === "restarting" || restartRequested) return "automatic-retry";
+  if (["degraded", "unhealthy"].includes(state)) return autoStart ? "automatic-recovery" : "requires-attention";
+  if (state === "stopped") return autoStart ? "automatic-restart" : "leave-stopped";
+  if (state === "ready" && !alive) return autoStart ? "automatic-restart" : "start-on-demand";
+  if (state === "ready") return "available";
+  if (state === "starting") return "starting";
+  return autoStart ? "automatic-start" : "start-on-demand";
+}
+
+function redactDiagnosticText(value) {
+  if (!value) return null;
+  return String(value)
+    .replace(/\b(Bearer)\s+[^\s,;]+/gi, "$1 [redacted]")
+    .replace(/\b(token|secret|password|api[_-]?key)(\s*[=:]\s*)[^\s,;&]+/gi, "$1$2[redacted]")
+    .replace(/([?&](?:token|secret|password|api[_-]?key)=)[^\s&#]+/gi, "$1[redacted]")
+    .replace(/(https?:\/\/[^\s:/]+:)[^\s@/]+@/gi, "$1[redacted]@");
+}
+
+function diagnosticError(lastError) {
+  if (!lastError) return null;
+  return {
+    ...lastError,
+    message: redactDiagnosticText(lastError.message)
+  };
+}
+
+export async function readDaemonDiagnostic({ toolName, scope, autoStart = false }) {
+  const paths = daemonPaths({ toolName, scope });
+  const status = await readJson(paths.statusFile, {});
+  const { pid } = await readJson(paths.pidFile, {});
+  const state = status.state || "not-started";
+  const alive = isProcessAlive(pid);
+  const restartRequested = Boolean(status.restartRequested);
+  const hasActiveError = ["degraded", "unhealthy", "restarting", "failed"].includes(state);
+  return {
+    state,
+    alive,
+    pid: alive ? pid : null,
+    message: redactDiagnosticText(status.message),
+    lastError: hasActiveError ? diagnosticError(status.lastError) : null,
+    restart: {
+      attempts: Number(status.restartAttempts || 0),
+      requested: restartRequested,
+      nextAt: status.nextRestartAt || null
+    },
+    disposition: daemonDisposition({ state, alive, autoStart: Boolean(autoStart), restartRequested }),
+    updatedAt: status.updatedAt || null,
+    logFile: paths.logFile
+  };
+}
+
 function registrationRecord({ paths, entryPath, autoStart, startupContext, current = {}, startedAt = null }) {
   return {
     toolName: paths.toolName,
@@ -168,6 +221,22 @@ async function acquireStartLock(paths, policy) {
   throw new Error(`Timed out acquiring daemon start lock for ${paths.toolName} (${paths.instanceId})`);
 }
 
+export async function unregisterManagedDaemon(toolNameOrOptions, { scope } = {}) {
+  const paths = daemonPaths(toolNameOrOptions, scope);
+  const { pid } = await readJson(paths.pidFile, {});
+  if (isProcessAlive(pid)) {
+    throw new Error(`Refusing to unregister a live daemon: ${paths.toolName} (${paths.instanceId})`);
+  }
+  await Promise.all([
+    rm(paths.metaFile, { force: true }),
+    rm(paths.pidFile, { force: true }),
+    rm(paths.statusFile, { force: true }),
+    rm(paths.startLockFile, { force: true }),
+    rm(paths.commandsDir, { recursive: true, force: true })
+  ]);
+  return { toolName: paths.toolName, scope: paths.scope, instanceId: paths.instanceId };
+}
+
 export async function stopManagedDaemon(toolNameOrOptions, {
   scope,
   signal = "SIGTERM",
@@ -285,9 +354,29 @@ export async function startManagedDaemon({
     } finally {
       closeSync(out);
     }
+    const pidRegistration = writeJson(paths.pidFile, { pid: child.pid, startedAt });
+    child.once("exit", async (exitCode, signal) => {
+      await pidRegistration.catch(() => {});
+      const currentPid = (await readJson(paths.pidFile, {})).pid;
+      const currentStatus = await readJson(paths.statusFile, {});
+      if (currentPid !== child.pid || ["stopped", "failed"].includes(currentStatus.state)) return;
+      const exitReason = signal ? `signal ${signal}` : `exit code ${exitCode}`;
+      await writeDaemonStatus(paths, {
+        state: "degraded",
+        pid: null,
+        heartbeatAt: null,
+        lastError: {
+          at: new Date().toISOString(),
+          phase: "process-exit",
+          message: `Daemon process exited with ${exitReason}`,
+          code: signal || `EXIT_${exitCode}`
+        },
+        message: `Daemon process exited with ${exitReason}`
+      }).catch(() => {});
+    });
     child.unref();
 
-    await writeJson(paths.pidFile, { pid: child.pid, startedAt });
+    await pidRegistration;
     await writeDaemonStatus(paths, {
       state: "starting",
       pid: child.pid,
@@ -301,7 +390,8 @@ export async function startManagedDaemon({
       lastError: {
         at: new Date().toISOString(),
         phase: "start",
-        message: error?.message || String(error)
+        message: error?.message || String(error),
+        ...(error?.code ? { code: error.code } : {})
       },
       message: error?.message || String(error)
     }).catch(() => {});

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

@@ -289,7 +289,8 @@ export function createDaemonRuntime({
               lastError: {
                 at: new Date().toISOString(),
                 phase: operation || "job",
-                message: error?.message || String(error)
+                message: error?.message || String(error),
+                ...(error?.code ? { code: error.code } : {})
               },
               message: error?.message || String(error)
             });
@@ -315,7 +316,8 @@ export function createDaemonRuntime({
           lastError: {
             at: new Date().toISOString(),
             phase: "work-loop",
-            message: error?.message || String(error)
+            message: error?.message || String(error),
+            ...(error?.code ? { code: error.code } : {})
           },
           message: error?.message || String(error)
         });

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

@@ -53,7 +53,12 @@ function requestIpc({ socketPath, request, timeoutMs = DEFAULT_TIMEOUT_MS }) {
   });
 }
 
-export function createArisaClient({ toolName, chatId = null, socketPath = process.env.ARISA_IPC_SOCKET || arisaIpcSocketFile } = {}) {
+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()) {
     throw new Error("toolName is required");
   }
@@ -66,6 +71,7 @@ export function createArisaClient({ toolName, chatId = null, socketPath = proces
       method,
       toolName,
       chatId,
+      capabilityToken,
       params
     }
   });
@@ -74,17 +80,23 @@ export function createArisaClient({ toolName, chatId = null, socketPath = proces
     artifacts: {
       createText: (params) => call("artifacts.createText", params),
       listRecent: (params) => call("artifacts.listRecent", params),
-      get: (params) => call("artifacts.get", params)
+      get: (params) => call("artifacts.get", params),
+      deliver: (params) => call("artifacts.deliver", params, { timeoutMs: 120_000 })
     },
     tasks: {
       add: (params) => call("tasks.add", params),
       list: (params) => call("tasks.list", params),
-      cancel: (params) => call("tasks.cancel", params)
+      cancel: (params) => call("tasks.cancel", params),
+      cancelAll: () => call("tasks.cancelAll")
     },
     agent: {
       enqueueEvent: (params) => call("agent.enqueueEvent", params)
     },
     tools: {
+      list: () => call("tools.list"),
+      help: (params) => call("tools.help", params),
+      skills: (params) => call("tools.skills", params),
+      setConfig: (params) => call("tools.setConfig", params),
       run: (params, options) => call("tools.run", params, options)
     },
     paths: {

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

@@ -4,6 +4,7 @@ import { spawn } from "node:child_process";
 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 { readDaemonDiagnostic } from "./daemon-processes.js";
 import { SkillRegistry } from "../skills/skill-registry.js";
 
 function toolEnv() {
@@ -105,6 +106,32 @@ export class ToolRegistry {
     }));
   }
 
+  async listWithRuntime(chatId = null) {
+    return Promise.all(this.list().map(async (listedTool) => {
+      const daemon = this.get(listedTool.name)?.daemon;
+      if (!daemon) return listedTool;
+      if (daemon.scope === "chat" && (chatId == null || chatId === "")) {
+        throw new Error(`Daemon status for ${listedTool.name} requires chatId`);
+      }
+      const scope = daemon.scope === "chat"
+        ? { type: "chat", chatId }
+        : { type: "global" };
+      return {
+        ...listedTool,
+        daemon: {
+          scope: daemon.scope,
+          autoStart: Boolean(daemon.autoStart),
+          health: daemon.health || null,
+          runtime: await readDaemonDiagnostic({
+            toolName: listedTool.name,
+            scope,
+            autoStart: daemon.autoStart
+          })
+        }
+      };
+    }));
+  }
+
   get(name) {
     return this.tools.get(name) || null;
   }