arisa 5.2.19 → 5.2.20

package/LOW-MEMORY.md

@@ -0,0 +1,37 @@
+# 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.
+
+## 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.
+
+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.20",
   "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/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/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,10 +8,8 @@ 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;
 
@@ -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({
@@ -224,6 +228,7 @@ async function runForeground() {
 
 async function main() {
   if (slaveCommand) {
+    const { runSlaveCli } = await import("./runtime/slave-cli.js");
     const result = await runSlaveCli({
       positionals: cli.positionals.slice(1),
       flags: cli.flags,
@@ -265,6 +270,7 @@ async function main() {
   }
 
   if (command === "tui") {
+    const { runTui } = await import("./runtime/tui.js");
     await runTui({ logger });
     return;
   }

package/src/platform/paths.js

@@ -46,10 +46,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/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/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-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/model-selection.test.js

@@ -197,7 +197,7 @@ test("builds and parses the speed picker", () => {
   assert.match(picker.replyMarkup.inline_keyboard[1][0].text, /^✓ 1\.5x$/);
   assert.deepEqual(parseSpeedPickerAction("speed:1.5"), { type: "speed", speed: 1.5 });
   assert.deepEqual(parseSpeedPickerAction("speed:1"), { type: "speed", speed: 1 });
-  assert.equal(parseSpeedPickerAction("speed:2"), null);
+  assert.equal(parseSpeedPickerAction("speed:3"), null);
 });
 
 test("closes the picker after selecting the already active model and effort", async () => {
@@ -350,7 +350,16 @@ test("maps supported model speeds to provider service tiers", () => {
   assert.equal(clampModelSpeed({ ...fastModel, id: "gpt-5.3" }, 1.5), 1);
   assert.equal(speedToServiceTier(1), "default");
   assert.equal(speedToServiceTier(1.5), "priority");
-  assert.throws(() => normalizeModelSpeed(2), /Invalid model speed/);
+  assert.equal(normalizeModelSpeed(2), 2);
+  assert.equal(speedToServiceTier(2), "priority");
+  const legacyConfig = { pi: { provider: "openai-codex", model: "gpt-6-astra", speed: 1.5 } };
+  assert.equal(resolveChatSpeed(legacyConfig, "legacy"), 2);
+  assert.equal(legacyConfig.pi.speed, 1.5);
+  assert.equal(clampModelSpeed({ ...fastModel, id: "gpt-6-astra" }, 1.5), 2);
+  assert.equal(clampModelSpeed({ ...fastModel, id: "gpt-6-astra" }, 2), 2);
+  assert.equal(clampModelSpeed(fastModel, 2), 1.5);
+  assert.deepEqual(parseSpeedPickerAction("speed:2"), { type: "speed", speed: 2 });
+  assert.throws(() => normalizeModelSpeed(3), /Invalid model speed/);
 });
 
 test("applies Pi speed to every provider request and updates it in place", async () => {

package/test/paths.test.js

@@ -9,6 +9,7 @@ import {
   chatsDir,
   createIpcSocketPath,
   getChatArtifactsDir,
+  getChatArtifactsDatabaseFile,
   getChatSessionSeedFile,
   getChatTelegramWorkspacesFile,
   getChatToolConfigPath,
@@ -31,6 +32,7 @@ test("keeps chat artifact paths scoped below the chat directory", () => {
   const artifactsDir = getChatArtifactsDir("chat-1");
 
   assert.equal(artifactsDir, path.join(chatsDir, "chat-1", "artifacts"));
+  assert.equal(getChatArtifactsDatabaseFile("chat-1"), path.join(chatsDir, "chat-1", "state", "artifacts.sqlite"));
 });
 
 test("keeps pending session seeds scoped below the chat state directory", () => {

package/test/pi-speed-integration.test.js

@@ -45,7 +45,7 @@ test("speed picker updates Astra in place, persists per topic, and closes unchan
     answerCallbackQuery: async (answer) => answers.push(answer)
   };
   await controls.showSpeedPicker(ctx);
-  assert.equal(replies[0][1]?.reply_markup.inline_keyboard[1][0].callback_data, "speed:1.5");
+  assert.equal(replies[0][1]?.reply_markup.inline_keyboard[1][0].callback_data, "speed:2");
   const handler = createTelegramModelCallbackHandler({
     ...controls, config,
     authorizeContext: async () => ({ ok: true }),
@@ -54,13 +54,14 @@ test("speed picker updates Astra in place, persists per topic, and closes unchan
   });
   ctx.callbackQuery = { data: "speed:1.5", message: { message_id: 456 } };
   await handler(ctx);
-  assert.deepEqual(updates, [["123:topic:7", 1.5]]);
-  assert.equal(resolveChatSpeed(writes[0], "123:topic:7"), 1.5);
+  assert.deepEqual(updates, [["123:topic:7", 2]]);
+  assert.equal(resolveChatSpeed(writes[0], "123:topic:7"), 2);
   assert.equal(resolveChatSpeed(config, "123:topic:8"), 1);
   assert.equal(resolveChatModelSelection(config, "123:topic:7").sessionRevision, 0);
+  ctx.callbackQuery.data = "speed:2";
   await handler(ctx);
   assert.equal(writes.length, 1);
-  assert.match(replies.at(-1)[2], /Already using speed 1.5x/);
+  assert.match(replies.at(-1)[2], /Already using speed 2.0x/);
   ctx.callbackQuery.data = "speed:1";
   await handler(ctx);
   assert.equal(resolveChatSpeed(config, "123:topic:7"), 1);
@@ -99,15 +100,15 @@ test("Pi SDK sends the selected speed in the actual Codex payload across turns",
     ...options, transport: "sse", maxRetries: 0
   }), 1);
   session.agent.streamFunction = controller.streamFn;
-  for (const speed of [1, 1.5, 1]) {
+  for (const speed of [1, 1.5, 2, 1]) {
     controller.setSpeed(speed);
     await session.prompt("Reply OK");
     const message = session.messages.at(-1);
     assert.equal(message.stopReason, "stop", message.errorMessage);
     assert.equal(requests.at(-1).model, model.id);
-    assert.equal(requests.at(-1).service_tier, speed === 1.5 ? "priority" : "default");
+    assert.equal(requests.at(-1).service_tier, speed > 1 ? "priority" : "default");
   }
-  assert.equal(requests.length, 3);
+  assert.equal(requests.length, 4);
 });
 
 test("speed control leaves unsupported provider payloads and hooks untouched", async () => {
@@ -148,7 +149,7 @@ test("Arisa creates and reuses Telegram sessions and opens its TUI with the inst
     try {
       assert.equal(context.session.model.id, "gpt-6-astra");
       assert.equal(context.session.agent.streamFunction, context.speedController.streamFn);
-      assert.equal(context.speedController.speed, 1.5);
+      assert.equal(context.speedController.speed, 2);
       await manager.setModelSpeed("123", 1);
       selectChatSpeed(config, "123", 1);
       const reused = await manager.getSessionContext("123", {});