arisa 5.2.19 → 5.2.21

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

@@ -0,0 +1,128 @@
+import { chmodSync, mkdirSync, readFileSync, closeSync, openSync } from "node:fs";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { tasksDatabaseFile, tasksFile } from "../../platform/paths.js";
+
+function createPrivateFile(file) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  try {
+    closeSync(openSync(file, "wx", 0o600));
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  chmodSync(file, 0o600);
+}
+
+function legacyTasks(file) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const tasks = JSON.parse(text);
+  if (!Array.isArray(tasks)) throw new Error("Legacy task storage must contain an array");
+  return tasks;
+}
+
+function taskValues(task) {
+  if (!task || typeof task.id !== "string" || !task.id || typeof task.status !== "string") {
+    throw new Error("Invalid task identity or status");
+  }
+  return [task.id, task.status, String(task.payload?.chatId ?? ""), task.kind ?? null,
+    Number.isFinite(Date.parse(task.runAt)) ? Date.parse(task.runAt) : null,
+    Number.isFinite(Date.parse(task.createdAt)) ? Date.parse(task.createdAt) : 0,
+    JSON.stringify(task)];
+}
+
+export function insertTask(db, task) {
+  db.prepare("INSERT INTO tasks (id, status, chat_id, kind, run_at, created_at, data) VALUES (?, ?, ?, ?, ?, ?, ?)")
+    .run(...taskValues(task));
+}
+
+export function transaction(db, operation) {
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const result = operation();
+    db.exec("COMMIT");
+    return result;
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+
+function initialize(db, legacyFile, migrate) {
+  const version = () => db.prepare("PRAGMA user_version").get().user_version;
+  if (version() === 1) return;
+  if (version() !== 0) throw new Error("Unsupported task database version");
+  transaction(db, () => {
+    if (version() !== 0) return;
+    db.exec(`CREATE TABLE tasks (
+      seq INTEGER PRIMARY KEY, id TEXT NOT NULL UNIQUE, status TEXT NOT NULL,
+      chat_id TEXT NOT NULL, kind TEXT, run_at INTEGER, created_at INTEGER NOT NULL, data TEXT NOT NULL
+    );
+    CREATE INDEX tasks_due ON tasks(run_at, created_at, id) WHERE status IN ('pending', 'blocked_auth');
+    CREATE INDEX tasks_chat ON tasks(chat_id, status);
+    CREATE INDEX tasks_status ON tasks(status);`);
+    for (const task of legacyTasks(legacyFile)) insertTask(db, migrate(task));
+    db.exec("PRAGMA user_version = 1");
+  });
+}
+
+// All work is synchronous inside a connection/transaction. No lock is held across
+// an await; separate processes use SQLite locking, not an in-process promise queue.
+export function withTaskDatabase(migrate, operation, {
+  databaseFile = tasksDatabaseFile, legacyFile = tasksFile
+} = {}) {
+  createPrivateFile(databaseFile);
+  const db = new DatabaseSync(databaseFile);
+  try {
+    db.exec("PRAGMA busy_timeout = 5000; PRAGMA cache_size = -1024; PRAGMA mmap_size = 0; PRAGMA synchronous = FULL");
+    initialize(db, legacyFile, migrate);
+    return operation(db);
+  } catch (error) {
+    throw new Error(`Task storage operation failed: ${databaseFile}`, { cause: error });
+  } finally {
+    db.close();
+  }
+}
+
+export function selectTasks(db, filter = {}) {
+  if (filter.empty) return [];
+  const conditions = [];
+  const values = [];
+  for (const [key, column] of [["id", "id"], ["chatId", "chat_id"], ["status", "status"], ["kind", "kind"]]) {
+    if (filter[key]) {
+      conditions.push(`${column} = ?`);
+      values.push(String(filter[key]));
+    }
+  }
+  let order = "seq";
+  let limit = "";
+  if (filter.due) {
+    conditions.push("status IN ('pending', 'blocked_auth')", "run_at <= ?");
+    values.push(filter.due.now);
+    order = "run_at, created_at, id";
+    limit = " LIMIT ?";
+    values.push(filter.due.limit);
+  }
+  return db.prepare(`SELECT data FROM tasks ${filter.due ? "INDEXED BY tasks_due" : ""} ${conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""} ORDER BY ${order}${limit}`)
+    .all(...values).map((row) => JSON.parse(row.data));
+}
+
+export function persistTaskChanges(db, before, tasks) {
+  const remaining = new Set(tasks.map((task) => task.id));
+  for (const id of before.keys()) {
+    if (!remaining.has(id)) db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+  }
+  for (const task of tasks) {
+    if (!before.has(task.id)) insertTask(db, task);
+    else if (before.get(task.id) !== JSON.stringify(task)) {
+      const [id, ...values] = taskValues(task);
+      db.prepare("UPDATE tasks SET status = ?, chat_id = ?, kind = ?, run_at = ?, created_at = ?, data = ? WHERE id = ?")
+        .run(...values, id);
+    }
+  }
+}

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

@@ -1,7 +1,5 @@
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
 import crypto from "node:crypto";
-import { tasksFile } from "../../platform/paths.js";
+import { withTaskDatabase, transaction, selectTasks, persistTaskChanges } from "./task-database.js";
 
 const DEFAULT_RETRY = Object.freeze({
   maxAttempts: 3,
@@ -13,43 +11,6 @@ const DEFAULT_RETRY = Object.freeze({
 const TERMINAL_STATUSES = new Set(["done", "failed", "outcome_uncertain"]);
 const TERMINAL_PAYLOAD_KEYS = ["chatId", "toolName", "resourceId", "artifactId"];
 
-const taskFileOperations = new Map();
-
-async function serializeTaskFileOperation(operation) {
-  const previous = taskFileOperations.get(tasksFile) || Promise.resolve();
-  const current = previous.catch(() => {}).then(operation);
-  taskFileOperations.set(tasksFile, current);
-  try {
-    return await current;
-  } finally {
-    if (taskFileOperations.get(tasksFile) === current) taskFileOperations.delete(tasksFile);
-  }
-}
-
-async function waitForTaskFileOperations() {
-  await (taskFileOperations.get(tasksFile) || Promise.resolve()).catch(() => {});
-}
-
-async function loadTasksFile() {
-  try {
-    const parsed = JSON.parse(await readFile(tasksFile, "utf8"));
-    return Array.isArray(parsed) ? parsed.map(migrateTask) : [];
-  } catch {
-    return [];
-  }
-}
-
-async function saveTasksFile(tasks) {
-  await mkdir(path.dirname(tasksFile), { recursive: true });
-  const temporaryFile = `${tasksFile}.${process.pid}.${crypto.randomUUID()}.tmp`;
-  try {
-    await writeFile(temporaryFile, `${JSON.stringify(tasks, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
-    await rename(temporaryFile, tasksFile);
-  } finally {
-    await rm(temporaryFile, { force: true }).catch(() => {});
-  }
-}
-
 function taskId() {
   return crypto.randomUUID();
 }
@@ -193,64 +154,51 @@ function failTask(task, error) {
 }
 
 export class TaskStore {
-  constructor() {
-    this.tasks = null;
+  constructor(storage = {}) {
+    this.storage = storage;
   }
 
   async init() {
-    if (!this.tasks) await this.reload();
+    this.read(() => undefined);
   }
 
-  async reload() {
-    await waitForTaskFileOperations();
-    this.tasks = await loadTasksFile();
+  read(operation) {
+    return withTaskDatabase(migrateTask, operation, this.storage);
   }
 
-  async mutate(operation) {
-    return serializeTaskFileOperation(async () => {
-      this.tasks = await loadTasksFile();
-      const { result, changed = true } = await operation(this.tasks);
-      if (changed) await saveTasksFile(this.tasks);
+  async mutate(operation, filter = {}) {
+    return this.read((db) => transaction(db, () => {
+      const tasks = selectTasks(db, filter);
+      const before = new Map(tasks.map((task) => [task.id, JSON.stringify(task)]));
+      const outcome = operation(tasks);
+      if (outcome?.then) throw new Error("Task mutations must be synchronous");
+      const { result, changed = true } = outcome;
+      if (changed) persistTaskChanges(db, before, tasks);
       return result;
-    });
-  }
-
-  async save() {
-    const tasks = structuredClone(this.tasks || []);
-    return serializeTaskFileOperation(async () => {
-      this.tasks = tasks;
-      await saveTasksFile(tasks);
-    });
+    }));
   }
 
   async add(task, defaults = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const normalized = normalizeTask(task, defaults);
       tasks.push(normalized);
       return { result: structuredClone(normalized) };
-    });
+    }, { empty: true });
   }
 
   async addMany(tasksToAdd = [], defaults = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const created = tasksToAdd.map((task) => normalizeTask(task, defaults));
       tasks.push(...created);
       return { result: structuredClone(created), changed: created.length > 0 };
-    });
+    }, { empty: true });
   }
 
   async claimDue(limit = 10) {
-    return this.mutate(async (tasks) => {
-      const now = Date.now();
-      const due = tasks
-        .filter((task) => ["pending", "blocked_auth"].includes(task.status)
-          && task.runAt
-          && !Number.isNaN(Date.parse(task.runAt))
-          && Date.parse(task.runAt) <= now)
-        .sort((left, right) => Date.parse(left.runAt) - Date.parse(right.runAt)
-          || Date.parse(left.createdAt || 0) - Date.parse(right.createdAt || 0)
-          || String(left.id).localeCompare(String(right.id)))
-        .slice(0, limit);
+    const now = Date.now();
+    if (!Number.isSafeInteger(limit) || limit < 0) throw new Error("Invalid task claim limit");
+    return this.mutate((tasks) => {
+      const due = tasks;
 
       const claimedAt = new Date(now).toISOString();
       for (const task of due) {
@@ -263,21 +211,21 @@ export class TaskStore {
       }
 
       return { result: structuredClone(due), changed: due.length > 0 };
-    });
+    }, { due: { now, limit } });
   }
 
   async markExecutionStarted(taskId) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       if (!task || task.status !== "running") return { result: null, changed: false };
       task.executionStartedAt = new Date().toISOString();
       task.updatedAt = task.executionStartedAt;
       return { result: structuredClone(task) };
-    });
+    }, { id: taskId });
   }
 
   async recoverInterrupted() {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const recovered = [];
       let compacted = false;
       const now = Date.now();
@@ -336,7 +284,7 @@ export class TaskStore {
   }
 
   async complete(taskId) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       if (!task) return { result: null, changed: false };
 
@@ -366,11 +314,11 @@ export class TaskStore {
       task.updatedAt = completedAt;
       compactTerminalTask(task);
       return { result: structuredClone(task) };
-    });
+    }, { id: taskId });
   }
 
   async blockAuth(taskId, error, resolution = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       if (!task) return { result: null, changed: false };
       const now = Date.now();
@@ -395,11 +343,11 @@ export class TaskStore {
       delete task.executionStartedAt;
       delete task.error;
       return { result: { ...structuredClone(task), authBlockedNew: !wasBlocked } };
-    });
+    }, { id: taskId });
   }
 
   async retryOrFail(taskId, error, { retryable = true, outcomeUncertain = false } = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       if (!task) return { result: null, changed: false };
       const message = error instanceof Error ? error.message : String(error);
@@ -465,45 +413,38 @@ export class TaskStore {
       delete task.claimedAt;
       delete task.executionStartedAt;
       return { result: structuredClone(task) };
-    });
+    }, { id: taskId });
   }
 
   async fail(taskId, error) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const task = tasks.find((item) => item.id === taskId);
       return task
         ? { result: failTask(task, error) }
         : { result: null, changed: false };
-    });
+    }, { id: taskId });
   }
 
   async list(filter = {}) {
-    await this.reload();
-    return this.tasks.filter((task) => {
-      if (filter.chatId && String(task.payload?.chatId) !== String(filter.chatId)) return false;
-      if (filter.status && task.status !== filter.status) return false;
-      if (filter.kind && task.kind !== filter.kind) return false;
-      return true;
-    }).map((task) => structuredClone(task));
+    return this.read((db) => selectTasks(db, filter));
   }
 
   async get(taskId) {
-    await this.reload();
-    const task = this.tasks.find((item) => item.id === taskId);
-    return task ? structuredClone(task) : null;
+    if (typeof taskId !== "string" || !taskId) return null;
+    return this.read((db) => selectTasks(db, { id: taskId })[0] || null);
   }
 
   async cancel(taskId) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const index = tasks.findIndex((item) => item.id === taskId);
       if (index === -1) return { result: null, changed: false };
       const [task] = tasks.splice(index, 1);
       return { result: structuredClone(task) };
-    });
+    }, { id: taskId });
   }
 
   async cancelAll(filter = {}) {
-    return this.mutate(async (tasks) => {
+    return this.mutate((tasks) => {
       const removed = [];
       const remaining = tasks.filter((task) => {
         if (filter.chatId && String(task.payload?.chatId) !== String(filter.chatId)) return true;
@@ -514,6 +455,6 @@ export class TaskStore {
       });
       tasks.splice(0, tasks.length, ...remaining);
       return { result: removed, changed: removed.length > 0 };
-    });
+    }, filter);
   }
 }

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