arisa 5.1.24 → 5.1.60

package/src/core/agent/agent-session-lifecycle.js

@@ -0,0 +1,181 @@
+import { readFileSync } from "node:fs";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { getChatPiSessionsDir, sessionStartOperationalNotesFile } from "../../runtime/paths.js";
+import { arisaInstallDir } from "./runtime-context.js";
+
+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 [];
+  }
+}
+
+function formatSessionStartOperationalNotes(notes) {
+  if (!notes.length) return "";
+  return [
+    "Durable operating notes for this Arisa session:",
+    ...notes.map((note) => `- ${note}`)
+  ].join("\n");
+}
+
+function closeAgentSession(session) {
+  if (session?.close) return session.close();
+  if (session?.dispose) return session.dispose();
+  return undefined;
+}
+
+export class AgentSessionLifecycle {
+  constructor({ logger, summarizeContext }) {
+    this.logger = logger;
+    this.summarizeContext = summarizeContext;
+    this.sessions = new Map();
+    this.pendingNewSessions = new Set();
+    this.pendingSessionHandoffs = new Map();
+    this.sessionClosePromises = new Map();
+  }
+
+  closeCached(sessionKey) {
+    const key = String(sessionKey);
+    const existing = this.sessions.get(key);
+    this.sessions.delete(key);
+    const closeSession = (existing?.session?.close || existing?.session?.dispose)
+      ? () => closeAgentSession(existing.session)
+      : null;
+    if (!closeSession) return this.sessionClosePromises.get(key) || Promise.resolve();
+
+    const previousClose = this.sessionClosePromises.get(key);
+    const closePromise = Promise.resolve(previousClose)
+      .catch(() => {})
+      .then(closeSession)
+      .catch((error) => {
+        this.logger?.error?.("agent", `session close failed for chat ${key}: ${error instanceof Error ? error.message : String(error)}`);
+      })
+      .finally(() => {
+        if (this.sessionClosePromises.get(key) === closePromise) {
+          this.sessionClosePromises.delete(key);
+        }
+      });
+    this.sessionClosePromises.set(key, closePromise);
+    return closePromise;
+  }
+
+  async waitForClose(sessionKey) {
+    const key = String(sessionKey);
+    let closing = this.sessionClosePromises.get(key);
+    while (closing) {
+      await closing;
+      closing = this.sessionClosePromises.get(key);
+    }
+  }
+
+  resetConfigState() {
+    for (const key of this.sessions.keys()) this.closeCached(key);
+    this.pendingNewSessions.clear();
+    this.pendingSessionHandoffs.clear();
+  }
+
+  resetSession(chatId, { handoff = "", parentSession = "" } = {}) {
+    const sessionKey = String(chatId);
+    this.closeCached(sessionKey);
+    this.pendingNewSessions.add(sessionKey);
+    const text = String(handoff || "").trim();
+    const parent = String(parentSession || "").trim();
+    if (text || parent) {
+      this.pendingSessionHandoffs.set(sessionKey, { text, parentSession: parent });
+    } else {
+      this.pendingSessionHandoffs.delete(sessionKey);
+    }
+  }
+
+  createSessionManager(chatId, workspaceDir = arisaInstallDir, sessionRevision = 0) {
+    const sessionKey = String(chatId);
+    const sessionDir = getChatPiSessionsDir(sessionKey, sessionRevision);
+    if (this.pendingNewSessions.has(sessionKey)) {
+      this.logger?.log("agent", `starting new persisted session for chat ${sessionKey}`);
+      const handoff = this.pendingSessionHandoffs.get(sessionKey);
+      const sessionManager = SessionManager.create(
+        workspaceDir,
+        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",
+          handoff.text,
+          false,
+          { source: "telegram-new" }
+        );
+      }
+      return { sessionManager, isNewSession: true };
+    }
+    this.logger?.log("agent", `recovering persisted session for chat ${sessionKey}`);
+    return {
+      sessionManager: SessionManager.continueRecent(workspaceDir, sessionDir),
+      isNewSession: false
+    };
+  }
+
+  completeNewSession(sessionKey) {
+    this.pendingNewSessions.delete(sessionKey);
+    this.pendingSessionHandoffs.delete(sessionKey);
+  }
+
+  async getDiagnostic() {
+    const contexts = await Promise.all([...this.sessions.entries()].map(async ([chatId, context]) => {
+      const base = { chatId };
+      try {
+        const stats = context.session.getSessionStats();
+        const retained = this.summarizeContext(context.session.messages);
+        return {
+          ...base,
+          ...retained,
+          tokens: stats.contextUsage?.tokens ?? null,
+          contextWindow: stats.contextUsage?.contextWindow ?? null,
+          percent: stats.contextUsage?.percent ?? null
+        };
+      } catch (error) {
+        return { ...base, error: error instanceof Error ? error.message : String(error) };
+      }
+    }));
+    return {
+      harness: "pi",
+      sessions: this.sessions.size,
+      closingSessions: this.sessionClosePromises.size,
+      contexts
+    };
+  }
+
+  async closeAll() {
+    const contexts = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.allSettled([
+      ...this.sessionClosePromises.values(),
+      ...contexts.map((context) => closeAgentSession(context.session))
+    ]);
+  }
+}

