arisa 5.2.19 → 5.2.21

package/LOW-MEMORY.md

@@ -0,0 +1,49 @@
+# Low-memory operation
+
+Arisa can use swap to keep cold pages out of RAM. Swap occupancy alone does not indicate failure: sustained swap-in/out, memory PSI, disk wait, worker restarts and operation latency are the useful signals. Do not run `swapoff` to clear swap on a constrained host, or increase every Node heap to mask an allocation problem.
+
+## Artifact index
+
+The artifact store uses Node's bundled SQLite support (Node >=22.19) and the chat-scoped `getChatArtifactsDatabaseFile(chatId)` path helper. `getChatArtifactsIndexFile(chatId)` still identifies the legacy JSON file, not the live database. Tools must access artifacts through Arisa IPC, not parse storage files.
+
+- Each operation opens its database, uses a 1 MiB page cache with mmap disabled, then closes it. There is no resident history cache per chat.
+- Writes insert one artifact. ID lookups and recent-item queries use indexes; history size does not determine their JS heap consumption.
+- `listRecent` accepts integer limits from 0 to 1000; 0 returns no items. Results are read incrementally and rejected if their combined serialized size exceeds 16 MiB; callers can reduce the limit or retrieve individual IDs. Memory still depends on individual record size.
+- SQLite serializes writes across processes. FULL synchronous commits and rollback journaling preserve atomic writes without accumulating an unbounded WAL.
+- The CLI loads agent, bootstrap, slave and TUI modules only in the branches that need them. The persistent service supervisor does not load the worker's agent dependencies.
+
+### Migration and backups
+
+First access to an uninitialized database streams the legacy JSON array one object at a time into a single transaction. Artifact IDs, scope, all fields and insertion order are preserved. Duplicate IDs, invalid chat identities or malformed/truncated input abort the whole migration. A failed migration leaves the original unchanged and can be retried after repairing the input. Memory scales with the largest individual legacy record, not total history size.
+
+A committed database has schema version 1. Subsequent operations do not read or import the legacy JSON again. The original JSON is retained unchanged as a pre-migration backup, but **does not contain later writes**. Never delete a live database assuming that the legacy file is current.
+
+Back up the SQLite database with SQLite's backup API, or stop all writers and copy it along with any journal files. Preserve artifact files separately. A rollback to an older JSON-only core requires stopping all writers, backing up the database, and streaming `SELECT data FROM artifacts ORDER BY seq` into a new JSON array. Fsync and atomically replace the legacy index only after export succeeds. Do not simply revert the code and resume writes to the old JSON snapshot.
+
+## Task storage
+
+`tasksDatabaseFile` identifies the live global scheduler database (`tasks.sqlite`); `tasksFile` is now only the legacy `tasks.json` migration source. Tools must use task IPC rather than read either file directly.
+
+- Due claims use a partial index for pending/authentication-blocked tasks. ID mutations only load and update the selected row; an idle poll does not parse terminal history or rewrite the queue.
+- Claim/read/update occurs in one synchronous `BEGIN IMMEDIATE` transaction, including across processes. Connections close after each operation, with a 1 MiB page cache, mmap disabled, FULL synchronous commits and a 5-second lock timeout. No asynchronous work runs while holding the write lock.
+- First access imports the legacy array atomically and records schema version 1. This one-time import still loads the legacy array in memory. Startup recovery and unbounded history listing also remain proportional to history size; they are not the per-second hot path.
+- Missing legacy input means a fresh database. Malformed input, duplicate IDs, invalid identities, unsupported schemas and unreadable databases fail explicitly instead of silently becoming an empty queue.
+- The legacy file stays unchanged and is never reimported after a successful migration. Routes, auth blocks, retry state and interrupted-execution semantics are preserved. Do not run old JSON-writing workers alongside a migrated scheduler.
+
+Back up using SQLite's backup API or stop all writers before copying the database and any journal. To downgrade, stop all writers and export `SELECT data FROM tasks ORDER BY seq` into a new UTF-8 JSON array, fsync and atomically replace `tasks.json` before starting the old core. The retained legacy JSON does not include subsequent changes and is not a safe downgrade by itself.
+
+## Daemons
+
+Keep external ingress daemons running. Request-driven tools should use `autoStart: false` in both their manifest and runtime registration, start through the shared runtime when invoked, and stop when idle. Otherwise the supervisor will repeatedly restart a daemon that deliberately stopped for inactivity. Do not disable ingress or drop sessions to improve a memory benchmark.
+
+## Verification
+
+Run the test suite serially on 1 GiB hosts:
+
+```sh
+node --test --test-concurrency=1
+```
+
+`test/artifact-index-memory.test.js` migrates a 100 MiB index and runs 300 subsequent operations in a child with a 48 MiB V8 heap. Migration tests cover UTF-8 chunk boundaries, escaping, corruption, rollback/retry, stable IDs, ordering and concurrent writers in separate processes. `test/cli-memory.test.js` runs the status command with a 24 MiB heap. `test/task-database.test.js` checks atomic migration, corruption, separate-process claims and 200 idle polls under a 32 MiB heap with approximately 60 MB of terminal history; idle polling must not rewrite the database.
+
+After deployment, check a real scheduled tool result, PID continuity, daemon health, `free -h`, `vmstat 1`, and `/proc/pressure/memory`. Short observations cannot establish long-term stability or guarantee that every browser workload fits this host.

