arisa 5.2.17 → 5.2.20

package/src/runtime/slave-service.js

@@ -4,6 +4,8 @@ import os from "node:os";
 import path from "node:path";
 
 export const slaveServiceName = "arisa-slave.service";
+export const slaveLaunchdLabel = "com.arisa.slave";
+export const slaveWindowsTaskName = "Arisa Slave";
 
 function exists(target) {
   return access(target).then(() => true, () => false);
@@ -15,6 +17,12 @@ function requireAccountName(value) {
   return name;
 }
 
+function requireWindowsAccountName(value) {
+  const name = String(value || "").trim();
+  if (!name || /[\u0000-\u001f<>"|]/.test(name)) throw new Error(`Invalid Windows service account: ${name || "empty"}`);
+  return name;
+}
+
 export function resolveSlaveHome({ environment = process.env, euid = process.geteuid?.(), homedir = os.homedir() } = {}) {
   if (environment.ARISA_SLAVE_HOME) return path.resolve(environment.ARISA_SLAVE_HOME);
   return euid === 0 ? "/var/lib/arisa-slave" : path.join(homedir, ".arisa-slave");
@@ -39,8 +47,15 @@ export function getSlavePaths(slaveHome) {
 export async function selectSlaveServiceAccount({
   euid = process.geteuid?.(),
   currentUser = os.userInfo().username,
-  environment = process.env
+  environment = process.env,
+  platform = process.platform
 } = {}) {
+  if (platform === "win32") {
+    const qualifiedUser = environment.USERDOMAIN && environment.USERNAME
+      ? `${environment.USERDOMAIN}\\${environment.USERNAME}`
+      : currentUser;
+    return { scope: "user", user: requireWindowsAccountName(qualifiedUser), root: false, dedicated: false };
+  }
   if (euid !== 0) {
     return { scope: "user", user: requireAccountName(currentUser), root: false, dedicated: false };
   }
@@ -95,6 +110,154 @@ export function buildSlaveSystemdUnit({ account, slaveHome, entryFile, nodePath
   ].filter((line, index, lines) => line || lines[index - 1] !== "").join("\n");
 }
 
+function escapeXml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}
+
+function plistString(value) {
+  return `    <string>${escapeXml(value)}</string>`;
+}
+
+export function buildSlaveLaunchdPlist({ account, slaveHome, entryFile, nodePath = process.execPath, environment = process.env }) {
+  if (!account?.scope || !account?.user) throw new Error("Slave launchd service requires a service account");
+  if (typeof entryFile !== "string" || !path.isAbsolute(entryFile)) throw new Error("Slave launchd service requires an absolute Arisa entry file");
+  const paths = getSlavePaths(slaveHome);
+  const serviceUser = account.scope === "system" && account.user !== "root"
+    ? ["  <key>UserName</key>", `  <string>${escapeXml(account.user)}</string>`]
+    : [];
+  const environmentEntries = {
+    ARISA_HOME: paths.home,
+    ARISA_SLAVE_HOME: paths.home,
+    ...(environment.HOME ? { HOME: environment.HOME } : {}),
+    ...(environment.PATH ? { PATH: environment.PATH } : {}),
+    ...(environment.TMPDIR ? { TMPDIR: environment.TMPDIR } : {})
+  };
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    '<dict>',
+    '  <key>Label</key>',
+    `  <string>${slaveLaunchdLabel}</string>`,
+    '  <key>ProgramArguments</key>',
+    '  <array>',
+    plistString(nodePath),
+    plistString(entryFile),
+    plistString("slave"),
+    plistString("--service-runner"),
+    '  </array>',
+    '  <key>EnvironmentVariables</key>',
+    '  <dict>',
+    ...Object.entries(environmentEntries).flatMap(([key, value]) => [
+      `    <key>${escapeXml(key)}</key>`,
+      `    <string>${escapeXml(value)}</string>`
+    ]),
+    '  </dict>',
+    '  <key>WorkingDirectory</key>',
+    `  <string>${escapeXml(paths.home)}</string>`,
+    '  <key>StandardOutPath</key>',
+    `  <string>${escapeXml(paths.logFile)}</string>`,
+    '  <key>StandardErrorPath</key>',
+    `  <string>${escapeXml(paths.logFile)}</string>`,
+    '  <key>RunAtLoad</key>',
+    '  <true/>',
+    '  <key>KeepAlive</key>',
+    '  <true/>',
+    ...serviceUser,
+    '</dict>',
+    '</plist>',
+    ''
+  ].join("\n");
+}
+
+export function buildSlaveWindowsLauncher({ slaveHome, entryFile, nodePath = process.execPath }) {
+  if (typeof entryFile !== "string" || !path.isAbsolute(entryFile)) throw new Error("Slave Windows launcher requires an absolute Arisa entry file");
+  const paths = getSlavePaths(slaveHome);
+  return [
+    'const { closeSync, openSync } = require("node:fs");',
+    'const { spawn } = require("node:child_process");',
+    `const home = ${JSON.stringify(paths.home)};`,
+    `const logFile = ${JSON.stringify(paths.logFile)};`,
+    `process.env.ARISA_HOME = ${JSON.stringify(paths.home)};`,
+    `process.env.ARISA_SLAVE_HOME = ${JSON.stringify(paths.home)};`,
+    'process.chdir(home);',
+    'const log = openSync(logFile, "a");',
+    `const child = spawn(${JSON.stringify(nodePath)}, [${JSON.stringify(entryFile)}, "slave", "--service-runner"], {`,
+    '  cwd: home,',
+    '  env: process.env,',
+    '  stdio: ["ignore", log, log],',
+    '  windowsHide: true',
+    '});',
+    'for (const signal of ["SIGINT", "SIGTERM"]) {',
+    '  process.on(signal, () => child.kill(signal));',
+    '}',
+    'let finished = false;',
+    'function finish(code, error) {',
+    '  if (finished) return;',
+    '  finished = true;',
+    '  if (error) require("node:fs").writeSync(log, `${error.stack || error.message || error}\\n`);',
+    '  closeSync(log);',
+    '  process.exitCode = Number.isInteger(code) ? code : 1;',
+    '}',
+    'child.once("error", (error) => finish(1, error));',
+    'child.once("close", (code) => finish(code));',
+    ''
+  ].join("\r\n");
+}
+
+export function buildSlaveWindowsTaskXml({ account, launcherFile, nodePath = process.execPath }) {
+  if (!account?.user) throw new Error("Slave Windows task requires a service account");
+  if (typeof launcherFile !== "string" || !path.isAbsolute(launcherFile)) throw new Error("Slave Windows task requires an absolute launcher file");
+  const taskArguments = `"${launcherFile}"`;
+  return [
+    '<?xml version="1.0" encoding="UTF-16"?>',
+    '<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">',
+    '  <RegistrationInfo>',
+    `    <Author>${escapeXml(account.user)}</Author>`,
+    '    <Description>Arisa Slave headless host</Description>',
+    '  </RegistrationInfo>',
+    '  <Triggers>',
+    '    <LogonTrigger>',
+    '      <Enabled>true</Enabled>',
+    `      <UserId>${escapeXml(account.user)}</UserId>`,
+    '    </LogonTrigger>',
+    '  </Triggers>',
+    '  <Principals>',
+    '    <Principal id="Author">',
+    `      <UserId>${escapeXml(account.user)}</UserId>`,
+    '      <LogonType>InteractiveToken</LogonType>',
+    '      <RunLevel>LeastPrivilege</RunLevel>',
+    '    </Principal>',
+    '  </Principals>',
+    '  <Settings>',
+    '    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>',
+    '    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>',
+    '    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>',
+    '    <StartWhenAvailable>true</StartWhenAvailable>',
+    '    <Enabled>true</Enabled>',
+    '    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>',
+    '    <RestartOnFailure>',
+    '      <Interval>PT1M</Interval>',
+    '      <Count>999</Count>',
+    '    </RestartOnFailure>',
+    '  </Settings>',
+    '  <Actions Context="Author">',
+    '    <Exec>',
+    `      <Command>${escapeXml(nodePath)}</Command>`,
+    `      <Arguments>${escapeXml(taskArguments)}</Arguments>`,
+    `      <WorkingDirectory>${escapeXml(path.dirname(launcherFile))}</WorkingDirectory>`,
+    '    </Exec>',
+    '  </Actions>',
+    '</Task>',
+    ''
+  ].join("\r\n");
+}
+
 export function runCommand(command, args, { cwd, env = process.env } = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
@@ -155,6 +318,70 @@ export async function installSlaveSystemdService({
   return { unitFile, serviceName: slaveServiceName, account, paths };
 }
 
+export async function installSlaveLaunchdService({
+  account,
+  slaveHome,
+  entryFile,
+  execute = runCommand,
+  environment = process.env,
+  platform = process.platform,
+  uid = process.getuid?.(),
+  systemUnitDir = "/Library/LaunchDaemons",
+  userUnitDir = path.join(os.homedir(), "Library", "LaunchAgents")
+}) {
+  if (platform !== "darwin") throw new Error("Arisa Slave launchd installation requires macOS");
+  if (account.scope === "user" && !Number.isSafeInteger(uid)) throw new Error("Cannot determine the macOS user id for launchd");
+  const paths = getSlavePaths(slaveHome);
+  await mkdir(paths.state, { recursive: true, mode: 0o700 });
+  const unitDir = account.scope === "system" ? systemUnitDir : userUnitDir;
+  await mkdir(unitDir, { recursive: true });
+  const unitFile = path.join(unitDir, `${slaveLaunchdLabel}.plist`);
+  await writeFile(unitFile, buildSlaveLaunchdPlist({ account, slaveHome: paths.home, entryFile, environment }), { mode: 0o644 });
+  const domain = account.scope === "system" ? "system" : `gui/${uid}`;
+  const serviceTarget = `${domain}/${slaveLaunchdLabel}`;
+  await execute("launchctl", ["bootout", serviceTarget], { env: environment }).catch(() => {});
+  await execute("launchctl", ["bootstrap", domain, unitFile], { env: environment });
+  await execute("launchctl", ["enable", serviceTarget], { env: environment });
+  await execute("launchctl", ["kickstart", "-k", serviceTarget], { env: environment });
+  return { unitFile, serviceName: slaveLaunchdLabel, serviceManager: "launchd", serviceTarget, account, paths };
+}
+
+export async function installSlaveWindowsService({
+  account,
+  slaveHome,
+  entryFile,
+  execute = runCommand,
+  platform = process.platform
+}) {
+  if (platform !== "win32") throw new Error("Arisa Slave Task Scheduler installation requires Windows");
+  const paths = getSlavePaths(slaveHome);
+  await mkdir(paths.state, { recursive: true, mode: 0o700 });
+  const launcherFile = path.join(paths.state, "arisa-slave-launcher.cjs");
+  const unitFile = path.join(paths.state, "arisa-slave-task.xml");
+  await writeFile(launcherFile, `\uFEFF${buildSlaveWindowsLauncher({ slaveHome: paths.home, entryFile })}`, { encoding: "utf8", mode: 0o600 });
+  await writeFile(unitFile, `\uFEFF${buildSlaveWindowsTaskXml({ account, launcherFile })}`, { encoding: "utf16le", mode: 0o600 });
+  await execute("schtasks.exe", ["/End", "/TN", slaveWindowsTaskName]).catch(() => {});
+  await execute("schtasks.exe", ["/Create", "/TN", slaveWindowsTaskName, "/XML", unitFile, "/F"]);
+  await execute("schtasks.exe", ["/Run", "/TN", slaveWindowsTaskName]);
+  return {
+    unitFile,
+    launcherFile,
+    serviceName: slaveWindowsTaskName,
+    serviceManager: "windows-task",
+    serviceTarget: slaveWindowsTaskName,
+    account,
+    paths
+  };
+}
+
+export async function installSlaveService(options = {}) {
+  const platform = options.platform || process.platform;
+  if (platform === "linux") return installSlaveSystemdService({ ...options, platform });
+  if (platform === "darwin") return installSlaveLaunchdService({ ...options, platform });
+  if (platform === "win32") return installSlaveWindowsService({ ...options, platform });
+  throw new Error(`Arisa Slave service installation is not supported on ${platform}`);
+}
+
 export async function writeSlaveServiceDescriptor(paths, descriptor) {
   await mkdir(paths.state, { recursive: true, mode: 0o700 });
   await writeFile(paths.descriptorFile, `${JSON.stringify(descriptor, null, 2)}\n`, { mode: 0o600 });
@@ -169,20 +396,85 @@ export async function readSlaveServiceDescriptor(paths) {
   }
 }
 
-export async function controlSlaveService(paths, operation, { execute = runCommand } = {}) {
-  const descriptor = await readSlaveServiceDescriptor(paths);
+async function controlSystemdService(descriptor, operation, execute) {
   const prefix = descriptor.account?.scope === "user" ? ["--user"] : [];
   if (operation === "status") {
     try {
       const result = await execute("systemctl", [...prefix, "is-active", slaveServiceName]);
-      return { running: result.stdout.trim() === "active", status: result.stdout.trim() };
+      return { running: result.stdout.trim() === "active", status: result.stdout.trim(), serviceManager: "systemd" };
     } catch {
-      return { running: false, status: "inactive" };
+      return { running: false, status: "inactive", serviceManager: "systemd" };
     }
   }
-  if (!["start", "stop", "restart"].includes(operation)) throw new Error(`Unsupported Slave service operation: ${operation}`);
   await execute("systemctl", [...prefix, operation, slaveServiceName]);
-  return { ok: true, operation };
+  return { ok: true, operation, serviceManager: "systemd" };
+}
+
+async function launchdIsLoaded(serviceTarget, execute) {
+  try {
+    await execute("launchctl", ["print", serviceTarget]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function controlLaunchdService(descriptor, operation, execute) {
+  const serviceTarget = descriptor.serviceTarget;
+  const unitFile = descriptor.unitFile;
+  const domain = serviceTarget?.slice(0, serviceTarget.lastIndexOf("/"));
+  if (!serviceTarget || !unitFile || !domain) throw new Error("Arisa Slave launchd descriptor is incomplete");
+  const loaded = await launchdIsLoaded(serviceTarget, execute);
+  if (operation === "status") {
+    return { running: loaded, status: loaded ? "active" : "inactive", serviceManager: "launchd" };
+  }
+  if (operation === "stop") {
+    if (loaded) await execute("launchctl", ["bootout", serviceTarget]);
+    return { ok: true, operation, serviceManager: "launchd" };
+  }
+  if (!loaded) await execute("launchctl", ["bootstrap", domain, unitFile]);
+  await execute("launchctl", ["enable", serviceTarget]);
+  await execute("launchctl", ["kickstart", ...(operation === "restart" ? ["-k"] : []), serviceTarget]);
+  return { ok: true, operation, serviceManager: "launchd" };
+}
+
+async function registeredSlavePidIsAlive(paths) {
+  try {
+    const pid = Number.parseInt((await readFile(paths.pidFile, "utf8")).trim(), 10);
+    if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function controlWindowsTask(paths, descriptor, operation, execute) {
+  const taskName = descriptor.serviceTarget || slaveWindowsTaskName;
+  if (operation === "status") {
+    try {
+      await execute("schtasks.exe", ["/Query", "/TN", taskName]);
+      const running = await registeredSlavePidIsAlive(paths);
+      return { running, status: running ? "active" : "inactive", serviceManager: "windows-task" };
+    } catch {
+      return { running: false, status: "not-installed", serviceManager: "windows-task" };
+    }
+  }
+  if (operation === "stop" || operation === "restart") {
+    await execute("schtasks.exe", ["/End", "/TN", taskName]).catch(() => {});
+  }
+  if (operation === "start" || operation === "restart") {
+    await execute("schtasks.exe", ["/Run", "/TN", taskName]);
+  }
+  return { ok: true, operation, serviceManager: "windows-task" };
+}
+
+export async function controlSlaveService(paths, operation, { execute = runCommand } = {}) {
+  if (!["start", "stop", "restart", "status"].includes(operation)) throw new Error(`Unsupported Slave service operation: ${operation}`);
+  const descriptor = await readSlaveServiceDescriptor(paths);
+  if (descriptor.serviceManager === "launchd") return controlLaunchdService(descriptor, operation, execute);
+  if (descriptor.serviceManager === "windows-task") return controlWindowsTask(paths, descriptor, operation, execute);
+  return controlSystemdService(descriptor, operation, execute);
 }
 
 export async function registerSlaveServiceProcess(paths) {

package/src/runtime/tui.js

@@ -126,8 +126,8 @@ function requiresProviderAuth(model) {
 export async function createArisaTuiRuntime({ config, client, logger } = {}) {
   const chatId = resolveTuiChatId(config);
   const policy = buildPiToolPolicy({ config, customToolNames: tuiToolNames });
-  const piRuntime = createPiRuntime({ provider: config.pi.provider, apiKey: config.pi.apiKey });
-  const model = piRuntime.modelRegistry.find(config.pi.provider, config.pi.model);
+  const piRuntime = await createPiRuntime({ provider: config.pi.provider, apiKey: config.pi.apiKey });
+  const model = piRuntime.getModel(config.pi.provider, config.pi.model);
   if (!model) throw new Error(`Model not found: ${config.pi.provider}/${config.pi.model}`);
   if (requiresProviderAuth(model) && !config.pi.apiKey && !hasProviderAuth(config.pi.provider, piRuntime)) {
     throw new Error(`No auth found for ${config.pi.provider}. Complete Arisa bootstrap first.`);
@@ -141,8 +141,7 @@ export async function createArisaTuiRuntime({ config, client, logger } = {}) {
     const services = await createAgentSessionServices({
       cwd,
       agentDir: arisaHomeDir,
-      authStorage: piRuntime.authStorage,
-      modelRegistry: piRuntime.modelRegistry,
+      modelRuntime: piRuntime,
       settingsManager,
       resourceLoaderOptions: {
         agentsFilesOverride: (current) => appendArisaAgentsFile(current, arisaAgentsContent)
@@ -158,8 +157,8 @@ export async function createArisaTuiRuntime({ config, client, logger } = {}) {
       excludeTools: policy.excludeTools,
       customTools
     });
-    const speedController = createModelSpeedController(created.session.agent.streamFn, config.pi.speed);
-    created.session.agent.streamFn = speedController.streamFn;
+    const speedController = createModelSpeedController(created.session.agent.streamFunction, config.pi.speed);
+    created.session.agent.streamFunction = speedController.streamFn;
     logger?.log("tui", `opened ${created.session.sessionFile || "in-memory session"} for owner scope ${chatId}`);
     return { ...created, services, diagnostics: services.diagnostics };
   };

package/src/transport/telegram/bot.js

@@ -335,7 +335,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     timer.unref?.();
   }
 
-  async function enqueueAsyncPrompt({ chatId, prompt, label, route: taskRoute, timeoutMs, priority = "background", queueTtlMs = undefined }) {
+  async function enqueueAsyncPrompt({ chatId, prompt, label, route: taskRoute, timeoutMs, priority = "background", queueTtlMs = undefined, agentTaskExecution = null }) {
     let ctx = { chat: { id: chatId }, api: bot.api };
     const destination = taskRoute?.transport === "telegram" ? taskRoute.destination : null;
     if (destination?.chatId && destination?.threadId) {
@@ -349,7 +349,11 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       if (!route.ok) throw new Error("Scheduled owner-workspace destination is unavailable.");
       registerRoute(ctx, route);
     }
-    const route = contextRoute(ctx);
+    const route = {
+      ...contextRoute(ctx),
+      ...(agentTaskExecution ? { agentTaskExecution } : {})
+    };
+    registerRoute(ctx, route);
     const chatState = getChatState(route.sessionId);
     if (chatState.processing) await ensureQueuedTelegramTyping(chatState, ctx);
     let timer = null;
@@ -409,7 +413,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     const auth = await authorizeContext(ctx);
     if (!auth.ok) return;
     if (authController.getIssue()) {
-      await ctx.reply(authController.buildBlockedMessage(ctx.chat.id));
+      await ctx.reply(await authController.buildBlockedMessage(ctx.chat.id));
       return;
     }
     await handleNewCommand(ctx);
@@ -536,7 +540,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     if (await authController.submitRenewalInput(ctx)) return;
 
     if (authController.getIssue()) {
-      await ctx.reply(authController.buildBlockedMessage(ctx.chat.id));
+      await ctx.reply(await authController.buildBlockedMessage(ctx.chat.id));
       return;
     }
 
@@ -548,7 +552,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       if (wasPromptErrorNotified(error)) return;
       const issue = getPiAuthIssue(error);
       await ctx.reply(issue
-        ? buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, issue })
+        ? await buildPiAuthTelegramMessage({ config, chatId: ctx.chat.id, issue })
         : getErrorMessage(error));
     });
   });

package/src/transport/telegram/model-callback.js

@@ -1,7 +1,7 @@
 import { getErrorMessage } from "../../core/agent/auth-flow.js";
 import { resolveChatModel, resolveChatSpeed, resolveChatThinkingLevel } from "../../core/agent/model-selection.js";
 import { clampModelThinkingLevel, listModelThinkingLevels, modelSupportsThinking } from "../../core/agent/pi-runtime.js";
-import { modelSupportsSpeed } from "../../core/agent/model-speed.js";
+import { clampModelSpeed, modelSupportsSpeed } from "../../core/agent/model-speed.js";
 import { parseEffortPickerAction, parseModelPickerAction, parseSpeedPickerAction } from "./model-picker.js";
 
 export async function closeModelPicker(ctx, { messageText, callbackText }) {
@@ -181,9 +181,10 @@ export function createTelegramModelCallbackHandler({
           return;
         }
         if (!modelSupportsSpeed(model)) {
-          await ctx.answerCallbackQuery({ text: "This model does not support speed 1.5x.", show_alert: true });
+          await ctx.answerCallbackQuery({ text: "This model does not support fast mode.", show_alert: true });
           return;
         }
+        action.speed = clampModelSpeed(model, action.speed);
         const currentSpeed = resolveChatSpeed(config, modelChatId);
         if (action.speed === currentSpeed) {
           await closeModelPicker(ctx, {

package/src/transport/telegram/model-controls.js

@@ -8,7 +8,7 @@ import {
   selectChatThinkingLevel
 } from "../../core/agent/model-selection.js";
 import { clampModelThinkingLevel, createPiRuntime, listModelThinkingLevels, listProviderModels, modelSupportsThinking } from "../../core/agent/pi-runtime.js";
-import { clampModelSpeed, MODEL_SPEEDS, modelSupportsSpeed } from "../../core/agent/model-speed.js";
+import { clampModelSpeed, listModelSpeeds, modelSupportsSpeed } from "../../core/agent/model-speed.js";
 import { buildEffortPicker, buildModelPicker, buildSpeedPicker, reverseModelOrder } from "./model-picker.js";
 
 function chatKey(chatId) {
@@ -40,7 +40,7 @@ function restorePreviousSelection(agentConfig, key, hadSelections, previousSelec
 
 export function createTelegramModelControls({ config, saveConfig, agentManager, contextRoute }) {
   async function getProviderModels() {
-    const runtime = createPiRuntime({
+    const runtime = await createPiRuntime({
       provider: config.pi.provider,
       apiKey: config.pi.apiKey
     });
@@ -89,12 +89,12 @@ export function createTelegramModelControls({ config, saveConfig, agentManager,
     const model = models.find((item) => item.id === resolveChatModel(config, route.sessionId));
     if (!model) throw new Error(`Model not found for provider ${agentConfig.provider}`);
     if (!modelSupportsSpeed(model)) {
-      return editOrReplyText(ctx, `${model.provider}/${model.id} does not support speed 1.5x.`);
+      return editOrReplyText(ctx, `${model.provider}/${model.id} does not support fast mode.`);
     }
     const picker = buildSpeedPicker({
       provider: model.provider,
       modelId: model.id,
-      speeds: MODEL_SPEEDS,
+      speeds: listModelSpeeds(model),
       selectedSpeed: resolveChatSpeed(config, route.sessionId)
     });
     return editOrReplyPicker(ctx, picker);

package/src/transport/telegram/model-picker.js

@@ -37,7 +37,7 @@ export function parseEffortPickerAction(data) {
 
 export function parseSpeedPickerAction(data) {
   if (data === "noop:page") return { type: "noop", value: null };
-  const speed = /^speed:(1(?:\.5)?)$/.exec(String(data || ""));
+  const speed = /^speed:(1(?:\.5)?|2)$/.exec(String(data || ""));
   return speed ? { type: "speed", speed: Number(speed[1]) } : null;
 }
 

package/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 }));
     }
   }