arisa 5.2.7 → 5.2.19

package/README.md

@@ -108,7 +108,7 @@ Per chat (`~/.arisa/chats/<chatId>/`):
 - chat-scoped daemon infrastructure lives in `state/tools/<tool>/daemon/`; persistent tool data stays beside it
 - ephemeral scratch lives under `tmp/`
 
-Managed daemons become ready only after their tool-defined health operation succeeds through the normal command queue. Arisa records heartbeats, successful jobs, errors, and standard lifecycle states, then retries recovery or recreates an unhealthy process with its persisted scope and startup context.
+Managed daemons become ready only after their tool-defined health operation succeeds through the normal command queue. Arisa records heartbeats, successful jobs, errors, and standard lifecycle states, then retries recovery or recreates an unhealthy process with its persisted scope and startup context. The supervisor automatically removes registrations and daemon runtime directories that no longer match an installed daemon tool. A live process is terminated only when its command line matches the registered entry and daemon invocation; unverifiable PIDs are left untouched and reported for attention.
 
 Daemon tools may opt into the `arisa-daemon-v1` local protocol for immediate
 multiplexed jobs and incremental NDJSON events over a capability-protected local
@@ -127,8 +127,10 @@ Slave runs only the IPC host, daemon supervisor and installed tools. Connections
 are authenticated, encrypted, initiated by Slave and restricted by per-Slave
 roots and capability grants.
 
-Linux with systemd is the first supported Slave target. Bootstrap uses a
-single-use URL issued by Master:
+Arisa Slave supports Linux with systemd, macOS with launchd, and Windows with
+Task Scheduler. On desktop systems, run bootstrap as the normal user so the
+persistent background task retains access to that user's browser profile.
+Bootstrap uses a single-use URL issued by Master:
 
 ```bash
 npm i -g arisa && arisa slave tcp://198.51.100.12:4719/arisa_secret_v1_<secret>
@@ -151,12 +153,31 @@ Automatic context compaction uses Pi's native implementation and can be tuned in
       "enabled": true,
       "reserveTokens": 120000,
       "keepRecentTokens": 20000
+    },
+    "sessionRotation": {
+      "enabled": true,
+      "compactAtPersistedBytes": 25165824,
+      "maxPersistedBytes": 33554432
+    },
+    "toolFanout": {
+      "enabled": true,
+      "maxConcurrent": 2,
+      "pressureConcurrent": 1,
+      "serializePercent": 60
+    },
+    "turnCoordinator": {
+      "enabled": true,
+      "backgroundQueueTtlMs": 600000,
+      "interactiveQueueTtlMs": 0,
+      "maxQueued": 100
     }
   }
 }
 ```
 
-Pi compacts when the context exceeds the model's context window minus `reserveTokens`. The default keeps a large reserve so compaction occurs before Arisa Doctor's context warning on the default model. Set a smaller reserve when using models with substantially smaller context windows. Arisa does not add Telegram commands or compaction notifications.
+Pi compacts when the context exceeds the model's context window minus `reserveTokens`. Arisa also requests compaction when persisted history exceeds `compactAtPersistedBytes`, then rotates to a fresh JSONL using the latest summary and retained active context. Before Pi loads a recent session above `maxPersistedBytes`, Arisa discovers the last valid active-branch compaction by streaming, atomically creates a compact child with `parentSession`, and leaves the historical JSONL intact. An unsafe oversized session is rejected rather than loaded into an OOM-prone worker. Same-turn `run_tool` fan-out is capped at two, becomes sequential when heap usage reaches `serializePercent`, and uses the heap circuit breaker before every admission. Across chats and topics, `turnCoordinator` admits only one Pi turn or headless poll at a time, prioritizes interactive messages and events over queued background work, and safely expires stale background admissions before execution. Set a smaller token reserve when using models with substantially smaller context windows. Arisa adds no Telegram commands or compaction notifications.
+
+Browser and checkout tools report lifecycle states separately: profile connection is not a session share, a session share is not target validation, wallet enrollment is not checkout submission, and only explicit target or merchant evidence can confirm the final objective.
 
 ## Install globally
 

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "arisa",
-  "version": "5.2.7",
+  "version": "5.2.19",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",
   "bin": {
     "arisa": "bin/arisa.js"
   },
