arisa 5.2.7 → 5.2.19

package/test/pi-compaction.test.js

@@ -23,6 +23,27 @@ test("merges partial resident session cache overrides with defaults", () => {
   });
 });
 
+test("merges partial session rotation overrides with defaults", () => {
+  const config = applyConfigDefaults({ pi: { sessionRotation: { enabled: false } } });
+
+  assert.deepEqual(config.pi.sessionRotation, {
+    enabled: false,
+    compactAtPersistedBytes: 24 * 1024 * 1024,
+    maxPersistedBytes: 32 * 1024 * 1024
+  });
+});
+
+test("merges partial exclusive turn coordinator overrides with defaults", () => {
+  const config = applyConfigDefaults({ pi: { turnCoordinator: { backgroundQueueTtlMs: 30_000 } } });
+
+  assert.deepEqual(config.pi.turnCoordinator, {
+    enabled: true,
+    backgroundQueueTtlMs: 30_000,
+    interactiveQueueTtlMs: 0,
+    maxQueued: 100
+  });
+});
+
 test("merges partial Pi compaction overrides with defaults", () => {
   const config = applyConfigDefaults({
     pi: { compaction: { reserveTokens: 8_192 } }

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

@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { zstdDecompressSync } from "node:zlib";
+import { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { createModelSpeedController } from "../src/core/agent/model-speed.js";
+import { applyConfigDefaults } from "../src/core/config/config-defaults.js";
+import { resolveChatModelSelection, resolveChatSpeed } from "../src/core/agent/model-selection.js";
+import { createTelegramModelControls } from "../src/transport/telegram/model-controls.js";
+import { createTelegramModelCallbackHandler } from "../src/transport/telegram/model-callback.js";
+
+async function createRuntime(t, credential) {
+  const directory = await mkdtemp(path.join(tmpdir(), "arisa-pi-speed-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  if (credential) await writeFile(path.join(directory, "auth.json"), JSON.stringify({ "openai-codex": credential }));
+  const runtime = await ModelRuntime.create({
+    authPath: path.join(directory, "auth.json"),
+    modelsPath: null,
+    modelsStorePath: path.join(directory, "models-store.json"),
+    refreshOnCreate: false
+  });
+  return { directory, runtime };
+}
+
+test("speed picker updates Astra in place, persists per topic, and closes unchanged selections", async (t) => {
+  const { runtime } = await createRuntime(t);
+  t.mock.method(ModelRuntime, "create", async () => runtime);
+  const config = applyConfigDefaults({ pi: { provider: "openai-codex", model: "gpt-6-astra" } });
+  const writes = [];
+  const updates = [];
+  const replies = [];
+  const answers = [];
+  const controls = createTelegramModelControls({
+    config,
+    saveConfig: async (value) => writes.push(structuredClone(value)),
+    agentManager: { setModelSpeed: async (...args) => updates.push(args) },
+    contextRoute: () => ({ sessionId: "123:topic:7" })
+  });
+  const ctx = {
+    chat: { id: 123 },
+    reply: async (...args) => replies.push(args),
+    api: { editMessageText: async (...args) => replies.push(args) },
+    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");
+  const handler = createTelegramModelCallbackHandler({
+    ...controls, config,
+    authorizeContext: async () => ({ ok: true }),
+    contextRoute: () => ({ sessionId: "123:topic:7" }),
+    getChatState: () => ({ processing: true })
+  });
+  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.equal(resolveChatSpeed(config, "123:topic:8"), 1);
+  assert.equal(resolveChatModelSelection(config, "123:topic:7").sessionRevision, 0);
+  await handler(ctx);
+  assert.equal(writes.length, 1);
+  assert.match(replies.at(-1)[2], /Already using speed 1.5x/);
+  ctx.callbackQuery.data = "speed:1";
+  await handler(ctx);
+  assert.equal(resolveChatSpeed(config, "123:topic:7"), 1);
+  assert.equal(answers.at(-1).text, "Speed: 1.0x.");
+});
+
+test("Pi SDK sends the selected speed in the actual Codex payload across turns", async (t) => {
+  const apiKey = `test.${Buffer.from(JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "test-account" } })).toString("base64url")}.test`;
+  const { directory, runtime } = await createRuntime(t, {
+    type: "oauth", access: apiKey, refresh: "test-refresh", expires: Date.now() + 3_600_000
+  });
+  const model = runtime.getModel("openai-codex", "gpt-6-astra");
+  const resourceLoader = new DefaultResourceLoader({
+    cwd: directory, agentDir: directory, noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true
+  });
+  await resourceLoader.reload();
+  const { session } = await createAgentSession({
+    cwd: directory, agentDir: directory, modelRuntime: runtime, model,
+    resourceLoader, settingsManager: SettingsManager.inMemory({ retry: { enabled: false } }),
+    sessionManager: SessionManager.inMemory(), tools: []
+  });
+  t.after(() => session.dispose());
+  const requests = [];
+  const fetch = async (_url, init) => {
+    const body = init.headers.get("content-encoding") === "zstd"
+      ? zstdDecompressSync(init.body).toString("utf8")
+      : init.body;
+    requests.push(JSON.parse(body));
+    return new Response(`data: ${JSON.stringify({ type: "response.completed", response: {
+      id: "test-response", status: "completed", output: [], usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 }
+    } })}\n\n`, { headers: { "content-type": "text/event-stream" } });
+  };
+  t.mock.method(globalThis, "fetch", fetch);
+  const sdkStream = session.agent.streamFunction;
+  const controller = createModelSpeedController((model, context, options) => sdkStream(model, context, {
+    ...options, transport: "sse", maxRetries: 0
+  }), 1);
+  session.agent.streamFunction = controller.streamFn;
+  for (const speed of [1, 1.5, 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.length, 3);
+});
+
+test("speed control leaves unsupported provider payloads and hooks untouched", async () => {
+  const options = { onPayload: (payload) => payload };
+  let received;
+  const controller = createModelSpeedController((_model, _context, nextOptions) => { received = nextOptions; }, 1.5);
+  controller.streamFn({ provider: "anthropic", api: "anthropic-messages", id: "claude-sonnet-4-5" }, {}, options);
+  assert.equal(received, options);
+});
+
+test("Arisa creates and reuses Telegram sessions and opens its TUI with the installed Pi SDK", async (t) => {
+  const directory = await mkdtemp(path.join(tmpdir(), "arisa-pi-startup-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const { execFile } = await import("node:child_process");
+  const { promisify } = await import("node:util");
+  await promisify(execFile)(process.execPath, ["--input-type=module", "-e", `
+    import assert from "node:assert/strict";
+    import { mkdir, writeFile } from "node:fs/promises";
+    import path from "node:path";
+    import { applyConfigDefaults } from "./src/core/config/config-defaults.js";
+    import { AgentManager } from "./src/core/agent/agent-manager.js";
+    import { createArisaTuiRuntime } from "./src/runtime/tui.js";
+    import { selectChatSpeed } from "./src/core/agent/model-selection.js";
+    import { ensureArisaHome, piAuthFile } from "./src/platform/paths.js";
+    globalThis.fetch = async () => { throw new Error("Unexpected network request"); };
+    await ensureArisaHome();
+    await mkdir(process.env.PI_CODING_AGENT_DIR, { recursive: true });
+    await writeFile(piAuthFile, JSON.stringify({ "openai-codex": {
+      type: "oauth", access: "test-access", refresh: "test-refresh", expires: Date.now() + 3600000
+    } }));
+    const config = applyConfigDefaults({
+      telegram: { authorizedChatIds: [123] },
+      pi: { provider: "openai-codex", model: "gpt-6-astra", speed: 1.5, workspaceDir: process.env.ARISA_HOME }
+    });
+    const manager = new AgentManager({ config });
+    manager.setCapabilityService({ execute: async () => ({}) });
+    const context = await manager.getSessionContext("123", {});
+    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);
+      await manager.setModelSpeed("123", 1);
+      selectChatSpeed(config, "123", 1);
+      const reused = await manager.getSessionContext("123", {});
+      assert.equal(reused.session, context.session);
+      assert.equal(reused.speedController.speed, 1);
+      await reused.release();
+    } finally {
+      await context.release();
+      manager.clearSessionCache("123");
+      await Promise.all(manager.sessionClosePromises.values());
+      manager.turnCoordinator.close();
+    }
+    const tui = await createArisaTuiRuntime({ config, client: {} });
+    try {
+      assert.equal(tui.session.model.id, "gpt-6-astra");
+      assert.equal(typeof tui.session.agent.streamFunction, "function");
+    } finally {
+      await tui.dispose();
+    }
+  `], {
+    cwd: new URL("..", import.meta.url),
+    env: { ...process.env, ARISA_HOME: directory, PI_CODING_AGENT_DIR: path.join(directory, "pi"), PI_OFFLINE: "1" },
+    timeout: 15_000
+  });
+});

package/test/session-history-reader.test.js

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { inspectSessionForPreloadMigration } from "../src/core/agent/session-history-reader.js";
+
+function writeSession(entries) {
+  const dir = mkdtempSync(path.join(tmpdir(), "arisa-session-reader-"));
+  const file = path.join(dir, "session.jsonl");
+  writeFileSync(file, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf8");
+  return { dir, file };
+}
+
+const header = {
+  type: "session",
+  version: 3,
+  id: "session-id",
+  timestamp: "2026-08-28T00:00:00.000Z",
+  cwd: "/workspace"
+};
+
+function message(id, parentId, text) {
+  return {
+    type: "message",
+    id,
+    parentId,
+    timestamp: "2026-08-28T00:00:00.000Z",
+    message: { role: "user", content: [{ type: "text", text }] }
+  };
+}
+
+test("discovers the latest valid compaction on the active branch without retaining divergent payloads", () => {
+  const entries = [
+    header,
+    message("kept", null, "kept context"),
+    {
+      type: "compaction",
+      id: "active-compaction",
+      parentId: "kept",
+      firstKeptEntryId: "kept",
+      summary: "active summary"
+    },
+    message("after", "active-compaction", "recent context"),
+    {
+      type: "compaction",
+      id: "divergent-compaction",
+      parentId: "kept",
+      firstKeptEntryId: "kept",
+      summary: "divergent summary"
+    },
+    message("leaf", "after", "active leaf")
+  ];
+  const { dir, file } = writeSession(entries);
+  try {
+    const result = inspectSessionForPreloadMigration(file, 1);
+    assert.equal(result.compactionId, "active-compaction");
+    assert.equal(result.summary, "active summary");
+    assert.deepEqual(result.contextEntries.map((entry) => entry.id), ["kept", "after", "leaf"]);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("does not migrate a small, unsupported, or structurally invalid session", () => {
+  const cases = [
+    [header, message("one", null, "small")],
+    [{ ...header, version: 2 }, message("kept", null, "old"), {
+      type: "compaction", id: "comp", parentId: "kept", firstKeptEntryId: "kept", summary: "summary"
+    }],
+    [header, message("leaf", "missing-parent", "broken"), {
+      type: "compaction", id: "comp", parentId: "leaf", firstKeptEntryId: "leaf", summary: "summary"
+    }]
+  ];
+  for (const entries of cases) {
+    const { dir, file } = writeSession(entries);
+    try {
+      const threshold = entries === cases[0] ? 1024 * 1024 : 1;
+      assert.equal(inspectSessionForPreloadMigration(file, threshold), null);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+});

package/test/session-preload-migration.test.js

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import {
+  createPreloadMigrationChild,
+  migrateRecentSessionBeforeLoad
+} from "../src/core/agent/session-preload-migration.js";
+
+function sourceMessage(id, parentId, role, text) {
+  return {
+    type: "message",
+    id,
+    parentId,
+    timestamp: "2026-08-28T00:00:00.000Z",
+    message: { role, content: [{ type: "text", text }] }
+  };
+}
+
+function writeEntries(file, entries) {
+  writeFileSync(file, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf8");
+}
+
+test("atomically creates a valid child session with a durable parent reference", () => {
+  const sessionDir = mkdtempSync(path.join(tmpdir(), "arisa-session-migration-"));
+  try {
+    const result = createPreloadMigrationChild({
+      sessionDir,
+      cwd: "/workspace",
+      migration: {
+        sourceFile: path.join(sessionDir, "historical.jsonl"),
+        sourceBytes: 80 * 1024 * 1024,
+        summary: "compacted history",
+        contextEntries: [
+          sourceMessage("old-user", null, "user", "recent question"),
+          { type: "label", id: "ignored", parentId: "old-user", targetId: "old-user", label: "old" },
+          sourceMessage("old-assistant", "old-user", "assistant", "recent answer")
+        ]
+      },
+      operationalNotes: "Durable operating notes:\n- keep history",
+      now: new Date("2026-08-28T12:00:00.000Z")
+    });
+
+    assert.equal(result.copiedEntries, 2);
+    assert.equal(readdirSync(sessionDir).some((name) => name.endsWith(".tmp")), false);
+    const entries = readFileSync(result.targetFile, "utf8").trim().split("\n").map(JSON.parse);
+    assert.equal(entries[0].parentSession, result.sourceFile);
+    assert.deepEqual(entries.slice(1).map((entry) => entry.parentId), [
+      null,
+      entries[1].id,
+      entries[2].id,
+      entries[3].id
+    ]);
+    assert.equal(entries[2].details.source, "preload-migration");
+
+    const manager = SessionManager.open(result.targetFile, sessionDir, "/workspace");
+    const messages = manager.buildSessionContext().messages;
+    assert.deepEqual(messages.map((message) => message.role), ["custom", "custom", "user", "assistant"]);
+    assert.match(messages[1].content, /compacted history/);
+  } finally {
+    rmSync(sessionDir, { recursive: true, force: true });
+  }
+});
+
+test("pre-load migration commits once and a restart selects the compact child", () => {
+  const sessionDir = mkdtempSync(path.join(tmpdir(), "arisa-session-recovery-"));
+  const sourceFile = path.join(sessionDir, "historical.jsonl");
+  try {
+    writeEntries(sourceFile, [
+      { type: "session", version: 3, id: "old", timestamp: "2026-08-28T00:00:00.000Z", cwd: "/workspace" },
+      sourceMessage("historical", null, "user", "x".repeat(8_000)),
+      sourceMessage("kept", "historical", "user", "recent"),
+      {
+        type: "compaction",
+        id: "compaction",
+        parentId: "kept",
+        firstKeptEntryId: "kept",
+        summary: "bounded summary"
+      },
+      sourceMessage("leaf", "compaction", "assistant", "answer")
+    ]);
+
+    const first = migrateRecentSessionBeforeLoad({
+      sessionDir,
+      cwd: "/workspace",
+      policy: { maxPersistedBytes: 2_000 },
+      operationalNotes: "notes"
+    });
+    assert.equal(first.sourceFile, sourceFile);
+    assert.ok(first.targetBytes < 2_000);
+    assert.equal(migrateRecentSessionBeforeLoad({
+      sessionDir,
+      cwd: "/workspace",
+      policy: { maxPersistedBytes: 2_000 }
+    }), null);
+    const resumed = SessionManager.continueRecent("/workspace", sessionDir);
+    assert.equal(resumed.getSessionFile(), first.targetFile);
+  } finally {
+    rmSync(sessionDir, { recursive: true, force: true });
+  }
+});
+
+test("refuses to load an oversized session when no safe compaction checkpoint exists", () => {
+  const sessionDir = mkdtempSync(path.join(tmpdir(), "arisa-session-refusal-"));
+  try {
+    writeEntries(path.join(sessionDir, "unsafe.jsonl"), [
+      { type: "session", version: 3, id: "unsafe", timestamp: "2026-08-28T00:00:00.000Z", cwd: "/workspace" },
+      sourceMessage("leaf", null, "user", "x".repeat(4_000))
+    ]);
+    assert.throws(() => migrateRecentSessionBeforeLoad({
+      sessionDir,
+      cwd: "/workspace",
+      policy: { maxPersistedBytes: 1_000 }
+    }), (error) => error.code === "PI_SESSION_PRELOAD_MIGRATION_UNAVAILABLE");
+  } finally {
+    rmSync(sessionDir, { recursive: true, force: true });
+  }
+});

package/test/session-rotation.test.js

@@ -0,0 +1,110 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { applyConfigDefaults } from "../src/core/config/config-defaults.js";
+import { AgentManager } from "../src/core/agent/agent-manager.js";
+import { compactionRotationRequest, normalizeSessionRotationPolicy } from "../src/core/agent/session-rotation.js";
+
+const mebibyte = 1024 * 1024;
+
+function compactionEvent(summary = "checkpoint") {
+  return {
+    type: "compaction_end",
+    aborted: false,
+    errorMessage: "",
+    result: { summary }
+  };
+}
+
+test("normalizes the automatic session rotation policy", () => {
+  assert.deepEqual(normalizeSessionRotationPolicy(), {
+    enabled: true,
+    compactAtPersistedBytes: 24 * mebibyte,
+    maxPersistedBytes: 32 * mebibyte
+  });
+  assert.deepEqual(normalizeSessionRotationPolicy({
+    enabled: false,
+    compactAtPersistedBytes: 8,
+    maxPersistedBytes: 12
+  }), {
+    enabled: false,
+    compactAtPersistedBytes: 8,
+    maxPersistedBytes: 12
+  });
+});
+
+test("requests rotation only after a successful oversized compaction", () => {
+  assert.equal(compactionRotationRequest(compactionEvent(), 24 * mebibyte), null);
+  assert.equal(compactionRotationRequest({ ...compactionEvent(), aborted: true }, 25 * mebibyte), null);
+  assert.equal(compactionRotationRequest(compactionEvent(), 25 * mebibyte, { enabled: false }), null);
+  const request = compactionRotationRequest(compactionEvent("latest summary"), 25 * mebibyte);
+  assert.equal(request.persistedBytes, 25 * mebibyte);
+  assert.match(request.handoff, /latest summary/);
+});
+
+test("compacts at the preventive persisted-size threshold and then rotates", async () => {
+  const config = applyConfigDefaults({ telegram: {}, pi: { provider: "test", model: "test" } });
+  const manager = new AgentManager({
+    config,
+    artifactStore: {},
+    toolRegistry: {},
+    taskStore: {},
+    logger: null
+  });
+  let compactions = 0;
+  const context = {
+    activeUsers: 1,
+    session: {
+      sessionFile: "/sessions/preventive.jsonl",
+      async compact() {
+        compactions += 1;
+        manager.scheduleCompactionRotationCheck("chat", context, compactionEvent("preventive summary"));
+      },
+      async close() {}
+    },
+    rotationCheckPromise: Promise.resolve(),
+    rotationRequest: null
+  };
+  manager.sessions.set("chat", context);
+  manager.estimatePersistedSessionBytes = async () => 25 * mebibyte;
+
+  await manager.releaseSessionContext("chat", context);
+
+  assert.equal(compactions, 1);
+  assert.equal(manager.sessions.has("chat"), false);
+  assert.equal(manager.pendingNewSessions.has("chat"), true);
+});
+
+test("rotates after active work releases and preserves the parent session path", async () => {
+  const config = applyConfigDefaults({ telegram: {}, pi: { provider: "test", model: "test" } });
+  let closes = 0;
+  const manager = new AgentManager({
+    config,
+    artifactStore: {},
+    toolRegistry: {},
+    taskStore: {},
+    logger: null
+  });
+  const context = {
+    activeUsers: 1,
+    session: {
+      sessionFile: "/sessions/oversized.jsonl",
+      async close() { closes += 1; }
+    },
+    rotationCheckPromise: Promise.resolve(),
+    rotationRequest: null
+  };
+  manager.sessions.set("chat", context);
+  manager.estimatePersistedSessionBytes = async () => 65 * mebibyte;
+
+  manager.scheduleCompactionRotationCheck("chat", context, compactionEvent("handoff summary"));
+  await manager.releaseSessionContext("chat", context);
+
+  assert.equal(closes, 1);
+  assert.equal(manager.sessions.has("chat"), false);
+  assert.equal(manager.pendingNewSessions.has("chat"), true);
+  assert.deepEqual(manager.pendingSessionHandoffs.get("chat"), {
+    text: "Automatic session rotation after compaction. Continue from this checkpoint:\n\nhandoff summary",
+    parentSession: "/sessions/oversized.jsonl",
+    source: "compaction-rotation"
+  });
+});