arisa 5.2.17 → 5.2.19

package/src/transport/telegram/task-dispatcher.js

@@ -41,7 +41,7 @@ function buildFailureNotice({ task, result, error }) {
   if (result?.authBlockedNew === true) {
     return [
       "⚠️ Arisa automation paused for authentication",
-      `Tool: ${task.payload?.toolName || "unknown"}`,
+      `Tool: ${result.authBlock?.toolName || task.payload?.toolName || "unknown"}`,
       `Reason: ${safeErrorSummary(error)}`,
       `Next authentication check: ${result.runAt}`
     ].join("\n");
@@ -72,17 +72,62 @@ export function createTelegramTaskDispatcher({
   const agentTimeoutMs = boundedTimeout(taskTimeouts.agentTimeoutMs, 15 * 60_000);
   const eventTimeoutMs = boundedTimeout(taskTimeouts.eventTimeoutMs, 5 * 60_000);
 
+  const runBackgroundTool = (toolName, chatId, args, label) => agentManager.runTurn({
+    priority: "background",
+    label
+  }, () => agentManager.runTool({ name: toolName, request: { args }, chatId }));
+
+  function throwToolFailure(result, toolName, fallbackResolution) {
+    const error = new Error(result?.error || `${toolName} failed`);
+    if (result?.status === "blocked_auth" || fallbackResolution) {
+      error.retryable = false;
+      error.authBlocked = true;
+      error.authResolution = {
+        ...(result?.resolution || fallbackResolution || {}),
+        toolName
+      };
+    } else if (result?.status === "needs_config") {
+      error.retryable = false;
+    } else if (result?.status === "outcome_uncertain") {
+      error.retryable = false;
+      error.outcomeUncertain = true;
+    }
+    throw error;
+  }
+
   async function dispatchAgentTask(task, chatId) {
     if (!task.payload.prompt) throw new NonRetryableTaskError("agent_task missing prompt");
+    if (task.authBlock?.toolName) {
+      const probe = await runBackgroundTool(
+        task.authBlock.toolName,
+        chatId,
+        task.authBlock.probeArgs || {},
+        `authentication probe ${task.authBlock.toolName}`
+      );
+      if (probe?.ok === false) throwToolFailure(probe, task.authBlock.toolName, task.authBlock);
+      logger?.log("tasks", `authentication restored for ${task.authBlock.toolName} (task ${task.id})`);
+    }
+
     logger?.log("tasks", `running task ${task.id} for chat ${chatId}`);
+    const agentTaskExecution = { blockedAuth: null };
     await enqueueAsyncPrompt({
       chatId,
       prompt: await buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, resourceNotes, logger }),
       label: `scheduled task ${task.id}`,
       route: task.route,
       timeoutMs: agentTimeoutMs,
-      priority: task.source?.toolName === "whatsapp-web" ? "interactive" : "background"
+      priority: task.source?.toolName === "whatsapp-web" ? "interactive" : "background",
+      agentTaskExecution
     });
+    if (agentTaskExecution.blockedAuth) {
+      const blocked = agentTaskExecution.blockedAuth;
+      throwToolFailure({
+        ok: false,
+        status: "blocked_auth",
+        error: blocked.error,
+        resolution: blocked.resolution
+      }, blocked.toolName);
+    }
   }
 
   async function dispatchAgentEvent(task, chatId) {
@@ -111,34 +156,16 @@ export function createTelegramTaskDispatcher({
     if (!toolName) throw new NonRetryableTaskError("poll_tool missing toolName");
     logger?.log("tasks", `polling tool ${toolName} (task ${task.id}) for chat ${chatId}`);
 
-    const runTool = (args) => agentManager.runTurn({
-      priority: "background",
-      label: `poll tool ${toolName}`
-    }, () => agentManager.runTool({ name: toolName, request: { args }, chatId }));
-
-    function throwFailure(result, fallbackResolution) {
-      const error = new Error(result?.error || `poll_tool ${toolName} failed`);
-      if (result?.status === "blocked_auth" || fallbackResolution) {
-        error.retryable = false;
-        error.authBlocked = true;
-        error.authResolution = result?.resolution || fallbackResolution;
-      } else if (result?.status === "needs_config") {
-        error.retryable = false;
-      } else if (result?.status === "outcome_uncertain") {
-        error.retryable = false;
-        error.outcomeUncertain = true;
-      }
-      throw error;
-    }
+    const runTool = (args) => runBackgroundTool(toolName, chatId, args, `poll tool ${toolName}`);
 
     if (task.authBlock) {
       const probe = await runTool(task.authBlock.probeArgs || {});
-      if (probe?.ok === false) throwFailure(probe, task.authBlock);
+      if (probe?.ok === false) throwToolFailure(probe, toolName, task.authBlock);
       logger?.log("tasks", `authentication restored for ${toolName} (task ${task.id})`);
     }
 
     const result = await runTool(task.payload.args || {});
-    if (result?.ok === false) throwFailure(result);
+    if (result?.ok === false) throwToolFailure(result, toolName);
   }
 
   async function dispatchTask(task) {

package/src/transport/telegram/telegram-auth-controller.js

@@ -50,7 +50,7 @@ export function createTelegramAuthController({
     if (!detected) return false;
 
     try {
-      await api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, chatId, issue: detected }));
+      await api.sendMessage(chatId, await buildPiAuthTelegramMessage({ config, chatId, issue: detected }));
       markPromptErrorNotified(error);
       return true;
     } catch (notifyError) {
@@ -66,11 +66,11 @@ export function createTelegramAuthController({
       agentManager.clearSessionCache(chatId);
       issue = null;
       logger?.log("telegram", `Pi auth renewal completed for chat ${chatId}`);
-      await api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, chatId, verified: true }));
+      await api.sendMessage(chatId, await buildPiAuthTelegramMessage({ config, chatId, verified: true }));
     } catch (error) {
       const detected = rememberValidationFailure(error);
       logger?.error("telegram", `Pi auth renewal failed for chat ${chatId}: ${getErrorMessage(error)}`);
-      await api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, chatId, issue: detected })).catch((notifyError) => {
+      await api.sendMessage(chatId, await buildPiAuthTelegramMessage({ config, chatId, issue: detected })).catch((notifyError) => {
         logger?.error("telegram", `auth renewal failure notice failed for chat ${chatId}: ${getErrorMessage(notifyError)}`);
       });
     } finally {
@@ -140,17 +140,17 @@ export function createTelegramAuthController({
     const authorization = await authorize(ctx);
     if (!authorization.ok) return;
 
-    const status = getPiAuthStatus(config, ctx.chat.id);
+    const status = await getPiAuthStatus(config, ctx.chat.id);
     if (status.hasApiKey || !status.supportsOAuth) {
       await withTyping(ctx, async () => {
         try {
           await agentManager.validateAgent();
           agentManager.clearSessionCache(ctx.chat.id);
           issue = null;
-          await ctx.reply(buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, verified: true }));
+          await ctx.reply(await buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, verified: true }));
         } catch (error) {
           const detected = rememberValidationFailure(error);
-          await ctx.reply(buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, issue: detected }));
+          await ctx.reply(await buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, issue: detected }));
         }
       });
       return;
@@ -163,7 +163,7 @@ export function createTelegramAuthController({
         : "Pi login is already in progress. Paste the redirect URL or code here when you have it.");
     } catch (error) {
       const detected = rememberValidationFailure(error);
-      await ctx.reply(buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, issue: detected }));
+      await ctx.reply(await buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, issue: detected }));
     }
   }
 

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/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/model-selection.test.js

@@ -355,17 +355,18 @@ test("maps supported model speeds to provider service tiers", () => {
 
 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/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,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
+  });
+});