+  "scripts": {
+    "start": "node src/index.js",
+    "bootstrap": "node src/index.js --bootstrap",
+    "test": "node --test"
+  },
   "keywords": [
     "telegram",
     "pi-agent",
@@ -29,7 +34,7 @@
   "author": "Martin Clasen",
   "license": "MIT",
   "engines": {
-    "node": ">=22.8.0"
+    "node": ">=22.19.0"
   },
   "repository": {
     "type": "git",
@@ -39,14 +44,10 @@
     "url": "https://github.com/clasen/Arisa/issues"
   },
   "homepage": "https://arisa.sh",
+  "packageManager": "pnpm@11.3.0+sha512.2c403d6594527287672b1f7056343a1f7c3634036a67ffabfcc2b3d7595d843768f8787148d1b57cf7956c90606bbd192857c363af19e96d2d0ec9ec5741d215",
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "0.80.6",
+    "@earendil-works/pi-coding-agent": "0.85.1",
     "@sinclair/typebox": "^0.34.41",
     "grammy": "^1.42.0"
-  },
-  "scripts": {
-    "start": "node src/index.js",
-    "bootstrap": "node src/index.js --bootstrap",
-    "test": "node --test"
   }
-}
+}

package/pnpm-workspace.yaml

@@ -1,11 +1,13 @@
 allowBuilds:
   '@google/genai': false
+  esbuild: true
 
 minimumReleaseAgeExclude:
-  - '@earendil-works/pi-agent-core@0.80.6'
-  - '@earendil-works/pi-ai@0.80.6'
-  - '@earendil-works/pi-coding-agent@0.80.6'
-  - '@earendil-works/pi-tui@0.80.6'
+  - '@earendil-works/pi-agent-core@0.85.1'
+  - '@earendil-works/pi-ai@0.85.1'
+  - '@earendil-works/pi-coding-agent@0.85.1'
+  - '@earendil-works/pi-tui@0.85.1'
+  - '@earendil-works/chord@0.85.1'
 
 overrides:
   'node-fetch@2.7.0>whatwg-url': '13.0.0'
@@ -14,7 +16,7 @@ overrides:
   basic-ftp@<=5.2.2: '>=5.3.0'
   basic-ftp@<=5.3.0: '>=5.3.1'
   basic-ftp@=5.2.0: '>=5.2.1'
-  brace-expansion@>=5.0.0 <5.0.6: '>=5.0.6'
+  brace-expansion@>=4.0.0 <5.0.9: '5.0.9'
   ip-address@<=10.1.0: '>=10.1.1'
   protobufjs@<7.5.5: '>=7.5.5'
   protobufjs@<=7.5.5: '>=7.5.6'

package/src/core/agent/agent-manager.js

@@ -14,6 +14,9 @@ import { createPiCapabilityTools } from "./pi-capability-tools.js";
 import { ToolResourceNoteStore } from "../tools/tool-resource-note-store.js";
 import { materializeToolOutput } from "../tools/tool-output-materializer.js";
 import { WorkerHeapCircuitBreaker } from "./worker-heap-circuit-breaker.js";
