arisa 5.2.7 → 5.2.19

package/src/runtime/slave-cli.js

@@ -11,7 +11,7 @@ import { withSecureRequestFile } from "./secure-request-file.js";
 import {
   controlSlaveService,
   getSlavePaths,
-  installSlaveSystemdService,
+  installSlaveService,
   isSlaveToolInstalled,
   readSlaveServiceDescriptor,
   registerSlaveServiceProcess,
@@ -138,11 +138,13 @@ function parseSlaveToolOutput(result) {
   return result?.output && typeof result.output === "object" ? result.output : result;
 }
 
-export function formatSlaveStatus({ systemd, diagnostic }) {
+export function formatSlaveStatus({ service, systemd, diagnostic }) {
+  const serviceStatus = service || systemd;
+  const manager = serviceStatus?.serviceManager || (systemd ? "systemd" : "service");
   const jobs = diagnostic?.jobs && typeof diagnostic.jobs === "object" ? diagnostic.jobs : {};
   return [
     "Arisa Slave status",
-    `Systemd: ${systemd.running ? "active" : systemd.status || "inactive"}`,
+    `Service (${manager}): ${serviceStatus?.running ? "active" : serviceStatus?.status || "inactive"}`,
     `Daemon: ${diagnostic?.daemon?.state || diagnostic?.daemonState || "unknown"}`,
     `Role: ${diagnostic?.role || "unknown"}`,
     `Endpoint: ${diagnostic?.endpoint || "not configured"}`,
@@ -167,14 +169,14 @@ export async function runSlaveBootstrap(url, {
   paths = getSlavePaths(resolveSlaveHome()),
   selectAccount = selectSlaveServiceAccount,
   ensureTool = ensureMasterSlaveTool,
-  installService = installSlaveSystemdService,
+  installService = installSlaveService,
   invokeTool = invokeSlaveTool,
   entryFile,
   output = console,
   platform = process.platform
 } = {}) {
   parseSlaveBootstrapUrl(url);
-  if (platform !== "linux") throw new Error("Arisa Slave service installation currently requires Linux with systemd");
+  if (!["linux", "darwin", "win32"].includes(platform)) throw new Error(`Arisa Slave service installation is not supported on ${platform}`);
   const account = await selectAccount();
   await ensureSlaveConfig(paths);
   await ensureTool(paths);
@@ -188,8 +190,16 @@ export async function runSlaveBootstrap(url, {
   } catch (error) {
     throw explainSlaveBootstrapError(error);
   }
-  await installService({ account, slaveHome: paths.home, entryFile });
-  await writeSlaveServiceDescriptor(paths, { version: 1, account, installedAt: new Date().toISOString() });
+  const installedService = await installService({ account, slaveHome: paths.home, entryFile, platform });
+  await writeSlaveServiceDescriptor(paths, {
+    version: 1,
+    account,
+    serviceManager: installedService?.serviceManager || ({ darwin: "launchd", win32: "windows-task" }[platform] || "systemd"),
+    serviceTarget: installedService?.serviceTarget || null,
+    unitFile: installedService?.unitFile || null,
+    launcherFile: installedService?.launcherFile || null,
+    installedAt: new Date().toISOString()
+  });
   output.log(`Arisa Slave paired and running as ${account.user}${account.root ? " (root)" : ""}.`);
   return result;
 }
@@ -240,12 +250,12 @@ export async function runSlaveCli({
   }
   if (action === "status") {
     if (positionals.length !== 1) throw new Error("arisa slave status does not accept additional arguments");
-    const systemd = await controlService(paths, "status");
+    const service = await controlService(paths, "status");
     const diagnostic = await toolInstalled(paths, toolName)
       ? parseSlaveToolOutput(await invokeTool(paths, { action: "slave.status" }))
       : { daemonState: "not-installed", role: "slave", paired: false, toolCount: 0, pendingSecrets: 0 };
-    output.log(formatSlaveStatus({ systemd, diagnostic }));
-    return { systemd, diagnostic };
+    output.log(formatSlaveStatus({ service, diagnostic }));
+    return { service, diagnostic };
   }
   if (action === "log") {
     if (positionals.length !== 1) throw new Error("arisa slave log does not accept additional arguments");

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/tool-process-supervisor.js

@@ -9,6 +9,7 @@ import {
 } from "../core/tools/daemon-processes.js";
 import { loadDaemonPolicy } from "../core/tools/daemon-policy.js";
 import { ensureArisaHome } from "../platform/paths.js";
+import { reapObsoleteDaemon } from "./obsolete-daemon-reaper.js";
 
 async function fileExists(file) {
   try {
@@ -58,7 +59,12 @@ function validateRegistration(record, toolRegistry) {
   };
 }
 
-export function createToolProcessSupervisor({ logger, policy, toolRegistry } = {}) {
+export function createToolProcessSupervisor({
+  logger,
+  policy,
+  toolRegistry,
+  obsoleteDaemonReaper = reapObsoleteDaemon
+} = {}) {
   let running = false;
   let timer = null;
   let reconciliation = null;
@@ -75,13 +81,34 @@ export function createToolProcessSupervisor({ logger, policy, toolRegistry } = {
     for (const registeredRecord of await listRegisteredDaemons()) {
       const validation = validateRegistration(registeredRecord, toolRegistry);
       if (!validation.valid) {
-        logger?.log("tools", `skipping stale daemon registration ${registeredRecord.toolName} (${registeredRecord.instanceId || "global"}): ${validation.reason}`);
-        results.push({
-          record: registeredRecord,
-          outcome: "stale-registration",
-          reason: validation.reason,
-          diagnostic: await readDaemonDiagnostic(registeredRecord)
-        });
+        const diagnostic = await readDaemonDiagnostic(registeredRecord);
+        try {
+          const result = await obsoleteDaemonReaper({
+            record: registeredRecord,
+            diagnostic,
+            reason: validation.reason,
+            timeoutMs: daemonPolicy.healthTimeoutMs,
+            stopTimeoutMs: daemonPolicy.stopTimeoutMs
+          });
+          results.push(result);
+          const key = `${registeredRecord.toolName}:${registeredRecord.instanceId || "global"}`;
+          const message = result.outcome === "obsolete-removed"
+            ? `removed obsolete daemon ${registeredRecord.toolName} (${registeredRecord.instanceId || "global"}): ${validation.reason}`
+            : `left obsolete daemon ${registeredRecord.toolName} (${registeredRecord.instanceId || "global"}) untouched because process identity could not be verified`;
+          if (reportedDiagnostics.get(key) !== message) {
+            reportedDiagnostics.set(key, message);
+            logger?.log("tools", message);
+          }
+        } catch (error) {
+          logger?.error?.("tools", `obsolete daemon cleanup failed for ${registeredRecord.toolName}: ${error?.message || error}`);
+          results.push({
+            record: registeredRecord,
+            outcome: "obsolete-cleanup-error",
+            reason: validation.reason,
+            diagnostic,
+            error: error?.message || String(error)
+          });
+        }
         continue;
       }
       const record = validation.record;

package/src/runtime/tui.js

@@ -106,7 +106,7 @@ export function createTuiCapabilityTools(client) {
     defineTool({
       name: "cancel_all_scheduled_tasks",
       label: "Cancel all scheduled tasks",
-      description: "Cancel all pending or running owner-scoped Arisa tasks.",
+      description: "Cancel all active owner-scoped Arisa tasks, including authentication-blocked tasks.",
       parameters: Type.Object({}),
       execute: async () => jsonResult(await client.tasks.cancelAll())
     })
@@ -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 }) {
+  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;
@@ -359,6 +363,8 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       label,
       ctx,
       waitForExecution: true,
+      turnPriority: priority,
+      turnQueueTtlMs: queueTtlMs,
       onExecutionStart: ({ reject }) => {
         if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return;
         timer = setTimeout(() => {
@@ -407,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);
@@ -534,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;
     }
 
@@ -546,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/chat-queue.js

@@ -31,7 +31,7 @@ export function createChatStateStore() {
   };
 }
 
-export function createPromptExecutionReceipt(onStart = null) {
+export function createPromptExecutionReceipt(onStart = null, metadata = {}) {
   let resolve;
   let reject;
   let started = false;
@@ -43,6 +43,10 @@ export function createPromptExecutionReceipt(onStart = null) {
     promise,
     resolve,
     reject,
+    priority: metadata.priority || "background",
+    label: String(metadata.label || "scheduled agent turn"),
+    queueTtlMs: metadata.queueTtlMs,
+    deferStart: metadata.deferStart === true,
     start() {
       if (started) return;
       started = true;
@@ -179,7 +183,7 @@ export async function drainChatPromptQueue({
         chatState.continueAfterClose = false;
       }
       try {
-        currentReceipt?.start?.();
+        if (!currentReceipt?.deferStart) currentReceipt?.start?.();
         await processPrompt({ prompt: currentPrompt, ctx: currentCtx, receipt: currentReceipt });
         currentReceipt?.resolve({ status: "completed" });
       } catch (error) {

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

@@ -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
     });