arisa 5.2.19 → 5.2.21

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-compaction.test.js

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

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

package/test/task-database.test.js

@@ -0,0 +1,130 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import test from "node:test";
+import { TaskStore } from "../src/core/tasks/task-store.js";
+
+const execute = promisify(execFile);
+
+async function fixture(t) {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "arisa-task-db-"));
+  t.after(() => rm(dir, { recursive: true, force: true }));
+  const storage = { databaseFile: path.join(dir, "tasks.sqlite"), legacyFile: path.join(dir, "tasks.json") };
+  return { storage, store: new TaskStore(storage) };
+}
+
+function causes(error) {
+  return `${error.message} ${error.cause ? causes(error.cause) : ""}`;
+}
+
+test("task migration is atomic, retains the legacy source and does not reimport it", async (t) => {
+  const { storage, store } = await fixture(t);
+  const text = JSON.stringify([
+    { id: "old", status: "blocked_auth", kind: "agent_task", payload: { chatId: "owner", prompt: "private", telegramContext: { transportChatId: -100, messageThreadId: 87 } }, authBlock: { retryAfterSeconds: 3600 } }
+  ]);
+  await writeFile(storage.legacyFile, text);
+  await store.init();
+  assert.equal(await readFile(storage.legacyFile, "utf8"), text);
+  const task = await store.get("old");
+  assert.equal(task.payload.prompt, "private");
+  assert.equal(task.route.destination.threadId, 87);
+  assert.equal(task.authBlock.retryAfterSeconds, 3600);
+  if (process.platform !== "win32") assert.equal((await stat(storage.databaseFile)).mode & 0o777, 0o600);
+  await store.cancel("old");
+  await writeFile(storage.legacyFile, "broken obsolete source");
+  assert.deepEqual(await new TaskStore(storage).list(), []);
+});
+
+test("bad legacy task storage fails explicitly and rolls back partial migration", async (t) => {
+  const { storage, store } = await fixture(t);
+  for (const text of ["{broken", "{}", '[{"id":"one","status":"pending"},{"id":"one","status":"pending"}]', '[{"id":"one","status":"pending"},{}]']) {
+    await writeFile(storage.legacyFile, text);
+    await assert.rejects(store.init(), /Task storage operation failed/);
+    assert.equal(await readFile(storage.legacyFile, "utf8"), text);
+    const db = new DatabaseSync(storage.databaseFile);
+    try {
+      assert.equal(db.prepare("PRAGMA user_version").get().user_version, 0);
+      assert.equal(db.prepare("SELECT count(*) AS n FROM sqlite_master WHERE name = 'tasks'").get().n, 0);
+    } finally { db.close(); }
+  }
+  await writeFile(storage.legacyFile, "[]");
+  await store.add({ id: "fixed", kind: "agent_task" });
+  assert.equal((await store.list()).length, 1);
+});
+
+test("SQLite corruption and unsupported schemas do not silently fall back to JSON", async (t) => {
+  const { storage, store } = await fixture(t);
+  await writeFile(storage.databaseFile, "not a sqlite database");
+  await assert.rejects(store.list(), /Task storage operation failed/);
+  await rm(storage.databaseFile);
+  await store.init();
+  const db = new DatabaseSync(storage.databaseFile);
+  db.exec("PRAGMA user_version = 999");
+  db.close();
+  await assert.rejects(store.list(), (error) => /Unsupported task database version/.test(causes(error)));
+});
+
+test("task writes roll back together and unrelated history is not parsed on the claim path", async (t) => {
+  const { storage, store } = await fixture(t);
+  await store.add({ id: "history", kind: "agent_task", status: "done" });
+  await assert.rejects(store.addMany([{ id: "duplicate" }, { id: "duplicate" }]));
+  assert.equal(await store.get("duplicate"), null);
+  await store.add({ id: "active", kind: "agent_task", runAt: new Date(0).toISOString() });
+  const db = new DatabaseSync(storage.databaseFile);
+  db.prepare("UPDATE tasks SET data = ? WHERE id = ?").run("invalid JSON deliberately outside the hot path", "history");
+  const plan = db.prepare("EXPLAIN QUERY PLAN SELECT data FROM tasks INDEXED BY tasks_due WHERE status IN ('pending','blocked_auth') AND run_at <= ? ORDER BY run_at, created_at, id LIMIT ?").all(Date.now(), 10);
+  assert.ok(plan.some((row) => row.detail.includes("tasks_due")));
+  db.close();
+  assert.deepEqual((await store.claimDue()).map((task) => task.id), ["active"]);
+  assert.equal((await store.complete("active")).status, "done");
+  await assert.rejects(store.get("history"), /Task storage operation failed/);
+});
+
+test("idle task polling stays within a 32 MiB heap with a large terminal history and does not rewrite it", async (t) => {
+  const { storage, store } = await fixture(t);
+  await store.init();
+  const db = new DatabaseSync(storage.databaseFile);
+  try {
+    db.exec("BEGIN");
+    const insert = db.prepare("INSERT INTO tasks (id, status, chat_id, created_at, data) VALUES (?, 'done', 'owner', 0, ?)");
+    for (let i = 0; i < 6000; i++) {
+      insert.run(`history-${i}`, JSON.stringify({ id: `history-${i}`, status: "done", error: "x".repeat(10000) }));
+    }
+    db.exec("COMMIT");
+  } finally { db.close(); }
+  const before = await stat(storage.databaseFile);
+  const moduleUrl = new URL("../src/core/tasks/task-store.js", import.meta.url).href;
+  const { stdout } = await execute(process.execPath, ["--max-old-space-size=32", "--input-type=module", "-e", `
+    import assert from 'node:assert/strict';
+    import { TaskStore } from ${JSON.stringify(moduleUrl)};
+    const store = new TaskStore(${JSON.stringify(storage)});
+    for (let i = 0; i < 200; i++) assert.deepEqual(await store.claimDue(), []);
+    console.log('ok');
+  `], { timeout: 30000 });
+  assert.equal(stdout.trim(), "ok");
+  const after = await stat(storage.databaseFile);
+  assert.equal(after.size, before.size);
+  assert.equal(after.mtimeMs, before.mtimeMs);
+});
+
+test("separate processes cannot claim the same task or overwrite concurrent additions", async (t) => {
+  const { storage, store } = await fixture(t);
+  await store.addMany(Array.from({ length: 24 }, (_, i) => ({ id: `due-${i}`, kind: "agent_task", runAt: new Date(0).toISOString() })));
+  const moduleUrl = new URL("../src/core/tasks/task-store.js", import.meta.url).href;
+  const workers = await Promise.all(Array.from({ length: 4 }, (_, i) => execute(process.execPath, ["--input-type=module", "-e", `
+    import { TaskStore } from ${JSON.stringify(moduleUrl)};
+    const store = new TaskStore(${JSON.stringify(storage)});
+    const claimed = await store.claimDue(8);
+    await store.add({ id: 'worker-${i}', kind: 'agent_task', runAt: new Date(Date.now()+60000).toISOString() });
+    console.log(JSON.stringify(claimed.map(t => t.id)));
+  `], { timeout: 15000 })));
+  const claimed = workers.flatMap(({ stdout }) => JSON.parse(stdout));
+  assert.equal(claimed.length, 24);
+  assert.equal(new Set(claimed).size, 24);
+  assert.equal((await store.list()).length, 28);
+  assert.equal((await store.list({ status: "running" })).length, 24);
+});