+import { WorkerToolFanoutController } from "./worker-tool-fanout.js";
+import { compactionRotationRequest, normalizeSessionRotationPolicy } from "./session-rotation.js";
+import { AgentTurnCoordinator } from "./agent-turn-coordinator.js";
 
 const piValidationTimeoutMs = 60_000;
 const arisaToolNames = [
@@ -156,13 +159,23 @@ export class AgentManager {
     this.sessionLifecycle = new AgentSessionLifecycle({
       logger,
       summarizeContext: summarizeRetainedContext,
-      cachePolicy: config.pi.sessionCache
+      cachePolicy: config.pi.sessionCache,
+      sessionRotationPolicy: config.pi.sessionRotation
     });
     this.heapCircuitBreaker = new WorkerHeapCircuitBreaker({
       lifecycle: this.sessionLifecycle,
       logger,
       config: config.pi.heapCircuitBreaker
     });
+    this.toolFanout = new WorkerToolFanoutController({
+      heapCircuitBreaker: this.heapCircuitBreaker,
+      logger,
+      config: config.pi.toolFanout
+    });
+    this.turnCoordinator = new AgentTurnCoordinator({
+      logger,
+      config: config.pi.turnCoordinator
+    });
     this.sessions = this.sessionLifecycle.sessions;
     this.pendingNewSessions = this.sessionLifecycle.pendingNewSessions;
     this.pendingSessionHandoffs = this.sessionLifecycle.pendingSessionHandoffs;
@@ -196,7 +209,10 @@ export class AgentManager {
   setConfig(config) {
     this.sessionLifecycle.resetConfigState();
     this.sessionLifecycle.setCachePolicy(config.pi.sessionCache);
+    this.sessionLifecycle.setSessionRotationPolicy(config.pi.sessionRotation);
     this.heapCircuitBreaker.setConfig(config.pi.heapCircuitBreaker);
+    this.toolFanout.setConfig(config.pi.toolFanout);
+    this.turnCoordinator.setConfig(config.pi.turnCoordinator);
     this.config = config;
   }
 
@@ -222,7 +238,9 @@ export class AgentManager {
     const diagnostic = await this.sessionLifecycle.getDiagnostic();
     return {
       ...diagnostic,
-      heapCircuitBreaker: this.heapCircuitBreaker.getDiagnostic()
+      heapCircuitBreaker: this.heapCircuitBreaker.getDiagnostic(),
+      toolFanout: this.toolFanout.getDiagnostic(),
+      turnCoordinator: this.turnCoordinator.diagnostic()
     };
   }
 
@@ -249,31 +267,77 @@ export class AgentManager {
     return context;
   }
 
+  async compactPersistedSessionIfNeeded(sessionKey, context, persistedBytes) {
+    const policy = normalizeSessionRotationPolicy(this.config.pi.sessionRotation);
+    if (!policy.enabled
+      || persistedBytes <= policy.compactAtPersistedBytes
+      || context.rotationRequest
+      || typeof context.session?.compact !== "function") return;
+    try {
+      this.logger?.log("agent", `compacting ${Math.ceil(persistedBytes / 1024 / 1024)} MiB Pi session for chat ${sessionKey} before rotation`);
+      await context.session.compact();
+      await context.rotationCheckPromise;
+    } catch (error) {
+      this.logger?.error?.("agent", `persisted-size compaction failed for chat ${sessionKey}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
   async releaseSessionContext(sessionKey, context) {
     if (this.sessions.get(String(sessionKey)) !== context) return;
+    await context.rotationCheckPromise;
     const persistedBytes = await this.estimatePersistedSessionBytes(context.session);
+    if ((context.activeUsers || 0) <= 1) {
+      await this.compactPersistedSessionIfNeeded(sessionKey, context, persistedBytes);
+    }
     this.sessionLifecycle.releaseCached(sessionKey, persistedBytes);
+    if ((context.activeUsers || 0) === 0 && context.rotationRequest) {
+      const request = context.rotationRequest;
+      const parentSession = context.session.sessionFile || "";
+      this.logger?.log("agent", `rotating ${Math.ceil(request.persistedBytes / 1024 / 1024)} MiB Pi session for chat ${sessionKey} after compaction`);
+      this.sessionLifecycle.resetSession(sessionKey, {
+        handoff: request.handoff,
+        parentSession,
+        source: "compaction-rotation"
+      });
+      await this.sessionLifecycle.waitForClose(sessionKey);
+      return;
+    }
     await this.sessionLifecycle.enforceCachePolicy();
   }
 
+  scheduleCompactionRotationCheck(sessionKey, context, event) {
+    if (event?.type !== "compaction_end") return;
+    const previous = context.rotationCheckPromise || Promise.resolve();
+    context.rotationCheckPromise = previous
+      .catch(() => {})
+      .then(async () => {
+        if (this.sessions.get(String(sessionKey)) !== context) return;
+        const persistedBytes = await this.estimatePersistedSessionBytes(context.session);
+        const request = compactionRotationRequest(event, persistedBytes, this.config.pi.sessionRotation);
+        if (request) context.rotationRequest = request;
+      })
+      .catch((error) => {
+        this.logger?.error?.("agent", `session rotation check failed for chat ${sessionKey}: ${error instanceof Error ? error.message : String(error)}`);
+      });
+  }
+
   async validatePiAgent(config = this.config) {
     this.logger?.log("agent", "validating Pi session");
-    const { authStorage, modelRegistry } = createPiRuntime({
+    const modelRuntime = await createPiRuntime({
       provider: config.pi.provider,
       apiKey: config.pi.apiKey
     });
-    const model = modelRegistry.find(config.pi.provider, config.pi.model);
+    const model = modelRuntime.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, { authStorage, modelRegistry })) {
+    if (requiresProviderAuth(model) && !config.pi.apiKey && !hasProviderAuth(config.pi.provider, modelRuntime)) {
       throw new Error(`No auth found for ${config.pi.provider}. Provide a Pi API key in bootstrap, or authenticate with Pi login for this provider during bootstrap.`);
     }
 
     const settingsManager = createPiSettingsManager(config);
     const { session } = await createAgentSession({
-      authStorage,
-      modelRegistry,
+      modelRuntime,
       model,
       settingsManager,
       sessionManager: SessionManager.inMemory()
@@ -321,13 +385,13 @@ export class AgentManager {
       this.pendingNewSessions.add(sessionKey);
     }
 
-    const { authStorage, modelRegistry } = createPiRuntime({
+    const modelRuntime = await createPiRuntime({
       provider: this.config.pi.provider,
       apiKey: this.config.pi.apiKey
     });
-    const model = modelRegistry.find(this.config.pi.provider, effectiveModelId);
+    const model = modelRuntime.getModel(this.config.pi.provider, effectiveModelId);
     if (!model) throw new Error(`Model not found: ${this.config.pi.provider}/${effectiveModelId}`);
-    if (requiresProviderAuth(model) && !this.config.pi.apiKey && !hasProviderAuth(this.config.pi.provider, { authStorage, modelRegistry })) {
+    if (requiresProviderAuth(model) && !this.config.pi.apiKey && !hasProviderAuth(this.config.pi.provider, modelRuntime)) {
       throw new Error(`No auth found for ${this.config.pi.provider}. Re-run bootstrap and complete login for this provider before Telegram starts.`);
     }
     const thinkingLevel = clampModelThinkingLevel(model, modelSelection.thinkingLevel);
@@ -353,7 +417,8 @@ export class AgentManager {
       initializeForumTopic: (...args) => telegramTarget.current.initializeForumTopic(...args),
       prepareRestartReceipt: (...args) => telegramTarget.current.prepareRestartReceipt(...args),
       cancelRestartReceipt: (...args) => telegramTarget.current.cancelRestartReceipt(...args),
-      getTaskContext: (...args) => telegramTarget.current.getTaskContext?.(...args) || null
+      getTaskContext: (...args) => telegramTarget.current.getTaskContext?.(...args) || null,
+      getAgentTaskExecution: (...args) => telegramTarget.current.getAgentTaskExecution?.(...args) || null
     };
     const assertAccess = () => accessGuardTarget.current();
     const customTools = guardTools([
@@ -375,8 +440,7 @@ export class AgentManager {
       cwd: policy.workspaceDir,
       agentDir: arisaHomeDir,
       resourceLoader,
-      authStorage,
-      modelRegistry,
+      modelRuntime,
       model,
       thinkingLevel,
       tools: policy.tools,
@@ -385,8 +449,8 @@ export class AgentManager {
       settingsManager,
       sessionManager
     });
-    const speedController = createModelSpeedController(session.agent.streamFn, speed);
-    session.agent.streamFn = speedController.streamFn;
+    const speedController = createModelSpeedController(session.agent.streamFunction, speed);
+    session.agent.streamFunction = speedController.streamFn;
 
     if (!hasExistingSession) {
       this.logger?.log("agent", `created new session for chat ${sessionKey}`);
@@ -402,8 +466,11 @@ export class AgentManager {
       modelKey: effectiveModelKey,
       speedController,
       telegramTarget,
-      accessGuardTarget
+      accessGuardTarget,
+      rotationCheckPromise: Promise.resolve(),
+      rotationRequest: null
     };
+    session.subscribe((event) => this.scheduleCompactionRotationCheck(sessionKey, ctx, event));
     this.sessions.set(sessionKey, ctx);
     if (isNewSession) this.sessionLifecycle.completeNewSession(sessionKey);
     return this.acquireSessionContext(sessionKey, ctx);
@@ -411,7 +478,7 @@ export class AgentManager {
 
   async getAvailableModels(chatId) {
     const { listProviderModels } = await import("./pi-runtime.js");
-    const runtime = createPiRuntime({ provider: this.config.pi.provider, apiKey: this.config.pi.apiKey });
+    const runtime = await createPiRuntime({ provider: this.config.pi.provider, apiKey: this.config.pi.apiKey });
     return listProviderModels(this.config.pi.provider, runtime);
   }
 
@@ -424,9 +491,15 @@ export class AgentManager {
   }
 
   async close() {
+    this.turnCoordinator.close();
     await this.sessionLifecycle.closeAll();
   }
 
+  async runTurn(options, work) {
+    if (typeof work !== "function") throw new Error("Agent turn work is required");
+    return this.turnCoordinator.run(options, work);
+  }
+
   async runTool({ name, request, chatId, taskContext = null }) {
     await this.toolRegistry.load();
     this.logger?.log("agent", `run_tool ${name}`);
@@ -453,7 +526,8 @@ export class AgentManager {
       telegram,
       chatId,
       policy,
-      logger: this.logger
+      logger: this.logger,
+      toolFanout: this.toolFanout
     });
   }
 

package/src/core/agent/agent-session-lifecycle.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { getChatPiSessionsDir, sessionStartOperationalNotesFile } from "../../platform/paths.js";
 import { arisaInstallDir } from "./runtime-context.js";
+import { migrateRecentSessionBeforeLoad } from "./session-preload-migration.js";
 
 const operationalNoteMaxChars = 220;
 
@@ -26,7 +27,7 @@ export function loadSessionStartOperationalNotes() {
   }
 }
 
-function formatSessionStartOperationalNotes(notes) {
+export function formatSessionStartOperationalNotes(notes) {
   if (!notes.length) return "";
   return [
     "Durable operating notes for this Arisa session:",
@@ -41,7 +42,7 @@ function closeAgentSession(session) {
 }
 
 export class AgentSessionLifecycle {
-  constructor({ logger, summarizeContext, cachePolicy = {} }) {
+  constructor({ logger, summarizeContext, cachePolicy = {}, sessionRotationPolicy = {} }) {
     this.logger = logger;
     this.summarizeContext = summarizeContext;
     this.sessions = new Map();
@@ -49,6 +50,7 @@ export class AgentSessionLifecycle {
     this.pendingSessionHandoffs = new Map();
     this.sessionClosePromises = new Map();
     this.setCachePolicy(cachePolicy);
+    this.setSessionRotationPolicy(sessionRotationPolicy);
   }
 
   setCachePolicy(cachePolicy = {}) {
@@ -58,6 +60,10 @@ export class AgentSessionLifecycle {
     };
   }
 
+  setSessionRotationPolicy(policy = {}) {
+    this.sessionRotationPolicy = { ...policy };
+  }
+
   acquireCached(sessionKey, persistedBytes = 0) {
     const context = this.sessions.get(String(sessionKey));
     if (!context) return;
@@ -161,14 +167,19 @@ export class AgentSessionLifecycle {
     this.pendingSessionHandoffs.clear();
   }
 
-  resetSession(chatId, { handoff = "", parentSession = "" } = {}) {
+  resetSession(chatId, { handoff = "", parentSession = "", source = "" } = {}) {
     const sessionKey = String(chatId);
     this.closeCached(sessionKey);
     this.pendingNewSessions.add(sessionKey);
     const text = String(handoff || "").trim();
     const parent = String(parentSession || "").trim();
+    const handoffSource = String(source || "").trim();
     if (text || parent) {
-      this.pendingSessionHandoffs.set(sessionKey, { text, parentSession: parent });
+      this.pendingSessionHandoffs.set(sessionKey, {
+        text,
+        parentSession: parent,
+        ...(handoffSource ? { source: handoffSource } : {})
+      });
     } else {
       this.pendingSessionHandoffs.delete(sessionKey);
     }
@@ -177,6 +188,7 @@ export class AgentSessionLifecycle {
   createSessionManager(chatId, workspaceDir = arisaInstallDir, sessionRevision = 0) {
     const sessionKey = String(chatId);
     const sessionDir = getChatPiSessionsDir(sessionKey, sessionRevision);
+    const operationalNotes = formatSessionStartOperationalNotes(loadSessionStartOperationalNotes());
     if (this.pendingNewSessions.has(sessionKey)) {
       this.logger?.log("agent", `starting new persisted session for chat ${sessionKey}`);
       const handoff = this.pendingSessionHandoffs.get(sessionKey);
@@ -185,7 +197,6 @@ export class AgentSessionLifecycle {
         sessionDir,
         handoff?.parentSession ? { parentSession: handoff.parentSession } : undefined
       );
-      const operationalNotes = formatSessionStartOperationalNotes(loadSessionStartOperationalNotes());
       if (operationalNotes) {
         sessionManager.appendCustomMessageEntry(
           "arisa-operational-notes",
@@ -199,11 +210,23 @@ export class AgentSessionLifecycle {
           "arisa-session-handoff",
           handoff.text,
           false,
-          { source: "telegram-new" }
+          { source: handoff.source || "telegram-new" }
         );
       }
       return { sessionManager, isNewSession: true };
     }
+    const migration = migrateRecentSessionBeforeLoad({
+      sessionDir,
+      cwd: workspaceDir,
+      policy: this.sessionRotationPolicy,
+      operationalNotes
+    });
+    if (migration) {
+      this.logger?.log(
+        "agent",
+        `migrated oversized Pi session for chat ${sessionKey} before loading (${Math.ceil(migration.sourceBytes / 1024 / 1024)} MiB -> ${Math.ceil(migration.targetBytes / 1024 / 1024)} MiB)`
+      );
+    }
     this.logger?.log("agent", `recovering persisted session for chat ${sessionKey}`);
     return {
       sessionManager: SessionManager.continueRecent(workspaceDir, sessionDir),

package/src/core/agent/agent-turn-coordinator.js

@@ -0,0 +1,143 @@
+function normalizedPriority(value) {
+  if (value === "interactive") return 10;
+  if (value === "background") return 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(-100, Math.min(100, parsed)) : 0;
+}
+
+function positiveInteger(value, fallback, max) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.min(max, parsed) : fallback;
+}
+
+function queueExpiredError(label) {
+  const error = new Error(`${label || "Agent turn"} expired while waiting for exclusive execution.`);
+  error.code = "AGENT_TURN_QUEUE_EXPIRED";
+  error.retryable = true;
+  error.outcomeUncertain = false;
+  return error;
+}
+
+export class AgentTurnCoordinator {
+  constructor({ config = {}, logger = null, now = Date.now } = {}) {
+    this.logger = logger;
+    this.now = now;
+    this.queue = [];
+    this.active = null;
+    this.sequence = 0;
+    this.closed = false;
+    this.completed = 0;
+    this.expired = 0;
+    this.maxObservedQueue = 0;
+    this.totalWaitMs = 0;
+    this.setConfig(config);
+  }
+
+  setConfig(config = {}) {
+    this.config = {
+      enabled: config.enabled !== false,
+      backgroundQueueTtlMs: positiveInteger(config.backgroundQueueTtlMs, 10 * 60_000, 60 * 60_000),
+      interactiveQueueTtlMs: positiveInteger(config.interactiveQueueTtlMs, 0, 60 * 60_000),
+      maxQueued: Math.max(1, positiveInteger(config.maxQueued, 100, 1_000))
+    };
+  }
+
+  queueTtlMs(priority, override) {
+    if (override != null) return positiveInteger(override, 0, 60 * 60_000);
+    return priority === "interactive" ? this.config.interactiveQueueTtlMs : this.config.backgroundQueueTtlMs;
+  }
+
+  describeActive(entry) {
+    if (!entry) return null;
+    return { label: entry.label, priority: entry.priorityName, startedAt: entry.startedAt };
+  }
+
+  diagnostic() {
+    return {
+      enabled: this.config.enabled,
+      active: this.describeActive(this.active),
+      queued: this.queue.length,
+      maxObservedQueue: this.maxObservedQueue,
+      completed: this.completed,
+      expired: this.expired,
+      averageWaitMs: this.completed ? Math.round(this.totalWaitMs / this.completed) : 0
+    };
+  }
+
+  remove(entry) {
+    const index = this.queue.indexOf(entry);
+    if (index >= 0) this.queue.splice(index, 1);
+  }
+
+  next() {
+    if (this.active || this.closed || !this.queue.length) return;
+    this.queue.sort((left, right) => right.priority - left.priority || left.sequence - right.sequence);
+    const entry = this.queue.shift();
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.startedAt = new Date(this.now()).toISOString();
+    this.active = entry;
+    const waitMs = Math.max(0, this.now() - entry.queuedAt);
+    this.totalWaitMs += waitMs;
+    if (waitMs > 0) this.logger?.log("agent", `${entry.label} waited ${waitMs}ms for exclusive agent execution`);
+    let released = false;
+    entry.resolve(() => {
+      if (released) return;
+      released = true;
+      if (this.active === entry) this.active = null;
+      this.completed += 1;
+      queueMicrotask(() => this.next());
+    });
+  }
+
+  acquire({ priority: priorityName = "background", label = "Agent turn", queueTtlMs } = {}) {
+    if (!this.config.enabled) return Promise.resolve(() => {});
+    if (this.closed) return Promise.reject(Object.assign(new Error("Agent turn coordinator is closed."), { retryable: true }));
+    if (this.queue.length >= this.config.maxQueued) {
+      return Promise.reject(Object.assign(new Error("Agent turn queue is full."), { code: "AGENT_TURN_QUEUE_FULL", retryable: true }));
+    }
+    const priority = normalizedPriority(priorityName);
+    const ttlMs = this.queueTtlMs(priorityName, queueTtlMs);
+    return new Promise((resolve, reject) => {
+      const entry = {
+        label: String(label || "Agent turn").slice(0, 160),
+        priorityName: priorityName === "interactive" ? "interactive" : "background",
+        priority,
+        sequence: this.sequence += 1,
+        queuedAt: this.now(),
+        startedAt: null,
+        resolve,
+        reject,
+        timer: null
+      };
+      if (ttlMs > 0) {
+        entry.timer = setTimeout(() => {
+          if (this.active === entry) return;
+          this.remove(entry);
+          this.expired += 1;
+          reject(queueExpiredError(entry.label));
+        }, ttlMs);
+        entry.timer.unref?.();
+      }
+      this.queue.push(entry);
+      this.maxObservedQueue = Math.max(this.maxObservedQueue, this.queue.length);
+      this.next();
+    });
+  }
+
+  async run(options, work) {
+    const release = await this.acquire(options);
+    try {
+      return await work();
+    } finally {
+      release();
+    }
+  }
+
+  close() {
+    this.closed = true;
+    for (const entry of this.queue.splice(0)) {
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.reject(Object.assign(new Error("Agent turn coordinator closed before execution."), { retryable: true }));
+    }
+  }
+}

package/src/core/agent/auth-flow.js

@@ -33,8 +33,8 @@ export function getPiAuthIssue(error) {
   return null;
 }
 
-export function getPiAuthStatus(config, chatId = null) {
-  const runtime = createPiRuntime({
+export async function getPiAuthStatus(config, chatId = null) {
+  const runtime = await createPiRuntime({
     provider: config.pi.provider,
     apiKey: config.pi.apiKey
   });
@@ -51,8 +51,8 @@ export function getPiAuthStatus(config, chatId = null) {
   };
 }
 
-export function buildPiAuthTelegramMessage({ config, chatId = null, issue = null, verified = false }) {
-  const status = getPiAuthStatus(config, chatId);
+export async function buildPiAuthTelegramMessage({ config, chatId = null, issue = null, verified = false }) {
+  const status = await getPiAuthStatus(config, chatId);
   let title = `Pi authentication status for ${status.provider}/${status.model}.`;
   if (issue) {
     title = `Pi authentication needs attention for ${status.provider}/${status.model}.`;
@@ -95,8 +95,8 @@ export function buildPiAuthTelegramMessage({ config, chatId = null, issue = null
   return lines.join("\n");
 }
 
-export function buildPiAuthRecoveryBlockedMessage({ config, chatId = null, issue = null, renewalActive = false }) {
-  const status = getPiAuthStatus(config, chatId);
+export async function buildPiAuthRecoveryBlockedMessage({ config, chatId = null, issue = null, renewalActive = false }) {
+  const status = await getPiAuthStatus(config, chatId);
   const lines = [
     `Pi authentication is not ready for ${status.provider}/${status.model}.`,
     "I did not send your message to the agent."

package/src/core/agent/model-speed.js

@@ -1,4 +1,4 @@
-export const MODEL_SPEEDS = Object.freeze([1, 1.5]);
+export const MODEL_SPEEDS = Object.freeze([1, 1.5]);
 
 export function normalizeModelSpeed(speed) {
   const value = Number(speed);
@@ -17,6 +17,7 @@ export function modelSupportsSpeed(model) {
       || model.id === "gpt-5.5"
       || model.id === "gpt-5.6"
       || model.id.startsWith("gpt-5.6-")
+      || model.id === "gpt-6-astra"
     );
 }
 
@@ -40,6 +41,7 @@ export function createModelSpeedController(streamFn, initialSpeed) {
       speed = normalizeModelSpeed(nextSpeed);
     },
     streamFn(model, context, options) {
+      if (!modelSupportsSpeed(model)) return streamFn(model, context, options);
       const serviceTier = speedToServiceTier(speed);
       const onPayload = options?.onPayload;
       return streamFn(model, context, {