package/README.md

@@ -102,7 +102,8 @@ Global:
 
 Per chat (`~/.arisa/chats/<chatId>/`):
 - artifact files are stored under `artifacts/`
-- the artifact index is stored in `state/artifacts.json`
+- the artifact index is stored in `state/artifacts.sqlite`; the legacy `state/artifacts.json` is imported once, incrementally, and retained unchanged as a migration backup
+- artifact reads and writes use indexed SQLite operations rather than loading the chat's complete history into memory; see [low-memory operation and migration](LOW-MEMORY.md)
 - Pi sessions live under `state/pi-sessions/<revision>/`
 - chat-scoped tool config overrides live in `config/tools/<tool>/config.js`
 - chat-scoped daemon infrastructure lives in `state/tools/<tool>/daemon/`; persistent tool data stays beside it

package/package.json

@@ -1,17 +1,12 @@
 {
   "name": "arisa",
-  "version": "5.2.19",
+  "version": "5.2.21",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",
   "bin": {
     "arisa": "bin/arisa.js"
   },
-  "scripts": {
-    "start": "node src/index.js",
-    "bootstrap": "node src/index.js --bootstrap",
-    "test": "node --test"
-  },
   "keywords": [
     "telegram",
     "pi-agent",
@@ -44,10 +39,14 @@
     "url": "https://github.com/clasen/Arisa/issues"
   },
   "homepage": "https://arisa.sh",
-  "packageManager": "pnpm@11.3.0+sha512.2c403d6594527287672b1f7056343a1f7c3634036a67ffabfcc2b3d7595d843768f8787148d1b57cf7956c90606bbd192857c363af19e96d2d0ec9ec5741d215",
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.85.1",
     "@sinclair/typebox": "^0.34.41",
     "grammy": "^1.42.0"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "bootstrap": "node src/index.js --bootstrap",
+    "test": "node --test"
   }
-}
+}

package/src/core/agent/agent-turn-coordinator.js

@@ -30,6 +30,12 @@ export class AgentTurnCoordinator {
     this.expired = 0;
     this.maxObservedQueue = 0;
     this.totalWaitMs = 0;
+    this.lastInteractiveActivityAt = 0;
+    this.backgroundWakeTimer = null;
+    this.priorityStats = {
+      interactive: { queued: 0, started: 0, completed: 0, expired: 0, totalWaitMs: 0, maxWaitMs: 0 },
+      background: { queued: 0, started: 0, completed: 0, expired: 0, totalWaitMs: 0, maxWaitMs: 0 }
+    };
     this.setConfig(config);
   }
 
@@ -38,6 +44,7 @@ export class AgentTurnCoordinator {
       enabled: config.enabled !== false,
       backgroundQueueTtlMs: positiveInteger(config.backgroundQueueTtlMs, 10 * 60_000, 60 * 60_000),
       interactiveQueueTtlMs: positiveInteger(config.interactiveQueueTtlMs, 0, 60 * 60_000),
+      interactiveQuietMs: positiveInteger(config.interactiveQuietMs, 0, 60_000),
       maxQueued: Math.max(1, positiveInteger(config.maxQueued, 100, 1_000))
     };
   }