package/test/task-store.test.js

@@ -144,8 +144,10 @@ test("persists auth blocks, claims only due probes, and clears the block after s
   assert.equal(blocked.authBlock.toolName, "checker");
   assert.deepEqual(await store.claimDue(), []);
 
-  store.tasks.find((task) => task.id === "auth-poll").runAt = new Date(Date.now() - 1000).toISOString();
-  await store.save();
+  await store.mutate((tasks) => {
+    tasks[0].runAt = new Date(Date.now() - 1000).toISOString();
+    return { result: null };
+  }, { id: "auth-poll" });
   const [probe] = await store.claimDue();
   assert.equal(probe.status, "running");
   assert.ok(probe.authBlock);
@@ -248,7 +250,8 @@ test("startup recovery compacts historical terminal tasks without changing activ
 
   const store = new TaskStore();
   assert.deepEqual(await store.recoverInterrupted(), []);
-  const persisted = JSON.parse(await readFile(tasksFile, "utf8"));
+  const persisted = await new TaskStore().list();
+  assert.equal(JSON.parse(await readFile(tasksFile, "utf8"))[0].payload.prompt, "obsolete prompt");
   const historical = persisted.find((task) => task.id === "historical-done");
   const active = persisted.find((task) => task.id === "active-pending");
 
@@ -278,8 +281,10 @@ test("backs off known failures and fails after the attempt limit", async () => {
   assert.ok(Date.parse(retrying.runAt) > Date.now());
 
   retrying.runAt = runAt;
-  store.tasks.find((task) => task.id === "retrying").runAt = runAt;
-  await store.save();
+  await store.mutate((tasks) => {
+    tasks[0].runAt = runAt;
+    return { result: null };
+  }, { id: "retrying" });
   await store.claimDue();
   const failed = await store.retryOrFail("retrying", "still broken");
   assert.equal(failed.status, "failed");

package/test/telegram-task-dispatcher.test.js

@@ -110,7 +110,6 @@ test("runs poll tools headlessly and confirms their result", async () => {
   });
 
   assert.deepEqual(calls, [
-    ["runTurn", { priority: "background", label: "poll tool checker" }],
     ["runTool", { name: "checker", request: { args: { cursor: "4" } }, chatId: 123 }],
     ["complete", "poll-1"]
   ]);
@@ -194,8 +193,7 @@ test("probes a blocked agent task before starting another reasoning turn", async
     payload: { chatId: 123, prompt: "run harvest" }
   });
 
-  assert.deepEqual(calls[0], ["runTurn", { priority: "background", label: "authentication probe creator-scout" }]);
-  assert.deepEqual(calls[1], ["runTool", {
+  assert.deepEqual(calls[0], ["runTool", {
     name: "creator-scout",
     request: { args: { action: "status" } },
     chatId: 123
@@ -335,9 +333,8 @@ test("due-task dispatch retries one failure without blocking another task", asyn
 
   await dispatcher.dispatchDueTasks();
 
-  assert.deepEqual(calls.slice(0, 3), [
+  assert.deepEqual(calls.slice(0, 2), [
     ["claimDue", 10],
-    ["runTurn", { priority: "background", label: "poll tool checker" }],
     ["runTool", { name: "checker", request: { args: {} }, chatId: 123 }]
   ]);
   assert.ok(calls.some((call) => JSON.stringify(call) === JSON.stringify(["complete", "good"])));