package/src/core/agent/pi-capability-tools.js

@@ -0,0 +1,183 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { getCoreCodingTools } from "./core-tools.js";
+import { maxScheduledTaskListLimit } from "../capabilities/capability-service.js";
+
+function jsonResult(result, text = JSON.stringify(result, null, 2)) {
+  return { content: [{ type: "text", text }], details: result };
+}
+
+function nativeTools(policy) {
+  return [{
+    name: "system_shell",
+    source: "arisa-native",
+    description: "Run native system shell commands in the active Arisa workspace.",
+    workspaceDir: policy.workspaceDir,
+    shell: policy.shell.shellPath || (process.platform === "win32" ? "powershell" : "sh"),
+    enabled: !(policy.excludeTools || []).includes("system_shell")
+  }];
+}
+
+export function createPiCapabilityTools({ capabilityService, telegram, chatId, policy, logger }) {
+  if (!capabilityService?.execute) throw new Error("Pi capability tools require CapabilityService");
+
+  const baseContext = {
+    telegram,
+    returnMissingArtifact: true,
+    selectScheduledTasks: true,
+    wrapTaskResult: true,
+    allowTargetToolName: true,
+    delivery: async (artifact, options) => {
+      logger?.log("agent", `deliver artifact ${artifact.id} as ${options.method}`);
+      await telegram.sendMedia(artifact.path, options);
+      return {
+        method: options.method,
+        fileName: options.filename,
+        artifactId: artifact.id
+      };
+    }
+  };
+
+  const execute = (actorToolName, method, params = {}, context = {}) => capabilityService.execute({
+    method,
+    actorToolName,
+    chatId,
+    params,
+    context: {
+      ...baseContext,
+      taskContext: telegram.getTaskContext(),
+      ...context
+    }
+  });
+
+  return [
+    defineTool({
+      name: "list_tools",
+      label: "List tools",
+      description: "List Arisa tools, or search installed tool metadata by capability with automatic official-catalog fallback.",
+      parameters: Type.Object({ query: Type.Optional(Type.String()) }),
+      execute: async (_id, params) => jsonResult(await execute("list_tools", "tools.list", params, {
+        workspaceDir: policy.workspaceDir,
+        coreTools: getCoreCodingTools({ tools: policy.tools, excludeTools: policy.excludeTools }),
+        nativeTools: nativeTools(policy)
+      }))
+    }),
+    defineTool({
+      name: "tool_help",
+      label: "Tool help",
+      description: "Show --help text for a CLI tool.",
+      parameters: Type.Object({ name: Type.String() }),
+      execute: async (_id, params) => {
+        const help = await execute("tool_help", "tools.help", params);
+        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) => {
+        const skills = await execute("tool_skills", "tools.skills", params);
+        const visible = skills.map(({ content, ...item }) => item);
+        return jsonResult(visible);
+      }
+    }),
+    defineTool({
+      name: "set_tool_config",
+      label: "Set tool config",
+      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) => jsonResult(await execute("set_tool_config", "tools.setConfig", params))
+    }),
+    defineTool({
+      name: "set_tool_resource_note",
+      label: "Set tool resource note",
+      description: "Set or clear a deterministic chat-scoped note of up to 200 characters for one tool resource.",
+      parameters: Type.Object({
+        name: Type.String(),
+        resourceId: Type.String(),
+        note: Type.String()
+      }),
+      execute: async (_id, params) => jsonResult(await execute("set_tool_resource_note", "tools.setResourceNote", params))
+    }),
+    defineTool({
+      name: "run_tool",
+      label: "Run tool",
+      description: "Run a CLI tool using text input or an artifactId. Inspect the returned status/resolution fields. If a tool reports missing config, ask the user naturally, use set_tool_config, and retry. Set `deliver: true` to also send the generated file to the chat in one step (only when you want the user to receive it now, not for intermediate pipe steps).",
+      parameters: Type.Object({
+        name: Type.String(),
+        artifactId: Type.Optional(Type.String()),
+        text: Type.Optional(Type.String()),
+        resourceId: Type.Optional(Type.String()),
+        args: Type.Optional(Type.Record(Type.String(), Type.String())),
+        deliver: Type.Optional(Type.Boolean())
+      }),
+      execute: async (_id, params) => jsonResult(await execute("run_tool", "tools.run", params))
+    }),
+    defineTool({
+      name: "list_scheduled_tasks",
+      label: "List scheduled tasks",
+      description: "List scheduled async tasks for the current Telegram chat. Results default to 50 tasks, always include pending/running tasks, and accept an optional limit up to 100.",
+      parameters: Type.Object({
+        status: Type.Optional(Type.String()),
+        limit: Type.Optional(Type.Integer({ minimum: 1, maximum: maxScheduledTaskListLimit }))
+      }),
+      execute: async (_id, params) => jsonResult(await execute("list_scheduled_tasks", "tasks.list", params))
+    }),
+    defineTool({
+      name: "cancel_scheduled_task",
+      label: "Cancel scheduled task",
+      description: "Cancel one scheduled async task by id for the current Telegram chat.",
+      parameters: Type.Object({ id: Type.String() }),
+      execute: async (_id, params) => jsonResult(await execute("cancel_scheduled_task", "tasks.cancel", params))
+    }),
+    defineTool({
+      name: "cancel_all_scheduled_tasks",
+      label: "Cancel all scheduled tasks",
+      description: "Cancel all pending or running async tasks for the current Telegram chat.",
+      parameters: Type.Object({}),
+      execute: async () => jsonResult(await execute("cancel_all_scheduled_tasks", "tasks.cancelAll"))
+    }),
+    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) => jsonResult(await execute("create_telegram_topic", "telegram.createTopic", params))
+    }),
+    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) => jsonResult(await execute("initialize_telegram_topic", "telegram.initializeTopic", params))
+    }),
+    defineTool({
+      name: "send_artifact",
+      label: "Send artifact",
+      description: "Deliver an existing chat artifact to the current Telegram chat. Pass the `artifactId` returned by run_tool or from an inbound file. The delivery method and filename are derived from the artifact (its delivery hint, kind, and stored name); internal local paths are never exposed. No caption is shown by default, since the filename already appears on the attachment; set `caption` only to add a separate visible label, or `method` to override the delivery method. The artifact is not deleted.",
+      parameters: Type.Object({
+        artifactId: Type.String(),
+        caption: Type.Optional(Type.String()),
+        method: Type.Optional(Type.Union([
+          Type.Literal("voice"),
+          Type.Literal("audio"),
+          Type.Literal("document")
+        ]))
+      }),
+      execute: async (_id, params) => {
+        const result = await execute("send_artifact", "artifacts.deliver", params);
+        if (result?.ok === false) return jsonResult(result);
+        return jsonResult({ ok: true, sent: result }, `Media sent to Telegram as ${result.method}.`);
+      }
+    })
+  ];
+}

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

