arisa 5.1.68 → 5.2.17

package/src/core/agent/pi-capability-tools.js

@@ -18,7 +18,7 @@ function nativeTools(policy) {
   }];
 }
 
-export function createPiCapabilityTools({ capabilityService, telegram, chatId, policy, logger }) {
+export function createPiCapabilityTools({ capabilityService, telegram, chatId, policy, logger, toolFanout }) {
   if (!capabilityService?.execute) throw new Error("Pi capability tools require CapabilityService");
 
   const baseContext = {
@@ -38,6 +38,7 @@ export function createPiCapabilityTools({ capabilityService, telegram, chatId, p
     }
   };
 
+  const runWithFanout = (work) => toolFanout?.run ? toolFanout.run(work) : work();
   const execute = (actorToolName, method, params = {}, context = {}) => capabilityService.execute({
     method,
     actorToolName,
@@ -113,12 +114,14 @@ export function createPiCapabilityTools({ capabilityService, telegram, chatId, p
         args: Type.Optional(Type.Record(Type.String(), Type.String())),
         deliver: Type.Optional(Type.Boolean())
       }),
-      execute: async (_id, params) => jsonResult(await execute("run_tool", "tools.run", params))
+      execute: async (_id, params) => jsonResult(await runWithFanout(
+        () => execute("run_tool", "tools.run", params)
+      ))
     }),
     defineTool({
       name: "list_scheduled_tasks",
       label: "List scheduled tasks",
-      description: "List scheduled async tasks for the current Telegram chat. Results default to 50 tasks, always include pending/running tasks, and accept an optional limit up to 100.",
+      description: "List scheduled async tasks for the current Telegram chat. Results default to 50 tasks, always include pending, running, and authentication-blocked tasks, and accept an optional limit up to 100.",
       parameters: Type.Object({
         status: Type.Optional(Type.String()),
         limit: Type.Optional(Type.Integer({ minimum: 1, maximum: maxScheduledTaskListLimit }))
@@ -135,7 +138,7 @@ export function createPiCapabilityTools({ capabilityService, telegram, chatId, p
     defineTool({
       name: "cancel_all_scheduled_tasks",
       label: "Cancel all scheduled tasks",
-      description: "Cancel all pending or running async tasks for the current Telegram chat.",
+      description: "Cancel all active async tasks, including authentication-blocked tasks, for the current Telegram chat.",
       parameters: Type.Object({}),
       execute: async () => jsonResult(await execute("cancel_all_scheduled_tasks", "tasks.cancelAll"))
     }),

package/src/core/agent/pi-runtime.js

@@ -1,5 +1,5 @@
 import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
-import { piAuthFile } from "../../runtime/paths.js";
+import { piAuthFile } from "../../platform/paths.js";
 
 function compareText(a, b) {
   return a.localeCompare(b, undefined, { sensitivity: "base", numeric: true });

package/src/core/agent/runtime-context.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { arisaHomeDir, arisaPackageDir, chatsDir, stateDir, toolStateDir, toolsDir } from "../../runtime/paths.js";
+import { arisaHomeDir, arisaPackageDir, chatsDir, stateDir, toolStateDir, toolsDir } from "../../platform/paths.js";
 
 export const arisaInstallDir = fileURLToPath(new URL("../../..", import.meta.url));
 export const arisaAgentsFile = path.join(arisaPackageDir, "AGENTS.md");

package/src/core/agent/session-history-reader.js

@@ -0,0 +1,168 @@
+import { closeSync, openSync, readSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+const readBufferBytes = 1024 * 1024;
+const supportedSessionVersion = 3;
+
+function parseEntry(line) {
+  if (!line.trim()) return null;
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+function readSessionHeader(filePath) {
+  const descriptor = openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(4096);
+    const bytesRead = readSync(descriptor, buffer, 0, buffer.length, 0);
+    const line = buffer.toString("utf8", 0, bytesRead).split("\n", 1)[0];
+    const header = parseEntry(line);
+    return header?.type === "session" ? header : null;
+  } catch {
+    return null;
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+export function findMostRecentSessionFile(sessionDir, cwd) {
+  const expectedCwd = path.resolve(cwd);
+  try {
+    return readdirSync(sessionDir)
+      .filter((name) => name.endsWith(".jsonl"))
+      .map((name) => path.join(sessionDir, name))
+      .map((filePath) => ({ filePath, header: readSessionHeader(filePath) }))
+      .filter(({ header }) => header && typeof header.cwd === "string" && path.resolve(header.cwd) === expectedCwd)
+      .map(({ filePath }) => ({ filePath, mtimeMs: statSync(filePath).mtimeMs }))
+      .sort((left, right) => right.mtimeMs - left.mtimeMs)[0]?.filePath || null;
+  } catch {
+    return null;
+  }
+}
+
+export function streamSessionEntries(filePath, visit) {
+  const descriptor = openSync(filePath, "r");
+  try {
+    const decoder = new StringDecoder("utf8");
+    const buffer = Buffer.allocUnsafe(readBufferBytes);
+    let pending = "";
+    while (true) {
+      const bytesRead = readSync(descriptor, buffer, 0, buffer.length, null);
+      if (!bytesRead) break;
+      pending += decoder.write(buffer.subarray(0, bytesRead));
+      let newline = pending.indexOf("\n");
+      while (newline !== -1) {
+        const entry = parseEntry(pending.slice(0, newline));
+        if (entry) visit(entry);
+        pending = pending.slice(newline + 1);
+        newline = pending.indexOf("\n");
+      }
+    }
+    pending += decoder.end();
+    const entry = parseEntry(pending);
+    if (entry) visit(entry);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function traceActivePath(entries, leafId) {
+  const reversed = [];
+  const seen = new Set();
+  let currentId = leafId;
+  while (currentId) {
+    if (seen.has(currentId)) return null;
+    seen.add(currentId);
+    const entry = entries.get(currentId);
+    if (!entry) return null;
+    reversed.push(entry);
+    currentId = entry.parentId || null;
+  }
+  return reversed.reverse();
+}
+
+function findLatestValidCompaction(path) {
+  const pathIndex = new Map(path.map((entry, index) => [entry.id, index]));
+  for (let index = path.length - 1; index >= 0; index -= 1) {
+    const entry = path[index];
+    if (entry.type !== "compaction" || !entry.hasSummary) continue;
+    if (!entry.firstKeptEntryId) return { entry, index, firstKeptIndex: index };
+    const firstKeptIndex = pathIndex.get(entry.firstKeptEntryId);
+    if (firstKeptIndex !== undefined && firstKeptIndex < index) {
+      return { entry, index, firstKeptIndex };
+    }
+  }
+  return null;
+}
+
+function inspectSessionGraph(filePath) {
+  let header = null;
+  let firstEntry = true;
+  let invalidHeader = false;
+  let leafId = null;
+  let duplicateId = false;
+  const entries = new Map();
+  streamSessionEntries(filePath, (entry) => {
+    if (firstEntry) {
+      firstEntry = false;
+      header = entry.type === "session" ? entry : null;
+      invalidHeader = !header;
+      return;
+    }
+    if (invalidHeader) return;
+    if (!entry.id || entry.type === "session") return;
+    if (entries.has(entry.id)) duplicateId = true;
+    entries.set(entry.id, {
+      id: entry.id,
+      parentId: entry.parentId || null,
+      type: entry.type,
+      firstKeptEntryId: entry.type === "compaction" ? entry.firstKeptEntryId || null : null,
+      hasSummary: entry.type === "compaction" && Boolean(String(entry.summary || "").trim())
+    });
+    leafId = entry.id;
+  });
+  if (invalidHeader || !header || header.version !== supportedSessionVersion || duplicateId || !leafId) return null;
+  const path = traceActivePath(entries, leafId);
+  if (!path) return null;
+  const compaction = findLatestValidCompaction(path);
+  if (!compaction) return null;
+  return { header, path, compaction };
+}
+
+function loadMigrationPayload(filePath, path, compaction) {
+  const before = path.slice(compaction.firstKeptIndex, compaction.index);
+  const after = path.slice(compaction.index + 1);
+  const contextIds = [...before, ...after].map((entry) => entry.id);
+  const wanted = new Set(contextIds);
+  const loaded = new Map();
+  let summary = "";
+  streamSessionEntries(filePath, (entry) => {
+    if (entry.id === compaction.entry.id) summary = String(entry.summary || "").trim();
+    if (wanted.has(entry.id)) loaded.set(entry.id, entry);
+  });
+  if (!summary || loaded.size !== wanted.size) return null;
+  return {
+    summary,
+    contextEntries: contextIds.map((id) => loaded.get(id))
+  };
+}
+
+export function inspectSessionForPreloadMigration(filePath, maxPersistedBytes) {
+  const sourceBytes = statSync(filePath).size;
+  if (sourceBytes <= Math.max(1, Number(maxPersistedBytes) || 1)) return null;
+  const graph = inspectSessionGraph(filePath);
+  if (!graph) return null;
+  const payload = loadMigrationPayload(filePath, graph.path, graph.compaction);
+  if (!payload) return null;
+  return {
+    sourceFile: filePath,
+    sourceBytes,
+    header: graph.header,
+    compactionId: graph.compaction.entry.id,
+    ...payload
+  };
+}

package/src/core/agent/session-preload-migration.js

@@ -0,0 +1,162 @@
+import {
+  closeSync,
+  fsyncSync,
+  openSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import {
+  findMostRecentSessionFile,
+  inspectSessionForPreloadMigration
+} from "./session-history-reader.js";
+import { normalizeSessionRotationPolicy } from "./session-rotation.js";
+
+const contextEntryTypes = new Set([
+  "message",
+  "custom_message",
+  "branch_summary",
+  "thinking_level_change",
+  "model_change"
+]);
+
+function createEntry(type, parentId, fields = {}) {
+  return {
+    type,
+    ...fields,
+    id: randomUUID(),
+    parentId,
+    timestamp: fields.timestamp || new Date().toISOString()
+  };
+}
+
+function appendDurably(filePath, entry) {
+  writeFileSync(filePath, `${JSON.stringify(entry)}\n`, { encoding: "utf8", flag: "a" });
+}
+
+function syncFile(filePath) {
+  const descriptor = openSync(filePath, "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function syncDirectory(directory) {
+  const descriptor = openSync(directory, "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function migratedEntry(source, parentId) {
+  const { id: _id, parentId: _parentId, ...fields } = source;
+  return createEntry(source.type, parentId, fields);
+}
+
+export function createPreloadMigrationChild({
+  sessionDir,
+  cwd,
+  migration,
+  operationalNotes = "",
+  now = new Date()
+}) {
+  const timestamp = now.toISOString();
+  const sessionId = randomUUID();
+  const filenameTimestamp = timestamp.replace(/[:.]/g, "-");
+  const targetFile = path.join(sessionDir, `${filenameTimestamp}_${sessionId}.jsonl`);
+  const temporaryFile = path.join(sessionDir, `.session-migration-${sessionId}.tmp`);
+  const header = {
+    type: "session",
+    version: 3,
+    id: sessionId,
+    timestamp,
+    cwd,
+    parentSession: migration.sourceFile
+  };
+  let parentId = null;
+  let copiedEntries = 0;
+
+  try {
+    writeFileSync(temporaryFile, `${JSON.stringify(header)}\n`, { encoding: "utf8", flag: "wx" });
+    const notes = String(operationalNotes || "").trim();
+    if (notes) {
+      const entry = createEntry("custom_message", parentId, {
+        customType: "arisa-operational-notes",
+        content: notes,
+        display: false,
+        details: { source: "session-start" }
+      });
+      appendDurably(temporaryFile, entry);
+      parentId = entry.id;
+    }
+    const handoff = createEntry("custom_message", parentId, {
+      customType: "arisa-session-handoff",
+      content: [
+        "Automatic session migration before loading. Continue from this checkpoint:",
+        "",
+        migration.summary
+      ].join("\n"),
+      display: false,
+      details: { source: "preload-migration" }
+    });
+    appendDurably(temporaryFile, handoff);
+    parentId = handoff.id;
+
+    for (const sourceEntry of migration.contextEntries) {
+      if (!contextEntryTypes.has(sourceEntry.type)) continue;
+      const entry = migratedEntry(sourceEntry, parentId);
+      appendDurably(temporaryFile, entry);
+      parentId = entry.id;
+      copiedEntries += 1;
+    }
+
+    syncFile(temporaryFile);
+    renameSync(temporaryFile, targetFile);
+    syncDirectory(sessionDir);
+    return {
+      sourceFile: migration.sourceFile,
+      sourceBytes: migration.sourceBytes,
+      targetFile,
+      targetBytes: statSync(targetFile).size,
+      copiedEntries
+    };
+  } catch (error) {
+    try {
+      unlinkSync(temporaryFile);
+    } catch {}
+    throw error;
+  }
+}
+
+export function migrateRecentSessionBeforeLoad({
+  sessionDir,
+  cwd,
+  policy,
+  operationalNotes = ""
+}) {
+  const normalized = normalizeSessionRotationPolicy(policy);
+  if (!normalized.enabled) return null;
+  const sourceFile = findMostRecentSessionFile(sessionDir, cwd);
+  if (!sourceFile) return null;
+  const sourceBytes = statSync(sourceFile).size;
+  if (sourceBytes <= normalized.maxPersistedBytes) return null;
+  const migration = inspectSessionForPreloadMigration(sourceFile, normalized.maxPersistedBytes);
+  if (!migration) {
+    const error = new Error("Oversized Pi session could not be migrated safely before loading");
+    error.code = "PI_SESSION_PRELOAD_MIGRATION_UNAVAILABLE";
+    throw error;
+  }
+  return createPreloadMigrationChild({
+    sessionDir,
+    cwd,
+    migration,
+    operationalNotes
+  });
+}

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

@@ -0,0 +1,29 @@
+const defaultCompactAtPersistedBytes = 24 * 1024 * 1024;
+const defaultMaxPersistedBytes = 32 * 1024 * 1024;
+
+export function normalizeSessionRotationPolicy(policy = {}) {
+  const maxPersistedBytes = Math.max(1, Number(policy?.maxPersistedBytes) || defaultMaxPersistedBytes);
+  return {
+    enabled: policy?.enabled !== false,
+    compactAtPersistedBytes: Math.min(
+      maxPersistedBytes,
+      Math.max(1, Number(policy?.compactAtPersistedBytes) || defaultCompactAtPersistedBytes)
+    ),
+    maxPersistedBytes
+  };
+}
+
+export function compactionRotationRequest(event, persistedBytes, policy = {}) {
+  const normalized = normalizeSessionRotationPolicy(policy);
+  if (!normalized.enabled || event?.type !== "compaction_end" || event.aborted || event.errorMessage) return null;
+  const summary = String(event.result?.summary || "").trim();
+  if (!summary || Math.max(0, Number(persistedBytes) || 0) <= normalized.compactAtPersistedBytes) return null;
+  return {
+    handoff: [
+      "Automatic session rotation after compaction. Continue from this checkpoint:",
+      "",
+      summary
+    ].join("\n"),
+    persistedBytes: Math.max(0, Number(persistedBytes) || 0)
+  };
+}

package/src/core/agent/worker-heap-circuit-breaker.js

@@ -0,0 +1,122 @@
+import v8 from "node:v8";
+
+const defaults = Object.freeze({
+  enabled: true,
+  softPercent: 70,
+  criticalPercent: 82,
+  waitMs: 15_000,
+  pollMs: 500
+});
+
+function boundedPercent(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.min(99, Math.max(1, number)) : fallback;
+}
+
+function boundedMilliseconds(value, fallback, minimum, maximum) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.min(maximum, Math.max(minimum, Math.floor(number))) : fallback;
+}
+
+function normalizeConfig(config = {}) {
+  const softPercent = boundedPercent(config.softPercent, defaults.softPercent);
+  return {
+    enabled: config.enabled !== false,
+    softPercent,
+    criticalPercent: Math.max(softPercent + 1, boundedPercent(config.criticalPercent, defaults.criticalPercent)),
+    waitMs: boundedMilliseconds(config.waitMs, defaults.waitMs, 0, 120_000),
+    pollMs: boundedMilliseconds(config.pollMs, defaults.pollMs, 50, 5_000)
+  };
+}
+
+export function readWorkerHeapPressure({ memoryUsage = process.memoryUsage, heapStatistics = v8.getHeapStatistics } = {}) {
+  const heapUsed = Math.max(0, Number(memoryUsage().heapUsed) || 0);
+  const heapLimit = Math.max(1, Number(heapStatistics().heap_size_limit) || 1);
+  return {
+    heapUsed,
+    heapLimit,
+    percent: heapUsed / heapLimit * 100
+  };
+}
+
+export class WorkerHeapPressureError extends Error {
+  constructor(pressure) {
+    super(`Worker heap pressure remained critical at ${pressure.percent.toFixed(1)}%; retry this request shortly`);
+    this.name = "WorkerHeapPressureError";
+    this.code = "WORKER_HEAP_PRESSURE";
+    this.retryable = true;
+    this.pressure = pressure;
+  }
+}
+
+export class WorkerHeapCircuitBreaker {
+  constructor({ lifecycle, logger, config, measure = readWorkerHeapPressure, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now = Date.now }) {
+    this.lifecycle = lifecycle;
+    this.logger = logger;
+    this.measure = measure;
+    this.sleep = sleep;
+    this.now = now;
+    this.metrics = {
+      pressureEvents: 0,
+      evictedSessions: 0,
+      delayedAdmissions: 0,
+      rejectedAdmissions: 0,
+      peakHeapPercent: 0
+    };
+    this.setConfig(config);
+  }
+
+  setConfig(config) {
+    this.config = normalizeConfig(config);
+  }
+
+  sample() {
+    const pressure = this.measure();
+    this.metrics.peakHeapPercent = Math.max(this.metrics.peakHeapPercent, pressure.percent);
+    return pressure;
+  }
+
+  async relievePressure() {
+    const evicted = await this.lifecycle.evictInactive();
+    this.metrics.evictedSessions += evicted.length;
+    return evicted;
+  }
+
+  async admit() {
+    let pressure = this.sample();
+    if (!this.config.enabled || pressure.percent < this.config.softPercent) return pressure;
+
+    this.metrics.pressureEvents += 1;
+    const evicted = await this.relievePressure();
+    pressure = this.sample();
+    this.logger?.log("agent", `worker heap pressure ${pressure.percent.toFixed(1)}%; evicted ${evicted.length} inactive session(s)`);
+    if (pressure.percent < this.config.criticalPercent) return pressure;
+
+    this.metrics.delayedAdmissions += 1;
+    const deadline = this.now() + this.config.waitMs;
+    while (this.now() < deadline) {
+      await this.sleep(Math.min(this.config.pollMs, Math.max(0, deadline - this.now())));
+      await this.relievePressure();
+      pressure = this.sample();
+      if (pressure.percent < this.config.criticalPercent) {
+        this.logger?.log("agent", `worker heap pressure recovered to ${pressure.percent.toFixed(1)}%`);
+        return pressure;
+      }
+    }
+
+    this.metrics.rejectedAdmissions += 1;
+    this.logger?.log("agent", `worker heap admission rejected at ${pressure.percent.toFixed(1)}%`);
+    throw new WorkerHeapPressureError(pressure);
+  }
+
+  getDiagnostic() {
+    const pressure = this.sample();
+    return {
+      ...this.config,
+      heapUsed: pressure.heapUsed,
+      heapLimit: pressure.heapLimit,
+      currentHeapPercent: pressure.percent,
+      ...this.metrics
+    };
+  }
+}

package/src/core/agent/worker-tool-fanout.js

@@ -0,0 +1,117 @@
+const defaults = Object.freeze({
+  enabled: true,
+  maxConcurrent: 2,
+  pressureConcurrent: 1,
+  serializePercent: 60
+});
+
+function boundedInteger(value, fallback, minimum, maximum) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.min(maximum, Math.max(minimum, Math.floor(number))) : fallback;
+}
+
+function boundedPercent(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.min(99, Math.max(1, number)) : fallback;
+}
+
+export function normalizeToolFanoutConfig(config = {}) {
+  const maxConcurrent = boundedInteger(config.maxConcurrent, defaults.maxConcurrent, 1, 16);
+  return {
+    enabled: config.enabled !== false,
+    maxConcurrent,
+    pressureConcurrent: Math.min(
+      maxConcurrent,
+      boundedInteger(config.pressureConcurrent, defaults.pressureConcurrent, 1, 16)
+    ),
+    serializePercent: boundedPercent(config.serializePercent, defaults.serializePercent)
+  };
+}
+
+export class WorkerToolFanoutController {
+  constructor({ heapCircuitBreaker, logger, config = {} }) {
+    this.heapCircuitBreaker = heapCircuitBreaker;
+    this.logger = logger;
+    this.active = 0;
+    this.queue = [];
+    this.draining = false;
+    this.metrics = {
+      peakActive: 0,
+      peakQueued: 0,
+      pressureSerializations: 0,
+      rejectedAdmissions: 0,
+      completed: 0
+    };
+    this.setConfig(config);
+  }
+
+  setConfig(config = {}) {
+    this.config = normalizeToolFanoutConfig(config);
+    this.drain();
+  }
+
+  capacity() {
+    if (!this.config.enabled) return Number.POSITIVE_INFINITY;
+    const pressure = this.heapCircuitBreaker.sample();
+    if (pressure.percent >= this.config.serializePercent) {
+      this.metrics.pressureSerializations += 1;
+      return this.config.pressureConcurrent;
+    }
+    return this.config.maxConcurrent;
+  }
+
+  async drain() {
+    if (this.draining) return;
+    this.draining = true;
+    try {
+      while (this.queue.length && this.active < this.capacity()) {
+        const job = this.queue.shift();
+        try {
+          await this.heapCircuitBreaker.admit();
+        } catch (error) {
+          this.metrics.rejectedAdmissions += 1;
+          job.reject(error);
+          continue;
+        }
+        this.active += 1;
+        this.metrics.peakActive = Math.max(this.metrics.peakActive, this.active);
+        job.resolve();
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+
+  acquire() {
+    if (!this.config.enabled) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      this.queue.push({ resolve, reject });
+      this.metrics.peakQueued = Math.max(this.metrics.peakQueued, this.queue.length);
+      this.drain();
+    });
+  }
+
+  release() {
+    if (this.config.enabled) this.active = Math.max(0, this.active - 1);
+    this.metrics.completed += 1;
+    this.drain();
+  }
+
+  async run(work) {
+    await this.acquire();
+    try {
+      return await work();
+    } finally {
+      this.release();
+    }
+  }
+
+  getDiagnostic() {
+    return {
+      ...this.config,
+      active: this.active,
+      queued: this.queue.length,
+      ...this.metrics
+    };
+  }
+}

package/src/core/artifacts/artifact-store.js

@@ -1,7 +1,7 @@
 import { copyFile, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
-import { getChatArtifactsDir, getChatArtifactsIndexFile } from "../../runtime/paths.js";
+import { getChatArtifactsDir, getChatArtifactsIndexFile } from "../../platform/paths.js";
 
 const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf]);
 const indexOperations = new Map();

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

@@ -5,7 +5,7 @@ import {
   getChatToolTmpDir,
   getToolStateDir,
   getToolTmpDir
-} from "../../runtime/paths.js";
+} from "../../platform/paths.js";
 import { ToolResourceNoteStore } from "../tools/tool-resource-note-store.js";
 import { installBundledOfficialTool } from "../tools/official-tool-installer.js";
 import { searchOfficialToolCatalog } from "../tools/official-tool-catalog.js";
@@ -71,11 +71,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 {