arisa 5.2.20 → 5.2.21

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

@@ -0,0 +1,115 @@
+import { mkdir, readdir, rename, rm, stat } from "node:fs/promises";
+import path from "node:path";
+
+const defaultRetentionMs = 24 * 60 * 60_000;
+const defaultMaxCompleted = 2_048;
+const operationBatchSize = 64;
+
+function positiveInteger(value, fallback) {
+  return Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+
+function resultId(file) {
+  return file.endsWith(".result.json") ? file.slice(0, -".result.json".length) : "";
+}
+
+function activeId(file) {
+  return file.replace(/\.(?:request|processing)\.json$/, "");
+}
+
+async function entries(directory) {
+  try {
+    return await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+}
+
+async function inBatches(items, operation) {
+  for (let index = 0; index < items.length; index += operationBatchSize) {
+    await Promise.all(items.slice(index, index + operationBatchSize).map(operation));
+  }
+}
+
+async function completedRecords(directory, location, directoryEntries) {
+  const records = directoryEntries
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".result.json"))
+    .map((entry) => ({
+      id: resultId(entry.name),
+      name: entry.name,
+      file: path.join(directory, entry.name),
+      location,
+      mtimeMs: 0
+    }));
+  await inBatches(records, async (record) => {
+    record.mtimeMs = (await stat(record.file)).mtimeMs;
+  });
+  return records;
+}
+
+async function moveLegacyResult(record, resultsDir) {
+  const destination = path.join(resultsDir, record.name);
+  try {
+    await rename(record.file, destination);
+  } catch (error) {
+    if (error?.code !== "EEXIST") throw error;
+    await rm(record.file, { force: true });
+  }
+}
+
+export async function ensureDaemonJournal(paths) {
+  await Promise.all([
+    mkdir(paths.commandsDir, { recursive: true }),
+    mkdir(paths.resultsDir, { recursive: true })
+  ]);
+}
+
+export async function maintainDaemonJournal(paths, policy = {}, { now = Date.now } = {}) {
+  const startedAt = Date.now();
+  await ensureDaemonJournal(paths);
+  const [commandEntries, resultEntries] = await Promise.all([
+    entries(paths.commandsDir),
+    entries(paths.resultsDir)
+  ]);
+  const activeIds = new Set(commandEntries
+    .filter((entry) => entry.isFile() && /\.(?:request|processing)\.json$/.test(entry.name))
+    .map((entry) => activeId(entry.name)));
+  const completed = [
+    ...await completedRecords(paths.resultsDir, "results", resultEntries),
+    ...await completedRecords(paths.commandsDir, "legacy", commandEntries)
+  ].sort((left, right) => right.mtimeMs - left.mtimeMs || left.name.localeCompare(right.name));
+  const retentionMs = positiveInteger(policy.journalRetentionMs, defaultRetentionMs);
+  const maxCompleted = positiveInteger(policy.journalMaxCompleted, defaultMaxCompleted);
+  const cutoff = now() - retentionMs;
+  const seen = new Set();
+  const retained = [];
+  const removed = [];
+  let retainedCompleted = 0;
+
+  for (const record of completed) {
+    const duplicate = seen.has(record.id);
+    const protectedByActiveJob = activeIds.has(record.id);
+    const withinRetention = record.mtimeMs >= cutoff;
+    const withinLimit = retainedCompleted < maxCompleted;
+    if (!duplicate && (protectedByActiveJob || (withinRetention && withinLimit))) {
+      seen.add(record.id);
+      retained.push(record);
+      if (!protectedByActiveJob) retainedCompleted += 1;
+    } else {
+      removed.push(record);
+    }
+  }
+
+  await inBatches(removed, (record) => rm(record.file, { force: true }));
+  const legacy = retained.filter((record) => record.location === "legacy");
+  await inBatches(legacy, (record) => moveLegacyResult(record, paths.resultsDir));
+
+  return {
+    active: activeIds.size,
+    completed: retained.length,
+    migrated: legacy.length,
+    pruned: removed.length,
+    scanMs: Math.max(0, Date.now() - startedAt)
+  };
+}

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

@@ -56,6 +56,7 @@ export function daemonPaths(toolNameOrOptions, scope) {
     instanceId: getDaemonInstanceId(identity.scope),
     root,
     commandsDir: path.join(root, "commands"),
+    resultsDir: path.join(root, "results"),
     pidFile: path.join(root, "daemon.pid"),
     metaFile: path.join(root, "daemon.meta.json"),
     statusFile: path.join(root, "status.json"),
@@ -186,6 +187,13 @@ export async function readDaemonDiagnostic({ toolName, scope, autoStart = false
       nextAt: status.nextRestartAt || null
     },
     disposition: daemonDisposition({ state, alive, autoStart: Boolean(autoStart), restartRequested }),
+    journal: status.journal && typeof status.journal === "object" ? {
+      active: Number(status.journal.active || 0),
+      completed: Number(status.journal.completed || 0),
+      migrated: Number(status.journal.migrated || 0),
+      pruned: Number(status.journal.pruned || 0),
+      scanMs: Number(status.journal.scanMs || 0)
+    } : null,
     updatedAt: status.updatedAt || null,
     logFile: paths.logFile
   };
@@ -275,7 +283,8 @@ export async function unregisterManagedDaemon(toolNameOrOptions, { scope } = {})
     rm(paths.startLockFile, { force: true }),
     rm(paths.capabilityFile, { force: true }),
     process.platform === "win32" ? Promise.resolve() : rm(paths.socketFile, { force: true }),
-    rm(paths.commandsDir, { recursive: true, force: true })
+    rm(paths.commandsDir, { recursive: true, force: true }),
+    rm(paths.resultsDir, { recursive: true, force: true })
   ]);
   return { toolName: paths.toolName, scope: paths.scope, instanceId: paths.instanceId };
 }

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