@@ -1,9 +1,10 @@
-import { mkdir, readFile, writeFile, copyFile } from "node:fs/promises";
+import { copyFile, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
 import { getChatArtifactsDir, getChatArtifactsIndexFile } from "../../runtime/paths.js";
 
 const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf]);
+const indexOperations = new Map();
 
 function id() {
   return crypto.randomUUID();
@@ -42,6 +43,48 @@ async function copyArtifactFile(originalPath, destPath, mimeType) {
   return writeFile(destPath, withUtf8Bom(content));
 }
 
+async function serializeIndexOperation(indexFile, operation) {
+  const previous = indexOperations.get(indexFile) || Promise.resolve();
+  const current = previous.catch(() => {}).then(operation);
+  indexOperations.set(indexFile, current);
+  try {
+    return await current;
+  } finally {
+    if (indexOperations.get(indexFile) === current) indexOperations.delete(indexFile);
+  }
+}
+
+async function syncParentDirectory(file) {
+  let handle;
+  try {
+    handle = await open(path.dirname(file), "r");
+    await handle.sync();
+  } catch {
+    // Some platforms do not support fsync on directories; rename remains atomic there.
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}
+
+async function writeJsonAtomically(file, value) {
+  await mkdir(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${id()}.tmp`;
+  let handle;
+  try {
+    handle = await open(temporary, "wx", 0o600);
+    await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    await rename(temporary, file);
+    await syncParentDirectory(file);
+  } catch (error) {
+    await handle?.close().catch(() => {});
+    await unlink(temporary).catch(() => {});
+    throw error;
+  }
+}
+
 class ChatArtifactStore {
   constructor(chatId) {
     this.chatId = String(chatId);
@@ -52,9 +95,15 @@ class ChatArtifactStore {
 
   async reload() {
     try {
-      this.items = JSON.parse(await readFile(this.indexFile, "utf8"));
-    } catch {
-      this.items = [];
+      const parsed = JSON.parse(await readFile(this.indexFile, "utf8"));
+      if (!Array.isArray(parsed)) throw new Error("Artifact index must contain a JSON array");
+      this.items = parsed;
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        this.items = [];
+        return;
+      }
+      throw new Error(`Artifact index is unreadable: ${this.indexFile}`, { cause: error });
     }
   }
 
@@ -63,9 +112,20 @@ class ChatArtifactStore {
     if (!this.items) await this.reload();
   }
 
-  async saveIndex() {
-    await mkdir(path.dirname(this.indexFile), { recursive: true });
-    await writeFile(this.indexFile, `${JSON.stringify(this.items, null, 2)}\n`, "utf8");
+  async appendToIndex(artifact) {
+    return serializeIndexOperation(this.indexFile, async () => {
+      await this.reload();
+      this.items.push(artifact);
+      await writeJsonAtomically(this.indexFile, this.items);
+      return artifact;
+    });
+  }
+
+  async readIndex() {
+    return serializeIndexOperation(this.indexFile, async () => {
+      await this.reload();
+      return this.items;
+    });
   }
 
   async createText({ text, mimeType = "text/plain", source, metadata = {} }) {
@@ -81,19 +141,17 @@ class ChatArtifactStore {
       metadata,
       createdAt: new Date().toISOString()
     };
-    this.items.push(artifact);
-    await this.saveIndex();
-    return artifact;
+    return this.appendToIndex(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,
@@ -104,44 +162,41 @@ class ChatArtifactStore {
       metadata,
       createdAt: new Date().toISOString()
     };
-    this.items.push(artifact);
-    await this.saveIndex();
-    return artifact;
+    return this.appendToIndex(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) {
     await this.init();
-    await this.reload();
-    return this.items.find((item) => item.id === artifactId) || null;
+    const items = await this.readIndex();
+    return items.find((item) => item.id === artifactId) || null;
   }
 
   async listRecent(limit = 20) {
     await this.init();
-    await this.reload();
-    return [...this.items].slice(-limit).reverse();
+    const items = await this.readIndex();
+    return [...items].slice(-limit).reverse();
   }
 }