arisa 5.2.7 → 5.2.19

package/src/core/capabilities/capability-service.js

@@ -48,6 +48,17 @@ function normalizeAcknowledgement(value) {
   return acknowledgement;
 }
 
+function recordAgentTaskAuthBlock(execution, toolName, result) {
+  if (!execution || execution.blockedAuth || result?.ok !== false || result?.status !== "blocked_auth") return;
+  execution.blockedAuth = {
+    toolName,
+    error: String(result.error || `${toolName} authentication is required`).slice(0, 1_000),
+    resolution: result.resolution && typeof result.resolution === "object"
+      ? structuredClone(result.resolution)
+      : {}
+  };
+}
+
 function inferDeliveryMethod(artifact) {
   if (artifact.kind === "audio" || (artifact.mimeType || "").startsWith("audio/")) return "audio";
   if (artifact.kind === "image" || (artifact.mimeType || "").startsWith("image/")) return "photo";
@@ -71,11 +82,12 @@ export function selectScheduledTasks(tasks = [], { status, limit = defaultSchedu
     maxScheduledTaskListLimit
   );
   const allTasks = Array.isArray(tasks) ? tasks : [];
+  const activeStatuses = new Set(["pending", "running", "blocked_auth"]);
   const orderedTasks = status
     ? [...allTasks].reverse()
     : [
-        ...allTasks.filter((task) => task.status === "pending" || task.status === "running").reverse(),
-        ...allTasks.filter((task) => task.status !== "pending" && task.status !== "running").reverse()
+        ...allTasks.filter((task) => activeStatuses.has(task.status)).reverse(),
+        ...allTasks.filter((task) => !activeStatuses.has(task.status)).reverse()
       ];
   const visibleTasks = orderedTasks.slice(0, resolvedLimit);
   return {
@@ -177,6 +189,19 @@ export function createCapabilityService({
       if (!toolExecutor?.runTool) throw new Error("tools.run requires toolExecutor");
       const scopedChatId = requireChatId(chatId, method);
       const targetToolName = requireString(params.name, "name");
+      const blocked = context.agentTaskExecution?.blockedAuth;
+      if (blocked) {
+        return {
+          ok: false,
+          status: "blocked_prerequisite",
+          error: `Authentication for ${blocked.toolName} is blocking this scheduled task.`,
+          resolution: {
+            type: "blocked_prerequisite",
+            prerequisiteStatus: "blocked_auth",
+            toolName: blocked.toolName
+          }
+        };
+      }
       const chatArtifactStore = artifactStore.forChat(scopedChatId);
       const artifact = params.artifactId
         ? await chatArtifactStore.get(requireString(params.artifactId, "artifactId"))
@@ -196,6 +221,7 @@ export function createCapabilityService({
         chatId: scopedChatId,
         taskContext: context.taskContext || null
       });
+      recordAgentTaskAuthBlock(context.agentTaskExecution, targetToolName, result);
       if (params.deliver && result.output?.artifactId) {
         const generated = await chatArtifactStore.get(result.output.artifactId);
         if (generated?.path) {

package/src/core/config/config-defaults.js

@@ -72,6 +72,11 @@ export const piConfigDefaults = Object.freeze({
     maxSessions: 3,
     maxPersistedBytes: 48 * 1024 * 1024
   }),
+  sessionRotation: Object.freeze({
+    enabled: true,
+    compactAtPersistedBytes: 24 * 1024 * 1024,
+    maxPersistedBytes: 32 * 1024 * 1024
+  }),
   heapCircuitBreaker: Object.freeze({
     enabled: true,
     softPercent: 70,
@@ -79,6 +84,18 @@ export const piConfigDefaults = Object.freeze({
     waitMs: 15_000,
     pollMs: 500
   }),
+  toolFanout: Object.freeze({
+    enabled: true,
+    maxConcurrent: 2,
+    pressureConcurrent: 1,
+    serializePercent: 60
+  }),
+  turnCoordinator: Object.freeze({
+    enabled: true,
+    backgroundQueueTtlMs: 10 * 60_000,
+    interactiveQueueTtlMs: 0,
+    maxQueued: 100
+  }),
   compaction: Object.freeze({
     enabled: true,
     reserveTokens: 120_000,
@@ -133,10 +150,22 @@ export function applyConfigDefaults(config) {
         ...piConfigDefaults.sessionCache,
         ...(configuredPi.sessionCache || {})
       },
+      sessionRotation: {
+        ...piConfigDefaults.sessionRotation,
+        ...(configuredPi.sessionRotation || {})
+      },
       heapCircuitBreaker: {
         ...piConfigDefaults.heapCircuitBreaker,
         ...(configuredPi.heapCircuitBreaker || {})
       },
+      toolFanout: {
+        ...piConfigDefaults.toolFanout,
+        ...(configuredPi.toolFanout || {})
+      },
+      turnCoordinator: {
+        ...piConfigDefaults.turnCoordinator,
+        ...(configuredPi.turnCoordinator || {})
+      },
       compaction: {
         ...piConfigDefaults.compaction,
         ...(configuredPi.compaction || {})

package/src/core/tasks/task-runner.js

@@ -18,7 +18,8 @@ export function createTaskRunner({ taskStore, dispatch, laneKey = (task) => task
   async function reportTerminalFailure(task, updated, error) {
     const isTerminal = updated?.status === "failed"
       || updated?.status === "outcome_uncertain"
-      || updated?.terminalFailure === true;
+      || updated?.terminalFailure === true
+      || updated?.authBlockedNew === true;
     if (!isTerminal || typeof onTerminalFailure !== "function") return;
     try {
       await onTerminalFailure({ task, result: updated, error });
@@ -37,9 +38,12 @@ export function createTaskRunner({ taskStore, dispatch, laneKey = (task) => task
       logger?.log("tasks", `task ${task.id} completed after confirmed execution`);
       return { taskId: task.id, status: "completed" };
     } catch (error) {
-      const retryOptions = { retryable: error?.retryable !== false };
-      if (error?.outcomeUncertain === true) retryOptions.outcomeUncertain = true;
-      const updated = await taskStore.retryOrFail(task.id, error, retryOptions);
+      const updated = error?.authBlocked === true
+        ? await taskStore.blockAuth(task.id, error, error.authResolution)
+        : await taskStore.retryOrFail(task.id, error, {
+            retryable: error?.retryable !== false,
+            ...(error?.outcomeUncertain === true ? { outcomeUncertain: true } : {})
+          });
       const status = updated?.status || "missing";
       logger?.log("tasks", `task ${task.id} ${status}: ${errorMessage(error)}`);
       await reportTerminalFailure(task, updated, error);

package/src/core/tasks/task-store.js

@@ -170,6 +170,17 @@ function retryDelayMs(task) {
   return Math.max(1, Math.round(seconds * 1000));
 }
 
+function normalizeAuthResolution(resolution = {}) {
+  const value = resolution && typeof resolution === "object" && !Array.isArray(resolution) ? resolution : {};
+  const retryAfterSeconds = Math.max(300, boundedPositiveNumber(value.retryAfterSeconds, 3_600, 86_400));
+  const probeArgs = value.probeArgs && typeof value.probeArgs === "object" && !Array.isArray(value.probeArgs)
+    ? structuredClone(value.probeArgs)
+    : {};
+  if (JSON.stringify(probeArgs).length > 4_096) throw new Error("Authentication probe arguments are too large");
+  const toolName = typeof value.toolName === "string" ? value.toolName.trim().slice(0, 128) : "";
+  return { retryAfterSeconds, probeArgs, ...(toolName ? { toolName } : {}) };
+}
+
 function failTask(task, error) {
   const failedAt = new Date().toISOString();
   task.status = "failed";
@@ -232,7 +243,7 @@ export class TaskStore {
     return this.mutate(async (tasks) => {
       const now = Date.now();
       const due = tasks
-        .filter((task) => task.status === "pending"
+        .filter((task) => ["pending", "blocked_auth"].includes(task.status)
           && task.runAt
           && !Number.isNaN(Date.parse(task.runAt))
           && Date.parse(task.runAt) <= now)
@@ -275,7 +286,7 @@ export class TaskStore {
         if (task.status === "running") {
           const interruptedAt = new Date(now).toISOString();
           if (task.claimedAt && !task.executionStartedAt) {
-            task.status = "pending";
+            task.status = task.authBlock ? "blocked_auth" : "pending";
             task.attempts = Math.max(0, Number(task.attempts || 0) - 1);
             task.lastError = "execution interrupted before start";
             task.lastFailedAt = interruptedAt;
@@ -294,8 +305,11 @@ export class TaskStore {
           delete task.claimedAt;
           delete task.executionStartedAt;
           if (task.kind === "poll_tool") {
-            task.status = "pending";
-            task.runAt = new Date(now + retryDelayMs(task)).toISOString();
+            task.status = task.authBlock ? "blocked_auth" : "pending";
+            const delayMs = task.authBlock
+              ? Number(task.authBlock.retryAfterSeconds || 3_600) * 1_000
+              : retryDelayMs(task);
+            task.runAt = new Date(now + delayMs).toISOString();
             delete task.startedAt;
           } else {
             const nextRunAt = computeNextRunAt(task, now);
@@ -337,6 +351,7 @@ export class TaskStore {
       delete task.error;
       delete task.lastOutcome;
       delete task.consecutiveFailures;
+      delete task.authBlock;
       delete task.claimedAt;
       delete task.executionStartedAt;
       if (nextRunAt) {
@@ -354,6 +369,35 @@ export class TaskStore {
     });
   }
 
+  async blockAuth(taskId, error, resolution = {}) {
+    return this.mutate(async (tasks) => {
+      const task = tasks.find((item) => item.id === taskId);
+      if (!task) return { result: null, changed: false };
+      const now = Date.now();
+      const checkedAt = new Date(now).toISOString();
+      const normalized = normalizeAuthResolution(resolution);
+      const wasBlocked = Boolean(task.authBlock);
+      task.status = "blocked_auth";
+      task.runAt = new Date(now + (normalized.retryAfterSeconds * 1_000)).toISOString();
+      task.attempts = 0;
+      task.authBlock = {
+        firstBlockedAt: task.authBlock?.firstBlockedAt || checkedAt,
+        lastCheckedAt: checkedAt,
+        ...normalized
+      };
+      task.lastError = error instanceof Error ? error.message : String(error);
+      task.lastFailedAt = checkedAt;
+      task.updatedAt = checkedAt;
+      if (task.claimedAt) task.lastClaimedAt = task.claimedAt;
+      if (task.executionStartedAt) task.lastExecutionStartedAt = task.executionStartedAt;
+      delete task.startedAt;
+      delete task.claimedAt;
+      delete task.executionStartedAt;
+      delete task.error;
+      return { result: { ...structuredClone(task), authBlockedNew: !wasBlocked } };
+    });
+  }
+
   async retryOrFail(taskId, error, { retryable = true, outcomeUncertain = false } = {}) {
     return this.mutate(async (tasks) => {
       const task = tasks.find((item) => item.id === taskId);

package/src/core/tools/daemon-processes.js

@@ -280,6 +280,13 @@ export async function unregisterManagedDaemon(toolNameOrOptions, { scope } = {})
   return { toolName: paths.toolName, scope: paths.scope, instanceId: paths.instanceId };
 }
 
+export async function purgeManagedDaemon(toolNameOrOptions, { scope } = {}) {
+  const paths = daemonPaths(toolNameOrOptions, scope);
+  await unregisterManagedDaemon(toolNameOrOptions, { scope });
+  await rm(paths.root, { recursive: true, force: true });
+  return { toolName: paths.toolName, scope: paths.scope, instanceId: paths.instanceId };
+}
+
 export async function stopManagedDaemon(toolNameOrOptions, {
   scope,
   signal = "SIGTERM",

package/src/core/tools/memory-pressure.js

@@ -43,10 +43,10 @@ export async function readMemoryPressure({
   };
 }
 
-export function memoryPressureReason(snapshot, policy) {
+export function memoryPressureReason(snapshot, policy, { ignoreWorkerRss = false } = {}) {
   const mebibyte = 1024 * 1024;
   const workerRssMb = snapshot.workerRssBytes / mebibyte;
-  if (workerRssMb > policy.maxWorkerRssMb) {
+  if (!ignoreWorkerRss && workerRssMb > policy.maxWorkerRssMb) {
     return `worker RSS ${Math.ceil(workerRssMb)} MiB exceeds the ${policy.maxWorkerRssMb} MiB limit`;
   }
   if (snapshot.swapTotalBytes > 0 && snapshot.swapUsedPercent > policy.maxSwapUsedPercent) {

package/src/core/tools/tool-registry.js

@@ -42,6 +42,25 @@ function concurrentExecutionKey(name, chatId, request) {
   return createHash("sha256").update(serialized).digest("hex");
 }
 
+export function readyDaemonAdmission(tool, diagnostic) {
+  const reusable = Boolean(tool?.daemon)
+    && diagnostic?.alive === true
+    && diagnostic?.state === "ready"
+    && diagnostic?.restart?.requested !== true;
+  return reusable ? { ignoreWorkerRss: true } : {};
+}
+
+function declaredDaemonScope(tool, chatId) {
+  if (!tool?.daemon) return null;
+  return tool.daemon.scope === "chat"
+    ? { type: "chat", chatId }
+    : { type: "global" };
+}
+
+function nativeDaemonScope(tool, chatId) {
+  return tool?.daemon?.protocol === "arisa-daemon-v1" ? declaredDaemonScope(tool, chatId) : null;
+}
+
 function executionForLease(execution, lease) {
   if (!execution) return null;
   return {
@@ -399,20 +418,29 @@ export class ToolRegistry {
     let leaseOutcome = {};
     let result;
     try {
-      lease = await this.executionGovernor.acquire(tool.execution, name);
+      const admissionScope = declaredDaemonScope(tool, chatId);
+      let admission = {};
+      if (admissionScope) {
+        const diagnostic = await readDaemonDiagnostic({
+          toolName: name,
+          scope: admissionScope,
+          autoStart: Boolean(tool.daemon.autoStart)
+        }).catch(() => null);
+        admission = readyDaemonAdmission(tool, diagnostic);
+        if (admission.ignoreWorkerRss) this.logger?.log("tools", `reusing ready ${name} daemon without worker RSS spawn admission`);
+      }
+      lease = await this.executionGovernor.acquire(tool.execution, name, admission);
       this.logger?.log("tools", `running ${name}`);
       await mkdir(tmpDir, { recursive: true });
       const skills = await this.resolveSkills(name);
       const enrichedRequest = { ...request, chatId, skills };
-      if (tool.daemon?.protocol === "arisa-daemon-v1") {
-        const scope = tool.daemon.scope === "chat"
-          ? { type: "chat", chatId }
-          : { type: "global" };
+      const runtimeScope = nativeDaemonScope(tool, chatId);
+      if (runtimeScope) {
         const runtime = createDaemonRuntime({
           toolName: name,
           entryPath: tool.entry,
-          scope,
-          startupContext: scope.type === "chat" ? { chatId: String(chatId) } : {},
+          scope: runtimeScope,
+          startupContext: runtimeScope.type === "chat" ? { chatId: String(chatId) } : {},
           autoStart: Boolean(tool.daemon.autoStart)
         });
         result = await runtime.submit(enrichedRequest, { onEvent });

package/src/core/tools/weighted-resource-governor.js

@@ -205,11 +205,11 @@ export class WeightedResourceGovernor {
     request.resolve(this.createLease(request, waitedMs));
   }
 
-  async pressureSnapshot(label, resourceClass) {
+  async pressureSnapshot(label, resourceClass, { ignoreWorkerRss = false } = {}) {
     const pressure = await this.memoryPressure();
     this.lastPressure = pressure;
     this.lastMemoryBudgetMb = this.memoryBudgetMb(pressure);
-    const reason = memoryPressureReason(pressure, this.policy);
+    const reason = memoryPressureReason(pressure, this.policy, { ignoreWorkerRss });
     if (!reason) return pressure;
     const error = new Error(`Tool ${label} was not started because ${reason}`);
     error.code = "TOOL_RESOURCE_PRESSURE";
@@ -234,7 +234,7 @@ export class WeightedResourceGovernor {
           const next = state.queue[0];
           if (!next) continue;
           try {
-            const pressure = await this.pressureSnapshot(next.label, resourceClass);
+            const pressure = await this.pressureSnapshot(next.label, resourceClass, next.admission);
             const budgetMb = this.memoryBudgetMb(pressure);
             next.memoryMb = this.requestedMemoryMb(next.execution, next.label, budgetMb);
             if (next.memoryMb < this.policy.minimumToolMemoryMb || !this.canGrant(next)) continue;
@@ -253,14 +253,14 @@ export class WeightedResourceGovernor {
     }
   }
 
-  async acquire(rawExecution, label = "tool") {
+  async acquire(rawExecution, label = "tool", admission = {}) {
     const execution = normalizeToolExecution(rawExecution);
     if (!execution) return noopLease();
     const resourceClass = execution.resourceClass;
     const capacity = this.capacityFor(resourceClass);
     const weight = Math.min(execution.weight, capacity);
     const state = this.stateFor(resourceClass);
-    const pressure = await this.pressureSnapshot(label, resourceClass);
+    const pressure = await this.pressureSnapshot(label, resourceClass, admission);
     const budgetMb = this.memoryBudgetMb(pressure);
     const memoryMb = this.requestedMemoryMb(execution, label, budgetMb);
     if (budgetMb < this.policy.minimumToolMemoryMb || memoryMb < this.policy.minimumToolMemoryMb) {
@@ -274,7 +274,8 @@ export class WeightedResourceGovernor {
       weight,
       memoryMb,
       label,
-      queuedAt: this.now()
+      queuedAt: this.now(),
+      admission: { ignoreWorkerRss: admission?.ignoreWorkerRss === true }
     };
     if (!state.queue.length && this.canGrant(request)) {
       return new Promise((resolve) => this.grant({ ...request, resolve }));