arisa 5.2.19 → 5.2.21

package/src/index.js

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 
-import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
-import { applyRuntimeOverrides, createApp } from "./runtime/create-app.js";
 import { loadConfig } from "./core/config/config-store.js";
 import { createLogger } from "./runtime/logger.js";
 import { getServiceStatus, handoffServiceRestart, registerServiceProcess, restartService, serviceEntryFile, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
@@ -10,16 +8,14 @@ import { recordUnexpectedWorkerExit } from "./runtime/worker-recovery-report.js"
 import { flushArisaHome } from "./runtime/flush.js";
 import { readPackageVersion, showServiceLogs } from "./runtime/log-viewer.js";
 import { arisaPackageDir } from "./platform/paths.js";
-import { runSlaveCli } from "./runtime/slave-cli.js";
 import { unregisterSlaveServiceProcess } from "./runtime/slave-service.js";
 import { protectCoreFromOom } from "./runtime/oom-protection.js";
-import { runTui } from "./runtime/tui.js";
 
 process.env.ARISA_PACKAGE_DIR = arisaPackageDir;
 
 const args = process.argv.slice(2);
 const cli = parseCliArgs(args);
-const command = cli.positionals[0] || "run";
+const command = cli.flags.help ? "help" : cli.positionals[0] || "run";
 const forceBootstrap = Boolean(cli.flags.bootstrap);
 const verbose = !cli.flags.silent;
 const serviceRunner = Boolean(cli.flags["service-runner"]);
@@ -128,7 +124,13 @@ process.once("SIGINT", () => {
   shutdown(0);
 });
 
+async function bootstrapIfNeeded(options) {
+  const bootstrap = await import("./runtime/bootstrap.js");
+  return bootstrap.bootstrapIfNeeded(options);
+}
+
 async function startRuntimeApp() {
+  const { createApp } = await import("./runtime/create-app.js");
   const app = await createApp({
     logger,
     runtimeOverrides,
@@ -142,6 +144,7 @@ async function startRuntimeApp() {
 }
 
 async function startBackgroundService() {
+  const { applyRuntimeOverrides } = await import("./runtime/create-app.js");
   const persistedConfig = await loadConfig();
   applyRuntimeOverrides(persistedConfig, runtimeOverrides);
   const result = await startService({ verbose, cliArgs: toServiceRunnerArgs(cli.nestedFlags) });
@@ -155,6 +158,7 @@ async function startBackgroundService() {
 }
 
 async function restartBackgroundService() {
+  const { applyRuntimeOverrides } = await import("./runtime/create-app.js");
   const persistedConfig = await loadConfig();
   applyRuntimeOverrides(persistedConfig, runtimeOverrides);
   const result = await restartService({
@@ -222,8 +226,37 @@ async function runForeground() {
   }
 }
 
+function printHelp() {
+  console.log([
+    "Usage: arisa [command] [options]",
+    "",
+    "Commands:",
+    "  run       Run Arisa in the foreground (default)",
+    "  tui       Open the terminal interface",
+    "  start     Start the background service",
+    "  stop      Stop the background service",
+    "  restart   Restart the background service",
+    "  status    Show background service status",
+    "  log       Show background service logs",
+    "  flush     Remove Arisa state while stopped",
+    "  slave     Manage a Slave host",
+    "  help      Show this help",
+    "",
+    "Options:",
+    "  --help    Show this help",
+    "  --silent  Reduce runtime logging",
+    "  --bootstrap  Reopen interactive setup"
+  ].join("\n"));
+}
+
 async function main() {
+  if (command === "help") {
+    printHelp();
+    return;
+  }
+
   if (slaveCommand) {
+    const { runSlaveCli } = await import("./runtime/slave-cli.js");
     const result = await runSlaveCli({
       positionals: cli.positionals.slice(1),
       flags: cli.flags,
@@ -265,6 +298,7 @@ async function main() {
   }
 
   if (command === "tui") {
+    const { runTui } = await import("./runtime/tui.js");
     await runTui({ logger });
     return;
   }
@@ -328,6 +362,12 @@ async function main() {
     return;
   }
 
+  if (command !== "run") {
+    const error = new Error(`Unknown Arisa command: ${command}`);
+    error.code = "ARISA_UNKNOWN_COMMAND";
+    throw error;
+  }
+
   await runForeground();
 }
 

package/src/platform/paths.js

@@ -25,7 +25,8 @@ export function createIpcSocketPath({ homeDir = arisaHomeDir, platform = process
 }
 
 export const arisaIpcSocketFile = createIpcSocketPath();
-export const tasksFile = path.join(stateDir, "tasks.json");
+export const tasksFile = path.join(stateDir, "tasks.json"); // Legacy migration source; retained unchanged.
+export const tasksDatabaseFile = path.join(stateDir, "tasks.sqlite");
 export const toolsDir = path.join(arisaHomeDir, "tools");
 export const chatsDir = path.join(arisaHomeDir, "chats");
 export const toolStateDir = path.join(stateDir, "tools");
@@ -46,10 +47,15 @@ export function getChatArtifactsDir(chatId) {
   return path.join(getChatDir(chatId), "artifacts");
 }
 
+// Legacy JSON index; retained unchanged as a migration backup.
 export function getChatArtifactsIndexFile(chatId) {
   return path.join(getChatDir(chatId), "state", "artifacts.json");
 }
 
+export function getChatArtifactsDatabaseFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "artifacts.sqlite");
+}
+
 export function getChatSessionSeedFile(chatId) {
   return path.join(getChatDir(chatId), "state", "session-seed.jsonl");
 }

package/src/runtime/worker-recovery-report.js

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { readRecentLogLines } from "./log-viewer.js";
-import { arisaPackageDir, serviceLogFile, stateDir, tasksFile } from "../platform/paths.js";
+import { arisaPackageDir, serviceLogFile, stateDir } from "../platform/paths.js";
 
 export const workerRecoveryReportFile = path.join(stateDir, "worker-recovery-report.json");
 
@@ -70,9 +70,12 @@ export function summarizeRecoveryEvidence(lines, report) {
   };
 }
 
-async function interruptedTaskCount(report, file = tasksFile) {
+async function interruptedTaskCount(report, file) {
   try {
-    const document = JSON.parse(await readFile(file, "utf8"));
+    // Explicit JSON input is retained for offline reports. Runtime reads the live DB.
+    const document = file
+      ? JSON.parse(await readFile(file, "utf8"))
+      : await new (await import("../core/tasks/task-store.js")).TaskStore().list();
     const tasks = Array.isArray(document) ? document : document.tasks || [];
     const occurredAt = new Date(report.occurredAt).getTime();
     return tasks.filter((task) => {
@@ -98,7 +101,7 @@ async function runtimeVersion() {
 export async function loadWorkerRecoveryReport({
   reportFile = workerRecoveryReportFile,
   logFile = serviceLogFile,
-  taskFile = tasksFile,
+  taskFile,
   readLines = readRecentLogLines,
   getVersion = runtimeVersion
 } = {}) {

package/src/transport/telegram/model-callback.js

@@ -1,7 +1,7 @@
 import { getErrorMessage } from "../../core/agent/auth-flow.js";
 import { resolveChatModel, resolveChatSpeed, resolveChatThinkingLevel } from "../../core/agent/model-selection.js";
 import { clampModelThinkingLevel, listModelThinkingLevels, modelSupportsThinking } from "../../core/agent/pi-runtime.js";
-import { modelSupportsSpeed } from "../../core/agent/model-speed.js";
+import { clampModelSpeed, modelSupportsSpeed } from "../../core/agent/model-speed.js";
 import { parseEffortPickerAction, parseModelPickerAction, parseSpeedPickerAction } from "./model-picker.js";
 
 export async function closeModelPicker(ctx, { messageText, callbackText }) {
@@ -181,9 +181,10 @@ export function createTelegramModelCallbackHandler({
           return;
         }
         if (!modelSupportsSpeed(model)) {
-          await ctx.answerCallbackQuery({ text: "This model does not support speed 1.5x.", show_alert: true });
+          await ctx.answerCallbackQuery({ text: "This model does not support fast mode.", show_alert: true });
           return;
         }
+        action.speed = clampModelSpeed(model, action.speed);
         const currentSpeed = resolveChatSpeed(config, modelChatId);
         if (action.speed === currentSpeed) {
           await closeModelPicker(ctx, {

package/src/transport/telegram/model-controls.js

@@ -8,7 +8,7 @@ import {
   selectChatThinkingLevel
 } from "../../core/agent/model-selection.js";
 import { clampModelThinkingLevel, createPiRuntime, listModelThinkingLevels, listProviderModels, modelSupportsThinking } from "../../core/agent/pi-runtime.js";
-import { clampModelSpeed, MODEL_SPEEDS, modelSupportsSpeed } from "../../core/agent/model-speed.js";
+import { clampModelSpeed, listModelSpeeds, modelSupportsSpeed } from "../../core/agent/model-speed.js";
 import { buildEffortPicker, buildModelPicker, buildSpeedPicker, reverseModelOrder } from "./model-picker.js";
 
 function chatKey(chatId) {
@@ -89,12 +89,12 @@ export function createTelegramModelControls({ config, saveConfig, agentManager,
     const model = models.find((item) => item.id === resolveChatModel(config, route.sessionId));
     if (!model) throw new Error(`Model not found for provider ${agentConfig.provider}`);
     if (!modelSupportsSpeed(model)) {
-      return editOrReplyText(ctx, `${model.provider}/${model.id} does not support speed 1.5x.`);
+      return editOrReplyText(ctx, `${model.provider}/${model.id} does not support fast mode.`);
     }
     const picker = buildSpeedPicker({
       provider: model.provider,
       modelId: model.id,
-      speeds: MODEL_SPEEDS,
+      speeds: listModelSpeeds(model),
       selectedSpeed: resolveChatSpeed(config, route.sessionId)
     });
     return editOrReplyPicker(ctx, picker);

package/src/transport/telegram/model-picker.js

@@ -37,7 +37,7 @@ export function parseEffortPickerAction(data) {
 
 export function parseSpeedPickerAction(data) {
   if (data === "noop:page") return { type: "noop", value: null };
-  const speed = /^speed:(1(?:\.5)?)$/.exec(String(data || ""));
+  const speed = /^speed:(1(?:\.5)?|2)$/.exec(String(data || ""));
   return speed ? { type: "speed", speed: Number(speed[1]) } : null;
 }
 

package/src/transport/telegram/task-dispatcher.js

@@ -72,10 +72,11 @@ export function createTelegramTaskDispatcher({
   const agentTimeoutMs = boundedTimeout(taskTimeouts.agentTimeoutMs, 15 * 60_000);
   const eventTimeoutMs = boundedTimeout(taskTimeouts.eventTimeoutMs, 5 * 60_000);
 
-  const runBackgroundTool = (toolName, chatId, args, label) => agentManager.runTurn({
-    priority: "background",
-    label
-  }, () => agentManager.runTool({ name: toolName, request: { args }, chatId }));
+  const runHeadlessTool = (toolName, chatId, args) => agentManager.runTool({
+    name: toolName,
+    request: { args },
+    chatId
+  });
 
   function throwToolFailure(result, toolName, fallbackResolution) {
     const error = new Error(result?.error || `${toolName} failed`);
@@ -98,11 +99,10 @@ export function createTelegramTaskDispatcher({
   async function dispatchAgentTask(task, chatId) {
     if (!task.payload.prompt) throw new NonRetryableTaskError("agent_task missing prompt");
     if (task.authBlock?.toolName) {
-      const probe = await runBackgroundTool(
+      const probe = await runHeadlessTool(
         task.authBlock.toolName,
         chatId,
-        task.authBlock.probeArgs || {},
-        `authentication probe ${task.authBlock.toolName}`
+        task.authBlock.probeArgs || {}
       );
       if (probe?.ok === false) throwToolFailure(probe, task.authBlock.toolName, task.authBlock);
       logger?.log("tasks", `authentication restored for ${task.authBlock.toolName} (task ${task.id})`);
@@ -156,7 +156,7 @@ export function createTelegramTaskDispatcher({
     if (!toolName) throw new NonRetryableTaskError("poll_tool missing toolName");
     logger?.log("tasks", `polling tool ${toolName} (task ${task.id}) for chat ${chatId}`);
 
-    const runTool = (args) => runBackgroundTool(toolName, chatId, args, `poll tool ${toolName}`);
+    const runTool = (args) => runHeadlessTool(toolName, chatId, args);
 
     if (task.authBlock) {
       const probe = await runTool(task.authBlock.probeArgs || {});

package/test/agent-turn-coordinator.test.js

@@ -25,6 +25,54 @@ test("interactive turns run before queued background turns without overlapping",
   assert.equal(coordinator.diagnostic().completed, 3);
 });
 
+test("reserves a quiet window for interactive follow-ups before background work", async (t) => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  let now = 1_000;
+  const coordinator = new AgentTurnCoordinator({
+    config: { interactiveQuietMs: 100 },
+    now: () => now
+  });
+  const releaseFirstInteractive = await coordinator.acquire({ priority: "interactive", label: "first" });
+  releaseFirstInteractive();
+
+  let backgroundStarted = false;
+  const background = coordinator.acquire({ priority: "background", label: "background" }).then((release) => {
+    backgroundStarted = true;
+    return release;
+  });
+  assert.equal(backgroundStarted, false);
+
+  now = 1_050;
+  const releaseFollowUp = await coordinator.acquire({ priority: "interactive", label: "follow-up" });
+  assert.equal(coordinator.diagnostic().active.label, "follow-up");
+  releaseFollowUp();
+  await Promise.resolve();
+  assert.equal(backgroundStarted, false);
+
+  now = 1_150;
+  t.mock.timers.tick(100);
+  const releaseBackground = await background;
+  assert.equal(backgroundStarted, true);
+  releaseBackground();
+});
+
+test("reports wait metrics separately for interactive and background turns", async () => {
+  let now = 1_000;
+  const coordinator = new AgentTurnCoordinator({ now: () => now });
+  const releaseActive = await coordinator.acquire({ priority: "background" });
+  const interactive = coordinator.acquire({ priority: "interactive" });
+  now = 1_025;
+  releaseActive();
+  const releaseInteractive = await interactive;
+  releaseInteractive();
+
+  const diagnostic = coordinator.diagnostic();
+  assert.equal(diagnostic.priorities.background.completed, 1);
+  assert.equal(diagnostic.priorities.interactive.completed, 1);
+  assert.equal(diagnostic.priorities.interactive.maxWaitMs, 25);
+  assert.equal(diagnostic.priorities.interactive.averageWaitMs, 25);
+});
+
 test("background turns expire safely before execution when their queue TTL elapses", async (t) => {
   t.mock.timers.enable({ apis: ["setTimeout"] });
   const coordinator = new AgentTurnCoordinator();

package/test/artifact-index-memory.test.js

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { mkdtemp, open, rm } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+test("migrates a 100 MiB history and repeatedly accesses it with a 48 MiB heap", { timeout: 120_000 }, async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "artifact-memory-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const options = {chatId:"test",legacyFile:path.join(root,"artifacts.json"),databaseFile:path.join(root,"artifacts.sqlite")};
+  const file = await open(options.legacyFile, "wx", 0o600);
+  try {
+    await file.write("[");
+    for (let i = 0; i < 1024; i++) {
+      await file.write((i ? "," : "") + JSON.stringify({id:String(i),chatId:"test",text:"x".repeat(100*1024)}));
+    }
+    await file.write("]");
+  } finally { await file.close(); }
+  const moduleUrl = new URL("../src/core/artifacts/artifact-index.js", import.meta.url).href;
+  const code = `
+    import assert from 'node:assert/strict';
+    import {withArtifactIndex,getArtifact,appendArtifact,listRecentArtifacts} from ${JSON.stringify(moduleUrl)};
+    const f=${JSON.stringify(options)};
+    const start=performance.now();
+    await withArtifactIndex(f,db=>assert.equal(getArtifact(db,'0').text.length,102400));
+    const migrated=performance.now();
+    for(let i=0;i<100;i++) {
+      await withArtifactIndex(f,db=>appendArtifact(db,{id:'new-'+i,chatId:'test',text:'small'}));
+      await withArtifactIndex(f,db=>assert.equal(getArtifact(db,String(i)).text.length,102400));
+      await withArtifactIndex(f,db=>assert.equal(listRecentArtifacts(db,20).length,20));
+    }
+    await withArtifactIndex(f,db=>assert.equal(db.prepare('SELECT count(*) AS n FROM artifacts').get().n,1124));
+    console.log(JSON.stringify({migrationMs:Math.round(migrated-start),operationsMs:Math.round(performance.now()-migrated),maxRssKiB:process.resourceUsage().maxRSS,heapMiB:Math.round(process.memoryUsage().heapUsed/1048576)}));
+  `;
+  const result = await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, ["--max-old-space-size=48", "--input-type=module", "-e", code], {stdio:["ignore","pipe","pipe"]});
+    let stdout = "", stderr = "";
+    child.stdout.on("data", data => {stdout += data;});
+    child.stderr.on("data", data => {stderr += data;});
+    child.on("error", reject);
+    child.on("exit", code => code === 0 ? resolve(JSON.parse(stdout)) : reject(new Error(stderr)));
+  });
+  t.diagnostic(JSON.stringify(result));
+  assert.ok(result.heapMiB < 48);
+});

package/test/artifact-index-migration.test.js

@@ -0,0 +1,88 @@
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile, readFile, rm, stat } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { DatabaseSync } from "node:sqlite";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { readLegacyArtifacts } from "../src/core/artifacts/legacy-artifact-reader.js";
+import { withArtifactIndex, getArtifact, appendArtifact, listRecentArtifacts } from "../src/core/artifacts/artifact-index.js";
+
+async function fixture(t) {
+  const root = await mkdtemp(path.join(os.tmpdir(), "artifact-migration-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  return { chatId: "test", legacyFile: path.join(root, "artifacts.json"), databaseFile: path.join(root, "artifacts.sqlite") };
+}
+
+const artifacts = [
+  { id: "a", chatId: "test", kind: "text", text: 'ñ🙂[\\\"}]\n', metadata: { nested: [{ x: true }] } },
+  { id: "b", chatId: "test", kind: "document", path: "/unchanged/report.pdf", source: { type: "test" } }
+];
+
+test("legacy parser handles UTF-8, escaping and every token crossing chunk boundaries", async (t) => {
+  const f = await fixture(t);
+  await writeFile(f.legacyFile, JSON.stringify(artifacts, null, 2));
+  for (const highWaterMark of [1, 2, 7, 64]) {
+    const result = [];
+    for await (const item of readLegacyArtifacts(f.legacyFile, { highWaterMark })) result.push(item);
+    assert.deepEqual(result, artifacts);
+  }
+});
+
+test("migration preserves all fields, order and original bytes; runs only once", async (t) => {
+  const f = await fixture(t);
+  const original = JSON.stringify(artifacts, null, 2);
+  await writeFile(f.legacyFile, original);
+  assert.deepEqual(await withArtifactIndex(f, db => listRecentArtifacts(db, 20)), artifacts.toReversed());
+  assert.equal(await readFile(f.legacyFile, "utf8"), original);
+  const next = { id: "c", chatId: "test", text: "new" };
+  await withArtifactIndex(f, db => appendArtifact(db, next));
+  assert.deepEqual(await withArtifactIndex(f, db => getArtifact(db, "a")), artifacts[0]);
+  assert.deepEqual(await withArtifactIndex(f, db => listRecentArtifacts(db, 20)), [next, ...artifacts.toReversed()]);
+  assert.equal((await stat(f.databaseFile)).mode & 0o777, 0o600);
+  const db = new DatabaseSync(f.databaseFile);
+  assert.equal(db.prepare("PRAGMA integrity_check").get().integrity_check, "ok");
+  db.close();
+});
+
+test("invalid migrations roll back completely and can be retried after repair", async (t) => {
+  const f = await fixture(t);
+  for (const broken of ['{}', '[', '[{}]', '[null]', '[1]', '[{"id":"a","chatId":"test"},]', JSON.stringify(artifacts).slice(0, -1), JSON.stringify(artifacts) + 'x', JSON.stringify([artifacts[0], artifacts[0]]), JSON.stringify([{...artifacts[0],chatId:"other"}])]) {
+    await writeFile(f.legacyFile, broken);
+    await assert.rejects(withArtifactIndex(f, () => {}), /Artifact index is unreadable/);
+    assert.equal(await readFile(f.legacyFile, "utf8"), broken);
+    const db = new DatabaseSync(f.databaseFile);
+    assert.equal(db.prepare("PRAGMA user_version").get().user_version, 0);
+    assert.equal(db.prepare("SELECT count(*) AS n FROM sqlite_master WHERE name='artifacts'").get().n, 0);
+    db.close();
+  }
+  await writeFile(f.legacyFile, JSON.stringify(artifacts));
+  assert.deepEqual(await withArtifactIndex(f, db => getArtifact(db, "a")), artifacts[0]);
+});
+
+test("separate processes migrate and append without lost writes", async (t) => {
+  const f = await fixture(t);
+  await writeFile(f.legacyFile, JSON.stringify(artifacts));
+  const moduleUrl = new URL("../src/core/artifacts/artifact-index.js", import.meta.url).href;
+  await Promise.all(Array.from({length: 3}, (_, n) => new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, ["--input-type=module", "-e", `
+      import {withArtifactIndex,appendArtifact} from ${JSON.stringify(moduleUrl)};
+      for(let i=0;i<20;i++) await withArtifactIndex(${JSON.stringify(f)}, db => appendArtifact(db, {id:'${n}-'+i,chatId:'test',text:'ok'}));
+    `], {stdio:["ignore","ignore","pipe"]});
+    let stderr = "";
+    child.stderr.on("data", data => {stderr += data;});
+    child.on("error", reject);
+    child.on("exit", code => code === 0 ? resolve() : reject(new Error(stderr)));
+  })));
+  assert.equal((await withArtifactIndex(f, db => listRecentArtifacts(db, 100))).length, 62);
+});
+
+test("recent queries reject oversized results instead of materializing the whole selection", async (t) => {
+  const f = await fixture(t);
+  await withArtifactIndex(f, db => {
+    for (let i = 0; i < 20; i++) appendArtifact(db, {id: String(i), chatId: 'test', text: 'x'.repeat(1024 * 1024)});
+  });
+  await assert.rejects(withArtifactIndex(f, db => listRecentArtifacts(db, 20)), /exceed 16 MiB/);
+  assert.equal((await withArtifactIndex(f, db => listRecentArtifacts(db, 2))).length, 2);
+  assert.deepEqual(await withArtifactIndex(f, db => listRecentArtifacts(db, 0)), []);
+});

package/test/artifact-store.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -57,7 +57,7 @@ test("serializes 100 concurrent artifact writes across store instances", async (
     })
   )));
 
-  const persisted = JSON.parse(await readFile(getChatArtifactsIndexFile(chatId), "utf8"));
+  const persisted = await new ArtifactStore().forChat(chatId).listRecent(100);
   assert.equal(persisted.length, 100);
   assert.equal(new Set(persisted.map((artifact) => artifact.id)).size, 100);
   assert.deepEqual(
@@ -72,7 +72,7 @@ test("refuses to overwrite a corrupt artifact index", async () => {
   await resetHome();
   const chatId = "corrupt-chat";
   const indexFile = getChatArtifactsIndexFile(chatId);
-  await new ArtifactStore().forChat(chatId).createText({ text: "safe", source: { type: "test" } });
+  await mkdir(path.dirname(indexFile), { recursive: true });
   await writeFile(indexFile, "{truncated", "utf8");
 
   await assert.rejects(

package/test/cli-command.test.js

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+
+const execFileAsync = promisify(execFile);
+const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const entry = path.join(packageDir, "src", "index.js");
+
+async function isolatedEnvironment() {
+  const home = await mkdtemp(path.join(os.tmpdir(), "arisa-cli-command-"));
+  return {
+    home,
+    env: { ...process.env, ARISA_HOME: home }
+  };
+}
+
+test("prints CLI help without starting the runtime", async (t) => {
+  const isolated = await isolatedEnvironment();
+  t.after(() => rm(isolated.home, { recursive: true, force: true }));
+
+  const { stdout, stderr } = await execFileAsync(process.execPath, [entry, "--help"], {
+    cwd: packageDir,
+    env: isolated.env
+  });
+
+  assert.match(stdout, /^Usage: arisa/m);
+  assert.match(stdout, /status\s+Show background service status/);
+  assert.equal(stderr, "");
+});
+
+test("rejects unknown CLI commands instead of starting the runtime", async (t) => {
+  const isolated = await isolatedEnvironment();
+  t.after(() => rm(isolated.home, { recursive: true, force: true }));
+
+  await assert.rejects(
+    () => execFileAsync(process.execPath, [entry, "doctor"], {
+      cwd: packageDir,
+      env: isolated.env
+    }),
+    (error) => {
+      assert.equal(error.code, 1);
+      assert.match(error.stderr, /Unknown Arisa command: doctor/);
+      assert.doesNotMatch(error.stderr, /loading config|validating Pi session/);
+      return true;
+    }
+  );
+});

package/test/cli-memory.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+const exec = promisify(execFile);
+
+test("status runs with a 24 MiB heap without loading the agent, SQLite or TUI", async (t) => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "arisa-cli-memory-"));
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const entry = new URL("../src/index.js", import.meta.url);
+  const {stdout, stderr} = await exec(process.execPath, ["--max-old-space-size=24", entry.pathname, "status"], {
+    env: {...process.env, ARISA_HOME: home}, timeout: 15_000
+  });
+  assert.match(stdout, /Arisa is not running/);
+  assert.equal(stderr, "");
+  const source = await readFile(entry, "utf8");
+  assert.doesNotMatch(source, /^import .*from .*runtime\/(create-app|bootstrap|tui|slave-cli)\.js/m);
+});

package/test/daemon-runtime.test.js

@@ -21,7 +21,10 @@ const policy = {
   restartBackoffMaxMs: 40,
   startupTimeoutMs: 2_000,
   stopTimeoutMs: 300,
-  queuePollIntervalMs: 10
+  queuePollIntervalMs: 10,
+  journalRetentionMs: 24 * 60 * 60_000,
+  journalMaxCompleted: 128,
+  journalSweepIntervalMs: 60_000
 };
 
 await mkdir(path.join(homeDir, "state"), { recursive: true });
@@ -51,8 +54,10 @@ const {
 const { submitDaemonControl: directSubmitDaemonControl } = await import("../src/core/tools/daemon-client.js");
 const {
   DAEMON_EVENT_TYPES: directDaemonEventTypes,
-  DAEMON_PROTOCOL_VERSION: directDaemonProtocolVersion
+  DAEMON_PROTOCOL_VERSION: directDaemonProtocolVersion,
+  daemonJobPaths
 } = await import("../src/core/tools/daemon-protocol.js");
+const { maintainDaemonJournal } = await import("../src/core/tools/daemon-journal.js");
 const { createToolProcessSupervisor, formatDaemonOutcome } = await import("../src/runtime/tool-process-supervisor.js");
 const { superviseDaemon } = await import("../src/core/tools/daemon-health.js");
 const { ToolRegistry } = await import("../src/core/tools/tool-registry.js");
@@ -127,7 +132,7 @@ test("streams ordered daemon events and persists the terminal result", async ()
   assert.deepEqual(output, { echo: "done" });
   assert.deepEqual(events.map((event) => event.type), ["accepted", "progress", "chunk", "completed"]);
   assert.deepEqual(events.map((event) => event.sequence), [1, 2, 3, 4]);
-  assert.ok((await readdir(runtime.paths.commandsDir)).some((file) => file.endsWith(".result.json")));
+  assert.ok((await readdir(runtime.paths.resultsDir)).some((file) => file.endsWith(".result.json")));
   await runtime.stop();
 });
 
@@ -140,7 +145,7 @@ test("cancels a timed-out job without restarting the shared daemon", async () =>
   );
 
   const terminal = await waitFor(async () => {
-    const result = await readJson(path.join(runtime.paths.commandsDir, `${jobId}.result.json`), null);
+    const result = await readJson(daemonJobPaths(runtime.paths, jobId).result, null);
     return result?.terminal || null;
   });
   assert.equal(terminal.type, "failed");
@@ -192,6 +197,41 @@ test("recovers queued and accepted journal records after daemon start", async ()
   await runtime.stop();
 });
 
+test("migrates and bounds completed daemon journal records outside the active queue", async () => {
+  const paths = daemonPaths({ toolName: "journal-test", scope: { type: "chat", chatId: "303" } });
+  await maintainDaemonJournal(paths);
+  for (let index = 0; index < 5; index += 1) {
+    await writeJson(path.join(paths.commandsDir, `legacy-${index}.result.json`), {
+      id: `legacy-${index}`,
+      terminal: { version: 1, jobId: `legacy-${index}`, type: "completed", sequence: 2, payload: { output: { index } } }
+    });
+  }
+  await writeJson(path.join(paths.commandsDir, "legacy-active.request.json"), {
+    id: "legacy-active",
+    status: "queued",
+    payload: { value: "active" }
+  });
+  await writeJson(path.join(paths.commandsDir, "legacy-active.result.json"), {
+    id: "legacy-active",
+    terminal: { version: 1, jobId: "legacy-active", type: "completed", sequence: 2, payload: { output: { active: true } } }
+  });
+
+  const journal = await maintainDaemonJournal(paths, {
+    journalRetentionMs: 60_000,
+    journalMaxCompleted: 2
+  });
+  const activeFiles = await readdir(paths.commandsDir);
+  const resultFiles = await readdir(paths.resultsDir);
+
+  assert.equal(journal.active, 1);
+  assert.equal(journal.completed, 3);
+  assert.equal(journal.migrated, 3);
+  assert.equal(journal.pruned, 3);
+  assert.deepEqual(activeFiles, ["legacy-active.request.json"]);
+  assert.equal(resultFiles.includes("legacy-active.result.json"), true);
+  assert.equal(resultFiles.length, 3);
+});
+
 test("isolates daemon process files and context by chat scope", async () => {
   const first = runtimeFor({ type: "chat", chatId: "101" });
   const second = runtimeFor({ type: "chat", chatId: "202" });