@@ -10,7 +10,7 @@ export function daemonJobPaths(paths, id) {
   return {
     request: path.join(paths.commandsDir, `${id}.request.json`),
     processing: path.join(paths.commandsDir, `${id}.processing.json`),
-    result: path.join(paths.commandsDir, `${id}.result.json`)
+    result: path.join(paths.resultsDir || paths.commandsDir, `${id}.result.json`)
   };
 }
 

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

@@ -1,5 +1,5 @@
 import net from "node:net";
-import { chmod, mkdir, readdir, rename, rm, unlink } from "node:fs/promises";
+import { chmod, readdir, rename, rm, unlink } from "node:fs/promises";
 import {
   ensureDaemonCapability,
   readJson,
@@ -7,6 +7,7 @@ import {
   writeJson
 } from "./daemon-processes.js";
 import { loadDaemonPolicy } from "./daemon-policy.js";
+import { ensureDaemonJournal, maintainDaemonJournal } from "./daemon-journal.js";
 import {
   DAEMON_CONTROL_FIELD,
   DAEMON_PROTOCOL_VERSION,
@@ -37,7 +38,7 @@ export function createDaemonWorker({ toolName, paths }) {
   let statusWrite = Promise.resolve();
 
   async function ensure() {
-    await mkdir(paths.commandsDir, { recursive: true });
+    await ensureDaemonJournal(paths);
   }
 
   async function getPid() {
@@ -96,6 +97,7 @@ export function createDaemonWorker({ toolName, paths }) {
       streamBufferBytes: policy.streamBufferBytes || 1_048_576
     };
     const subscribers = new Map();
+    const deliveredSequences = new WeakMap();
     const activeJobs = new Map();
     const cancelledJobs = new Set();
     let lastActivity = Date.now();
@@ -103,21 +105,42 @@ export function createDaemonWorker({ toolName, paths }) {
     let exiting = false;
     let acceptingWork = true;
     let processRequested = false;
+    let journalMaintenance = Promise.resolve();
 
-    await ensure();
+    function maintainJournal() {
+      const operation = journalMaintenance
+        .catch(() => {})
+        .then(() => maintainDaemonJournal(paths, policy));
+      journalMaintenance = operation;
+      return operation;
+    }
+
+    const journal = await maintainJournal();
     const capabilityToken = process.env.ARISA_DAEMON_CAPABILITY || await ensureDaemonCapability(paths);
     await writeStatus({
       state: "starting",
       pid: process.pid,
       heartbeatAt: new Date().toISOString(),
       supportsRecovery: typeof recover === "function",
+      journal,
       message: "Daemon work loop started; waiting for health check"
     });
 
+    async function sendFrame(socket, frame) {
+      const delivered = deliveredSequences.get(socket) || new Map();
+      if ((delivered.get(frame.jobId) || 0) >= frame.sequence) return true;
+      const sent = await writeDaemonSocketFrame(socket, frame, ipcLimits);
+      if (sent) {
+        delivered.set(frame.jobId, frame.sequence);
+        deliveredSequences.set(socket, delivered);
+      }
+      return sent;
+    }
+
     async function publish(frame) {
       const sockets = [...(subscribers.get(frame.jobId) || [])];
       for (const socket of sockets) {
-        if (!(await writeDaemonSocketFrame(socket, frame, ipcLimits))) subscribers.get(frame.jobId)?.delete(socket);
+        if (!(await sendFrame(socket, frame))) subscribers.get(frame.jobId)?.delete(socket);
       }
     }
 
@@ -276,7 +299,7 @@ export function createDaemonWorker({ toolName, paths }) {
           subscribers.get(jobId).add(socket);
           subscribedJobs.add(jobId);
           readJson(daemonJobPaths(paths, jobId).result, null).then((result) => {
-            if (result?.terminal) return writeDaemonSocketFrame(socket, result.terminal, ipcLimits);
+            if (result?.terminal) return sendFrame(socket, result.terminal);
             return processQueue();
           }).catch(() => socket.destroy());
         }
@@ -293,10 +316,19 @@ export function createDaemonWorker({ toolName, paths }) {
     const heartbeatTimer = setInterval(() => {
       writeStatus({ heartbeatAt: new Date().toISOString() }).catch(() => {});
     }, policy.heartbeatIntervalMs);
+    const journalTimer = setInterval(() => {
+      maintainJournal()
+        .then((journal) => writeStatus({ journal }))
+        .catch((error) => writeStatus({
+          lastError: { at: new Date().toISOString(), phase: "journal", message: error?.message || String(error) }
+        }));
+    }, policy.journalSweepIntervalMs || 5 * 60_000);
+    journalTimer.unref?.();
     const idleTimer = idleTimeoutMs > 0 ? setInterval(async () => {
       if (processing || exiting || Date.now() - lastActivity <= idleTimeoutMs) return;
       exiting = true;
       clearInterval(heartbeatTimer);
+      clearInterval(journalTimer);
       clearInterval(idleTimer);
       await beforeExit?.();
       await writeStatus({ state: "stopped", restartRequested: false, nextRestartAt: null, message: "Idle timeout reached" });

package/src/index.js

@@ -15,7 +15,7 @@ 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"]);
@@ -226,7 +226,35 @@ 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({
@@ -334,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");

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/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/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/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" });

package/test/pi-compaction.test.js

@@ -40,6 +40,7 @@ test("merges partial exclusive turn coordinator overrides with defaults", () =>
     enabled: true,
     backgroundQueueTtlMs: 30_000,
     interactiveQueueTtlMs: 0,
+    interactiveQuietMs: 2_000,
     maxQueued: 100
   });
 });