@@ -53,14 +60,24 @@ export class AgentTurnCoordinator {
   }
 
   diagnostic() {
+    const priorities = Object.fromEntries(Object.entries(this.priorityStats).map(([name, stats]) => [name, {
+      queued: stats.queued,
+      started: stats.started,
+      completed: stats.completed,
+      expired: stats.expired,
+      averageWaitMs: stats.started ? Math.round(stats.totalWaitMs / stats.started) : 0,
+      maxWaitMs: stats.maxWaitMs
+    }]));
     return {
       enabled: this.config.enabled,
       active: this.describeActive(this.active),
       queued: this.queue.length,
+      queuedInteractive: this.queue.filter((entry) => entry.priorityName === "interactive").length,
       maxObservedQueue: this.maxObservedQueue,
       completed: this.completed,
       expired: this.expired,
-      averageWaitMs: this.completed ? Math.round(this.totalWaitMs / this.completed) : 0
+      averageWaitMs: this.completed ? Math.round(this.totalWaitMs / this.completed) : 0,
+      priorities
     };
   }
 
@@ -69,14 +86,42 @@ export class AgentTurnCoordinator {
     if (index >= 0) this.queue.splice(index, 1);
   }
 
+  clearBackgroundWake() {
+    if (!this.backgroundWakeTimer) return;
+    clearTimeout(this.backgroundWakeTimer);
+    this.backgroundWakeTimer = null;
+  }
+
+  deferBackground(delayMs) {
+    if (this.backgroundWakeTimer) return;
+    this.backgroundWakeTimer = setTimeout(() => {
+      this.backgroundWakeTimer = null;
+      this.next();
+    }, delayMs);
+    this.backgroundWakeTimer.unref?.();
+  }
+
   next() {
     if (this.active || this.closed || !this.queue.length) return;
     this.queue.sort((left, right) => right.priority - left.priority || left.sequence - right.sequence);
-    const entry = this.queue.shift();
+    const entry = this.queue[0];
+    if (entry.priorityName === "background") {
+      const quietRemainingMs = this.lastInteractiveActivityAt + this.config.interactiveQuietMs - this.now();
+      if (quietRemainingMs > 0) {
+        this.deferBackground(quietRemainingMs);
+        return;
+      }
+    }
+    this.clearBackgroundWake();
+    this.queue.shift();
     if (entry.timer) clearTimeout(entry.timer);
     entry.startedAt = new Date(this.now()).toISOString();
     this.active = entry;
     const waitMs = Math.max(0, this.now() - entry.queuedAt);
+    const stats = this.priorityStats[entry.priorityName];
+    stats.started += 1;
+    stats.totalWaitMs += waitMs;
+    stats.maxWaitMs = Math.max(stats.maxWaitMs, waitMs);
     this.totalWaitMs += waitMs;
     if (waitMs > 0) this.logger?.log("agent", `${entry.label} waited ${waitMs}ms for exclusive agent execution`);
     let released = false;
@@ -85,6 +130,8 @@ export class AgentTurnCoordinator {
       released = true;
       if (this.active === entry) this.active = null;
       this.completed += 1;
+      stats.completed += 1;
+      if (entry.priorityName === "interactive") this.lastInteractiveActivityAt = this.now();
       queueMicrotask(() => this.next());
     });
   }
@@ -96,11 +143,12 @@ export class AgentTurnCoordinator {
       return Promise.reject(Object.assign(new Error("Agent turn queue is full."), { code: "AGENT_TURN_QUEUE_FULL", retryable: true }));
     }
     const priority = normalizedPriority(priorityName);
