arisa 5.2.17 → 5.2.20

package/src/transport/telegram/telegram-session-bridge.js

@@ -113,7 +113,8 @@ export function createTelegramSessionBridgeController({
           chatId: route.transportChatId,
           threadId: route.topicThreadId
         }
-      } : null
+      } : null,
+      getAgentTaskExecution: () => route.agentTaskExecution || null
     };
   }
 

package/test/agent-turn-coordinator.test.js

@@ -25,13 +25,16 @@ test("interactive turns run before queued background turns without overlapping",
   assert.equal(coordinator.diagnostic().completed, 3);
 });
 
-test("background turns expire safely before execution when their queue TTL elapses", async () => {
+test("background turns expire safely before execution when their queue TTL elapses", async (t) => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
   const coordinator = new AgentTurnCoordinator();
   const releaseActive = await coordinator.acquire({ priority: "interactive", label: "active" });
-  await assert.rejects(
+  const expired = assert.rejects(
     coordinator.acquire({ priority: "background", label: "stale batch", queueTtlMs: 10 }),
     (error) => error.code === "AGENT_TURN_QUEUE_EXPIRED" && error.retryable === true && error.outcomeUncertain === false
   );
+  t.mock.timers.tick(10);
+  await expired;
   assert.equal(coordinator.diagnostic().expired, 1);
   releaseActive();
 });

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/auth-flow.test.js

@@ -42,7 +42,7 @@ test("ignores unrelated Pi errors", () => {
   assert.equal(getPiAuthIssue(new Error("")), null);
 });
 
-test("reports the active chat model after authentication", () => {
+test("reports the active chat model after authentication", async () => {
   const config = {
     pi: {
       provider: "openai-codex",
@@ -60,7 +60,7 @@ test("reports the active chat model after authentication", () => {
     }
   };
 
-  const message = buildPiAuthTelegramMessage({ config, chatId: 123, verified: true });
+  const message = await buildPiAuthTelegramMessage({ config, chatId: 123, verified: true });
 
   assert.match(message, /^Pi authentication is working for openai-codex\/gpt-5\.6\./);
   assert.doesNotMatch(message, /gpt-5\.5/);

package/test/capabilities-security.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createArisaCapabilities } from "../src/runtime/arisa-capabilities.js";
+import { createCapabilityService } from "../src/core/capabilities/capability-service.js";
 
 function createFakeArtifactStore() {
   const stores = new Map();
@@ -294,6 +295,41 @@ test("normalizes tool run args and rejects arrays", async () => {
   );
 });
 
+test("records blocked authentication and stops later tools inside an agent task", async () => {
+  const execution = { blockedAuth: null };
+  const resolution = { retryAfterSeconds: 3600, probeArgs: { action: "status" } };
+  let executions = 0;
+  const service = createCapabilityService({
+    artifactStore: createFakeArtifactStore(),
+    toolRegistry: { async load() {} },
+    toolExecutor: {
+      async runTool() {
+        executions += 1;
+        return { ok: false, status: "blocked_auth", error: "authentication expired", resolution };
+      }
+    }
+  });
+  const run = (name) => service.execute({
+    method: "tools.run",
+    actorToolName: "run_tool",
+    chatId: "chat-1",
+    params: { name, args: {} },
+    context: { agentTaskExecution: execution }
+  });
+
+  await run("creator-scout");
+  assert.deepEqual(execution.blockedAuth, {
+    toolName: "creator-scout",
+    error: "authentication expired",
+    resolution
+  });
+
+  const skipped = await run("campaign-draft-runner");
+  assert.equal(skipped.status, "blocked_prerequisite");
+  assert.equal(skipped.resolution.prerequisiteStatus, "blocked_auth");
+  assert.equal(executions, 1);
+});
+
 test("rejects missing artifact input before running a tool", async () => {
   const calls = [];
   const capabilities = createCapabilities({

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,22 +350,32 @@ 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 () => {
   const calls = [];
+  const model = { provider: "openai-codex", api: "openai-codex-responses", id: "gpt-5.6-sol" };
   const controller = createModelSpeedController((model, context, options) => {
     calls.push({ model, context, options });
     return "stream";
   }, 1);
 
-  assert.equal(controller.streamFn("model", "context", {
+  assert.equal(controller.streamFn(model, "context", {
     signal: "signal",
     onPayload: (payload) => ({ ...payload, preserved: true })
   }), "stream");
   controller.setSpeed(1.5);
-  controller.streamFn("model", "context", { signal: "signal" });
+  controller.streamFn(model, "context", { signal: "signal" });
 
   assert.equal(calls[0].options.serviceTier, "default");
   assert.equal(calls[1].options.serviceTier, "priority");

package/test/official-tool-installer.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import crypto from "node:crypto";
+import { execFileSync } from "node:child_process";
 import { cp, mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -88,9 +89,21 @@ test("every bundled official tool lock matches the catalog source", async () =>
     );
     const manifest = JSON.parse(await readFile(path.join(source, "tool.manifest.json"), "utf8"));
     assert.equal(manifest.version ?? null, entry.version ?? null, `${name} version`);
+    assert.deepEqual(manifest.toolDependencies || {}, entry.toolDependencies || {}, `${name} tool dependencies`);
   }
 });
 
+test("the bundled lock commit contains the exact catalog snapshot", async () => {
+  const lock = JSON.parse(await readFile(new URL("../src/official-tools.lock.json", import.meta.url), "utf8"));
+  const repositoryRoot = fileURLToPath(new URL("../../", import.meta.url));
+  execFileSync("git", ["cat-file", "-e", `${lock.commit}^{commit}`], { cwd: repositoryRoot });
+  const changedTools = execFileSync("git", ["diff", "--name-only", lock.commit, "--", "tools"], {
+    cwd: repositoryRoot,
+    encoding: "utf8"
+  }).trim();
+  assert.equal(changedTools, "", `Bundled lock commit does not match catalog source:\n${changedTools}`);
+});
+
 test("rejects symbolic links before deployment", async (t) => {
   const { source, files } = await fixture(t);
   await symlink(path.join(source, "index.js"), path.join(source, "link.js"));

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-auth-login.test.js

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { createPiOAuthLogin } from "../src/core/agent/pi-auth-login.js";
+import { createPiRuntime, hasProviderAuth, supportsProviderOAuth } from "../src/core/agent/pi-runtime.js";
+import { piAuthFile } from "../src/platform/paths.js";
+
+test("creates the async Pi runtime with Arisa credential storage and awaits runtime API keys", async (t) => {
+  const calls = [];
+  const runtime = {
+    async setRuntimeApiKey(provider, apiKey) {
+      await Promise.resolve();
+      calls.push([provider, apiKey]);
+    },
+    getProviderAuthStatus: () => ({ configured: true, source: "stored" }),
+    getProvider: () => ({ auth: { oauth: {} } })
+  };
+  t.mock.method(ModelRuntime, "create", async (options) => {
+    assert.equal(options.authPath, piAuthFile);
+    return runtime;
+  });
+  assert.equal(await createPiRuntime({ provider: "openai", apiKey: "test-key" }), runtime);
+  assert.deepEqual(calls, [["openai", "test-key"]]);
+  assert.equal(hasProviderAuth("openai", runtime), true);
+  assert.equal(supportsProviderOAuth("openai", runtime), true);
+});
+
+test("adapts Pi OAuth notifications, selections and manual codes in order", async (t) => {
+  const events = [];
+  let controller;
+  const credential = { type: "oauth", access: "test-access" };
+  t.mock.method(ModelRuntime, "create", async () => ({
+    getProvider: () => ({ auth: { oauth: {} } }),
+    async login(provider, type, interaction) {
+      assert.equal(provider, "openai-codex");
+      assert.equal(type, "oauth");
+      interaction.notify({ type: "auth_url", url: "https://example.com/login" });
+      interaction.notify({ type: "device_code", userCode: "ABCD", verificationUri: "https://example.com/device" });
+      interaction.notify({ type: "progress", message: "waiting" });
+      assert.equal(await interaction.prompt({ type: "select", options: [{ id: "device", label: "Device" }] }), "device");
+      assert.deepEqual(events, ["auth", "device", "waiting", "select"]);
+      assert.equal(await interaction.prompt({ type: "text", message: "Value" }), "answer");
+      const code = interaction.prompt({ type: "manual_code" });
+      await new Promise((resolve) => setImmediate(resolve));
+      assert.equal(controller.manualInputRequested, true);
+      assert.equal(controller.submitManualCode(" callback-code "), true);
+      assert.equal(await code, "callback-code");
+      return credential;
+    }
+  }));
+  controller = createPiOAuthLogin({
+    provider: "openai-codex",
+    onAuth: async () => { await Promise.resolve(); events.push("auth"); },
+    onDeviceCode: async () => { events.push("device"); },
+    onProgress: (message) => events.push(message),
+    onSelect: ({ options }) => { events.push("select"); return options[0].id; },
+    onPrompt: () => "answer"
+  });
+  assert.equal(await controller.promise, credential);
+  assert.equal(controller.manualInputRequested, false);
+  assert.equal(controller.submitManualCode("again"), false);
+});
+
+test("OAuth rejects unsupported providers and surfaces notification failures", async (t) => {
+  t.mock.method(ModelRuntime, "create", async () => ({ getProvider: () => ({ auth: {} }) }));
+  await assert.rejects(createPiOAuthLogin({ provider: "unsupported" }).promise, /No internal OAuth login flow/);
+  ModelRuntime.create.mock.restore();
+  t.mock.method(ModelRuntime, "create", async () => ({
+    getProvider: () => ({ auth: { oauth: {} } }),
+    async login(_provider, _type, interaction) {
+      interaction.notify({ type: "auth_url", url: "https://example.com/login" });
+      await interaction.prompt({ type: "manual_code" });
+    }
+  }));
+  const login = createPiOAuthLogin({ provider: "openai-codex", onAuth: async () => { throw new Error("delivery failed"); } });
+  await assert.rejects(login.promise, /delivery failed/);
+  assert.equal(login.manualInputRequested, false);
+});

package/test/pi-capability-tools.test.js

@@ -5,6 +5,7 @@ import { createPiCapabilityTools } from "../src/core/agent/pi-capability-tools.j
 function createHarness() {
   const calls = [];
   let taskContext = { transportChatId: "chat-1", messageThreadId: 10 };
+  const agentTaskExecution = { blockedAuth: null };
   const capabilityService = {
     async execute(request) {
       calls.push(request);
@@ -15,6 +16,7 @@ function createHarness() {
   };
   const telegram = {
     getTaskContext: () => taskContext,
+    getAgentTaskExecution: () => agentTaskExecution,
     sendMedia: async () => {}
   };
   const tools = createPiCapabilityTools({
@@ -62,4 +64,5 @@ test("Pi tool execution resolves the current Telegram task context per call", as
 
   assert.equal(harness.calls[0].context.taskContext.messageThreadId, 10);
   assert.equal(harness.calls[1].context.taskContext.messageThreadId, 20);
+  assert.equal(harness.calls[0].context.agentTaskExecution, harness.calls[1].context.agentTaskExecution);
 });

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

@@ -0,0 +1,177 @@
+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:2");
+  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", 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 2.0x/);
+  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, 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 ? "priority" : "default");
+  }
+  assert.equal(requests.length, 4);
+});
+
+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, 2);
+      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
+  });
+});