+    const normalizedPriorityName = priorityName === "interactive" ? "interactive" : "background";
     const ttlMs = this.queueTtlMs(priorityName, queueTtlMs);
     return new Promise((resolve, reject) => {
       const entry = {
         label: String(label || "Agent turn").slice(0, 160),
-        priorityName: priorityName === "interactive" ? "interactive" : "background",
+        priorityName: normalizedPriorityName,
         priority,
         sequence: this.sequence += 1,
         queuedAt: this.now(),
@@ -114,11 +162,18 @@ export class AgentTurnCoordinator {
           if (this.active === entry) return;
           this.remove(entry);
           this.expired += 1;
+          this.priorityStats[entry.priorityName].expired += 1;
           reject(queueExpiredError(entry.label));
+          queueMicrotask(() => this.next());
         }, ttlMs);
         entry.timer.unref?.();
       }
       this.queue.push(entry);
+      this.priorityStats[entry.priorityName].queued += 1;
+      if (entry.priorityName === "interactive") {
+        this.lastInteractiveActivityAt = this.now();
+        this.clearBackgroundWake();
+      }
       this.maxObservedQueue = Math.max(this.maxObservedQueue, this.queue.length);
       this.next();
     });
@@ -135,6 +190,7 @@ export class AgentTurnCoordinator {
 
   close() {
     this.closed = true;
+    this.clearBackgroundWake();
     for (const entry of this.queue.splice(0)) {
       if (entry.timer) clearTimeout(entry.timer);
       entry.reject(Object.assign(new Error("Agent turn coordinator closed before execution."), { retryable: true }));

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

@@ -1,4 +1,4 @@
-import { normalizeModelSpeed } from "./model-speed.js";
+import { modelFastSpeed, normalizeModelSpeed } from "./model-speed.js";
 
 function chatKey(chatId) {
   return String(chatId);
@@ -49,9 +49,10 @@ export function resolveChatThinkingLevel(config, chatId) {
 }
 
 export function resolveChatSpeed(config, chatId) {
-  const speed = resolveChatModelSelection(config, chatId).speed;
+  const { speed, model } = resolveChatModelSelection(config, chatId);
   if (speed === undefined) throw new Error("Model speed is not configured for the active runtime");
-  return speed;
+  // Preserve legacy fast selections while displaying the model-specific multiplier.
+  return speed > 1 ? modelFastSpeed(model) : speed;
 }
 
 export function selectChatModel(config, chatId, model, { thinkingLevel, speed } = {}) {

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

@@ -1,4 +1,4 @@
-export const MODEL_SPEEDS = Object.freeze([1, 1.5]);
+export const MODEL_SPEEDS = Object.freeze([1, 1.5, 2]);
 
 export function normalizeModelSpeed(speed) {
   const value = Number(speed);
@@ -21,13 +21,21 @@ export function modelSupportsSpeed(model) {
     );
 }
 
+export function modelFastSpeed(modelId) {
+  return modelId === "gpt-6-astra" ? 2 : 1.5;
+}
+
+export function listModelSpeeds(model) {
+  return modelSupportsSpeed(model) ? [1, modelFastSpeed(model.id)] : [1];
+}
+
 export function clampModelSpeed(model, speed) {
   const normalized = normalizeModelSpeed(speed);
-  return normalized === 1.5 && !modelSupportsSpeed(model) ? 1 : normalized;
+  return normalized > 1 && modelSupportsSpeed(model) ? modelFastSpeed(model.id) : 1;
 }
 
 export function speedToServiceTier(speed) {
-  return normalizeModelSpeed(speed) === 1.5 ? "priority" : "default";
+  return normalizeModelSpeed(speed) > 1 ? "priority" : "default";
 }
 
 export function createModelSpeedController(streamFn, initialSpeed) {

package/src/core/artifacts/artifact-index.js

@@ -0,0 +1,107 @@
+import { mkdir, open } from "node:fs/promises";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { readLegacyArtifacts } from "./legacy-artifact-reader.js";
+
+const operations = new Map();
+
+async function serialize(file, operation) {
+  const previous = operations.get(file) || Promise.resolve();
+  const current = previous.catch(() => {}).then(operation);
+  operations.set(file, current);
+  try {
+    return await current;
+  } finally {
+    if (operations.get(file) === current) operations.delete(file);
+  }
+}
+
+async function createPrivateFile(file) {
+  await mkdir(path.dirname(file), { recursive: true });
+  try {
+    const handle = await open(file, "wx", 0o600);
+    await handle.close();
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+}
+
+function insertArtifact(db, artifact) {
+  db.prepare("INSERT INTO artifacts (id, data) VALUES (?, ?)")
+    .run(artifact.id, JSON.stringify(artifact));
+}
+
+async function importLegacy(db, legacyFile, chatId) {
+  const insert = db.prepare("INSERT INTO artifacts (id, data) VALUES (?, ?)");
+  try {
+    for await (const artifact of readLegacyArtifacts(legacyFile)) {
+      if (!artifact || typeof artifact.id !== "string" || !artifact.id
+        || String(artifact.chatId) !== chatId) {
+        throw new Error("Invalid artifact identity or chat scope");
+      }
+      insert.run(artifact.id, JSON.stringify(artifact));
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw new Error(`Artifact index is unreadable: ${legacyFile}`, { cause: error });
+    }
+  }
+}
+
+async function initialize(db, legacyFile, chatId) {
+  const version = () => db.prepare("PRAGMA user_version").get().user_version;
+  if (version() === 1) return;
+  if (version() !== 0) throw new Error("Unsupported artifact database version");
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    // Another process may have completed migration while this connection waited.
+    if (version() === 0) {
+      db.exec("CREATE TABLE artifacts (seq INTEGER PRIMARY KEY, id TEXT NOT NULL UNIQUE, data TEXT NOT NULL)");
+      await importLegacy(db, legacyFile, chatId);
+      db.exec("PRAGMA user_version = 1");
+    }
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+
+// Open only for the operation: no per-chat resident history or idle DB cache.
+// SQLite transactions coordinate separate Arisa processes as well as store instances.
+export function withArtifactIndex({ databaseFile, legacyFile, chatId }, operation) {
+  return serialize(databaseFile, async () => {
+    await createPrivateFile(databaseFile);
+    const db = new DatabaseSync(databaseFile);
+    try {
+      db.exec("PRAGMA busy_timeout = 30000; PRAGMA cache_size = -1024; PRAGMA mmap_size = 0; PRAGMA synchronous = FULL");
+      await initialize(db, legacyFile, chatId);
+      return await operation(db);
+    } finally {
+      db.close();
+    }
+  });
+}
+
+export function appendArtifact(db, artifact) {
+  insertArtifact(db, artifact);
+  return artifact;
+}
+
+export function getArtifact(db, id) {
+  const row = db.prepare("SELECT data FROM artifacts WHERE id = ?").get(id);
+  return row ? JSON.parse(row.data) : null;
+}
+
+export function listRecentArtifacts(db, limit) {
+  const artifacts = [];
+  let bytes = 0;
+  for (const row of db.prepare("SELECT data FROM artifacts ORDER BY seq DESC LIMIT ?").iterate(limit)) {
+    bytes += Buffer.byteLength(row.data, "utf8");
+    if (bytes > 16 * 1024 * 1024) {
+      throw new RangeError("Recent artifacts exceed 16 MiB; request a smaller limit or retrieve individual IDs");
+    }
+    artifacts.push(JSON.parse(row.data));
+  }
+  return artifacts;
+}

package/src/core/artifacts/artifact-store.js

@@ -1,10 +1,10 @@
-import { copyFile, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
-import { getChatArtifactsDir, getChatArtifactsIndexFile } from "../../platform/paths.js";
+import { getChatArtifactsDir, getChatArtifactsIndexFile, getChatArtifactsDatabaseFile } from "../../platform/paths.js";
+import { withArtifactIndex, appendArtifact, getArtifact, listRecentArtifacts } from "./artifact-index.js";
 
 const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf]);
-const indexOperations = new Map();
 
 function id() {
   return crypto.randomUUID();
@@ -43,94 +43,27 @@ 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);
     this.rootDir = getChatArtifactsDir(this.chatId);
-    this.indexFile = getChatArtifactsIndexFile(this.chatId);
-    this.items = null;
-  }
-
-  async reload() {
-    try {
-      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 });
-    }
+    this.index = {
+      chatId: this.chatId,
+      legacyFile: getChatArtifactsIndexFile(this.chatId),
+      databaseFile: getChatArtifactsDatabaseFile(this.chatId)
+    };
   }
 
   async init() {
     await mkdir(this.rootDir, { recursive: true });
-    if (!this.items) await this.reload();
+    await withArtifactIndex(this.index, () => {});
   }
 
   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;
-    });
+    return withArtifactIndex(this.index, (db) => appendArtifact(db, artifact));
   }
 
   async createText({ text, mimeType = "text/plain", source, metadata = {} }) {
-    await this.init();
-    await this.reload();
     const artifact = {
       id: id(),
       chatId: this.chatId,
@@ -146,7 +79,6 @@ class ChatArtifactStore {
 
   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 });
@@ -188,15 +120,14 @@ class ChatArtifactStore {
   }
 
   async get(artifactId) {
-    await this.init();
-    const items = await this.readIndex();
-    return items.find((item) => item.id === artifactId) || null;
+    return withArtifactIndex(this.index, (db) => getArtifact(db, artifactId));
   }
 
   async listRecent(limit = 20) {
-    await this.init();
-    const items = await this.readIndex();
-    return [...items].slice(-limit).reverse();
+    if (!Number.isSafeInteger(limit) || limit < 0 || limit > 1000) {
+      throw new RangeError("Artifact list limit must be an integer between 0 and 1000");
+    }
+    return withArtifactIndex(this.index, (db) => listRecentArtifacts(db, limit));
   }
 }
 

package/src/core/artifacts/legacy-artifact-reader.js

@@ -0,0 +1,46 @@
+import { createReadStream } from "node:fs";
+
+// The legacy format is a JSON array of objects. Retain only one object's bytes,
+// not the complete index. JSON.parse validates each object's JSON grammar.
+export async function* readLegacyArtifacts(file, { highWaterMark = 64 * 1024 } = {}) {
+  const stream = createReadStream(file, { encoding: "utf8", highWaterMark });
+  let state = "array";
+  let depth = 0;
+  let quoted = false;
+  let escaped = false;
+  let parts = [];
+  for await (const chunk of stream) {
+    let start = depth ? 0 : -1;
+    for (let i = 0; i < chunk.length; i++) {
+      const char = chunk[i];
+      if (depth) {
+        if (quoted) {
+          if (escaped) escaped = false;
+          else if (char === "\\") escaped = true;
+          else if (char === '"') quoted = false;
+        } else if (char === '"') quoted = true;
+        else if (char === "{" || char === "[") depth++;
+        else if (char === "}" || char === "]") depth--;
+        if (!depth) {
+          parts.push(chunk.slice(start, i + 1));
+          const value = JSON.parse(parts.join(""));
+          parts = [];
+          start = -1;
+          state = "separator";
+          yield value;
+        }
+        continue;
+      }
+      if (char === " " || char === "\n" || char === "\r" || char === "\t") continue;
+      if (state === "array" && char === "[") state = "first";
+      else if ((state === "first" || state === "separator") && char === "]") state = "done";
+      else if (state === "separator" && char === ",") state = "value";
+      else if ((state === "first" || state === "value") && char === "{") {
+        depth = 1;
+        start = i;
+      } else throw new Error("Invalid legacy artifact array");
+    }
+    if (start >= 0) parts.push(chunk.slice(start));
+  }
+  if (state !== "done" || depth) throw new Error("Truncated legacy artifact array");
+}

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

@@ -12,6 +12,9 @@ export const daemonConfigDefaults = Object.freeze({
   startupTimeoutMs: 120_000,
   stopTimeoutMs: 3_000,
   queuePollIntervalMs: 250,
+  journalRetentionMs: 24 * 60 * 60_000,
+  journalMaxCompleted: 2_048,
+  journalSweepIntervalMs: 5 * 60_000,
   streamBufferBytes: 1_048_576,
   ipcFrameBytes: 1_048_576
 });
@@ -94,6 +97,7 @@ export const piConfigDefaults = Object.freeze({
     enabled: true,
     backgroundQueueTtlMs: 10 * 60_000,
     interactiveQueueTtlMs: 0,
+    interactiveQuietMs: 2_000,
     maxQueued: 100
   }),
   compaction: Object.freeze({