arisa 5.1.68 → 5.2.7

package/README.md

@@ -113,8 +113,11 @@ Managed daemons become ready only after their tool-defined health operation succ
 Daemon tools may opt into the `arisa-daemon-v1` local protocol for immediate
 multiplexed jobs and incremental NDJSON events over a capability-protected local
 socket. The runtime persists request, accepted and terminal records so a restart
-can recover queued work and will not silently repeat an accepted effect. Legacy
-daemon tools continue to use the existing request-file contract.
+can recover queued work and will not silently repeat an accepted effect. When a
+client deadline expires, the runtime sends a scoped cancellation signal to that
+job before closing the request; cooperative tools can stop it without restarting
+the shared daemon or interrupting unrelated sessions. Legacy daemon tools
+continue to use the existing request-file contract.
 
 ### Arisa Master and Slave
 
@@ -181,9 +184,9 @@ arisa --silent           # run without verbose logs
 
 Authorized Telegram chats can run the same safe service lifecycle with `/restart`.
 
-Background mode runs the Telegram/Pi worker under a lightweight supervisor. Unexpected worker exits use bounded exponential restart backoff. Scheduled agent tasks are serialized FIFO per conversation while different conversations remain independent; execution deadlines default to 15 minutes for scheduled prompts and 5 minutes for agent events. A timed-out turn is marked outcome-uncertain and is never replayed automatically. These policies can be overridden with `service.workerRestart*` and `tasks.*TimeoutMs` in the Arisa config.
+Background mode runs the Telegram/Pi worker under a lightweight supervisor. Unexpected worker exits use bounded exponential restart backoff. After recovery, authorized Telegram chats automatically receive a bounded report with the classified exit cause, recent tool names and counts, uncertain scheduled executions, restart delay, and running version; prompts and private payloads are never included. Scheduled agent tasks are serialized FIFO per conversation while different conversations remain independent; execution deadlines default to 15 minutes for scheduled prompts and 5 minutes for agent events. A timed-out turn is marked outcome-uncertain and is never replayed automatically. These policies can be overridden with `service.workerRestart*` and `tasks.*TimeoutMs` in the Arisa config.
 
-Tools may declare weighted execution resources in their manifest, for example `"execution": { "resourceClass": "browser", "weight": 1 }`. Runs sharing a declared class queue fairly once they reach its capacity; undeclared lightweight tools remain unconstrained. The default capacity is two per declared class, while the built-in `orchestrator` class has capacity one. An opt-in tool may set `deduplicateConcurrent: true` to join only exact concurrent duplicates from the same chat; later or different requests still execute normally. Override capacities with `toolExecution.defaultCapacity`, `toolExecution.capacities`, and `toolExecution.maxQueuedPerClass`. Arisa logs queue waits, joined duplicates, and new worker RSS peaks for operational measurement.
+Tools may opt into weighted resource governance with a manifest declaration such as `"execution": { "resourceClass": "browser", "weight": 1 }`; undeclared lightweight and nested orchestration calls remain unconstrained. Declared runs queue when their class reaches its concurrency capacity. A global memory broker also reserves RAM across declared classes, leaving configurable system and core reserves before it admits work. The broker starts declared tools with a 384 MiB recommendation, derives their V8 heap from the granted memory, and raises the recommendation after an isolated memory-limit failure. Manifest values for `maxHeapMb` and `maxMemoryMb` act as ceilings; `maxOutputBytes` bounds protocol output. On systemd-based Linux hosts, each declared process tree runs in `arisa-tools.slice` with `MemoryHigh`, `MemoryMax`, bounded swap, and a higher OOM-kill priority than the core. Tool daemons receive the same OOM priority. Arisa lowers the core OOM score when the service account permits it. A limit failure stays inside the tool process tree and returns an uncertain result. Set host reserves and dynamic grants with `toolExecution.systemReserveMb`, `coreReserveMb`, `initialToolMemoryMb`, `minimumToolMemoryMb`, and `maximumToolMemoryMb`. Heap, soft-pressure, and swap controls use `toolHeapPercent`, `toolMemoryHighPercent`, and `toolSwapMaxMb`. Admission still checks `maxWorkerRssMb` and `maxSwapUsedPercent`. Class controls remain available through `defaultCapacity`, `capacities`, and `maxQueuedPerClass`. `deduplicateConcurrent: true` joins exact concurrent duplicates from the same chat.
 
 Runtime model override (current process only):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "5.1.68",
+  "version": "5.2.7",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

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

@@ -8,11 +8,12 @@ import { buildPiToolPolicy } from "./core-tools.js";
 import { createSystemShellTool } from "./system-shell-tool.js";
 import { clampModelThinkingLevel } from "./pi-runtime.js";
 import { clampModelSpeed, createModelSpeedController } from "./model-speed.js";
-import { arisaHomeDir } from "../../runtime/paths.js";
+import { arisaHomeDir } from "../../platform/paths.js";
 import { AgentSessionLifecycle } from "./agent-session-lifecycle.js";
 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";
 
 const piValidationTimeoutMs = 60_000;
 const arisaToolNames = [
@@ -154,7 +155,13 @@ export class AgentManager {
     this.resourceNotes = new ToolResourceNoteStore();
     this.sessionLifecycle = new AgentSessionLifecycle({
       logger,
-      summarizeContext: summarizeRetainedContext
+      summarizeContext: summarizeRetainedContext,
+      cachePolicy: config.pi.sessionCache
+    });
+    this.heapCircuitBreaker = new WorkerHeapCircuitBreaker({
+      lifecycle: this.sessionLifecycle,
+      logger,
+      config: config.pi.heapCircuitBreaker
     });
     this.sessions = this.sessionLifecycle.sessions;
     this.pendingNewSessions = this.sessionLifecycle.pendingNewSessions;
@@ -188,6 +195,8 @@ export class AgentManager {
 
   setConfig(config) {
     this.sessionLifecycle.resetConfigState();
+    this.sessionLifecycle.setCachePolicy(config.pi.sessionCache);
+    this.heapCircuitBreaker.setConfig(config.pi.heapCircuitBreaker);
     this.config = config;
   }
 
@@ -209,14 +218,44 @@ export class AgentManager {
     }
   }
 
-  getRuntimeDiagnostic() {
-    return this.sessionLifecycle.getDiagnostic();
+  async getRuntimeDiagnostic() {
+    const diagnostic = await this.sessionLifecycle.getDiagnostic();
+    return {
+      ...diagnostic,
+      heapCircuitBreaker: this.heapCircuitBreaker.getDiagnostic()
+    };
   }
 
   createSessionManager(chatId, workspaceDir = arisaInstallDir, sessionRevision = 0) {
     return this.sessionLifecycle.createSessionManager(chatId, workspaceDir, sessionRevision);
   }
 
+  async estimatePersistedSessionBytes(session) {
+    const sessionStats = session?.getSessionStats?.();
+    const sessionFile = session?.sessionManager?.getSessionFile?.() || sessionStats?.sessionFile;
+    if (!sessionFile) return 0;
+    try {
+      return (await stat(sessionFile)).size;
+    } catch {
+      return 0;
+    }
+  }
+
+  async acquireSessionContext(sessionKey, context) {
+    const persistedBytes = await this.estimatePersistedSessionBytes(context.session);
+    this.sessionLifecycle.acquireCached(sessionKey, persistedBytes);
+    context.release = () => this.releaseSessionContext(sessionKey, context);
+    await this.sessionLifecycle.enforceCachePolicy({ protectedSessionKeys: [sessionKey] });
+    return context;
+  }
+
+  async releaseSessionContext(sessionKey, context) {
+    if (this.sessions.get(String(sessionKey)) !== context) return;
+    const persistedBytes = await this.estimatePersistedSessionBytes(context.session);
+    this.sessionLifecycle.releaseCached(sessionKey, persistedBytes);
+    await this.sessionLifecycle.enforceCachePolicy();
+  }
+
   async validatePiAgent(config = this.config) {
     this.logger?.log("agent", "validating Pi session");
     const { authStorage, modelRegistry } = createPiRuntime({
@@ -254,6 +293,7 @@ export class AgentManager {
   }
 
   async getSessionContext(chatId, telegram, { scopeChatId = chatId, accessGuard = async () => {} } = {}) {
+    await this.heapCircuitBreaker.admit();
     const sessionKey = String(chatId);
     const modelSelection = resolveChatModelSelection(this.config, sessionKey);
     const effectiveModelId = modelSelection.model;
@@ -274,7 +314,7 @@ export class AgentManager {
         existing.telegramTarget.current = telegram;
         existing.accessGuardTarget.current = accessGuard;
         this.logger?.log("agent", `reusing session for chat ${sessionKey}`);
-        return existing;
+        return this.acquireSessionContext(sessionKey, existing);
       }
       this.logger?.log("agent", `model changed for chat ${sessionKey}: ${existing?.modelKey || "unknown"} -> ${effectiveModelKey}; recreating session`);
       this.closeCachedSession(sessionKey);
@@ -366,7 +406,7 @@ export class AgentManager {
     };
     this.sessions.set(sessionKey, ctx);
     if (isNewSession) this.sessionLifecycle.completeNewSession(sessionKey);
-    return ctx;
+    return this.acquireSessionContext(sessionKey, ctx);
   }
 
   async getAvailableModels(chatId) {

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

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { getChatPiSessionsDir, sessionStartOperationalNotesFile } from "../../runtime/paths.js";
+import { getChatPiSessionsDir, sessionStartOperationalNotesFile } from "../../platform/paths.js";
 import { arisaInstallDir } from "./runtime-context.js";
 
 const operationalNoteMaxChars = 220;
@@ -41,13 +41,84 @@ function closeAgentSession(session) {
 }
 
 export class AgentSessionLifecycle {
-  constructor({ logger, summarizeContext }) {
+  constructor({ logger, summarizeContext, cachePolicy = {} }) {
     this.logger = logger;
     this.summarizeContext = summarizeContext;
     this.sessions = new Map();
     this.pendingNewSessions = new Set();
     this.pendingSessionHandoffs = new Map();
     this.sessionClosePromises = new Map();
+    this.setCachePolicy(cachePolicy);
+  }
+
+  setCachePolicy(cachePolicy = {}) {
+    this.cachePolicy = {
+      maxSessions: Math.max(1, Number(cachePolicy.maxSessions) || 3),
+      maxPersistedBytes: Math.max(1, Number(cachePolicy.maxPersistedBytes) || 48 * 1024 * 1024)
+    };
+  }
+
+  acquireCached(sessionKey, persistedBytes = 0) {
+    const context = this.sessions.get(String(sessionKey));
+    if (!context) return;
+    context.activeUsers = (context.activeUsers || 0) + 1;
+    context.lastAccessedAt = Date.now();
+    context.persistedBytes = Math.max(0, Number(persistedBytes) || 0);
+  }
+
+  releaseCached(sessionKey, persistedBytes = 0) {
+    const context = this.sessions.get(String(sessionKey));
+    if (!context) return;
+    context.activeUsers = Math.max(0, (context.activeUsers || 0) - 1);
+    context.lastAccessedAt = Date.now();
+    context.persistedBytes = Math.max(0, Number(persistedBytes) || 0);
+  }
+
+  cacheUsage() {
+    return {
+      sessions: this.sessions.size,
+      persistedBytes: [...this.sessions.values()].reduce((total, context) => total + (context.persistedBytes || 0), 0)
+    };
+  }
+
+  cacheOverLimit() {
+    const usage = this.cacheUsage();
+    return usage.sessions > this.cachePolicy.maxSessions
+      || usage.persistedBytes > this.cachePolicy.maxPersistedBytes;
+  }
+
+  evictionCandidate(protectedKeys = new Set()) {
+    return [...this.sessions.entries()]
+      .filter(([key, context]) => !protectedKeys.has(key) && !(context.activeUsers > 0) && !context.session?.isStreaming)
+      .sort((left, right) => (left[1].lastAccessedAt || 0) - (right[1].lastAccessedAt || 0))[0];
+  }
+
+  async evictInactive({ protectedSessionKeys = [] } = {}) {
+    const protectedKeys = new Set(protectedSessionKeys.map(String));
+    const evicted = [];
+    let candidate = this.evictionCandidate(protectedKeys);
+    while (candidate) {
+      const [sessionKey, context] = candidate;
+      evicted.push({ sessionKey, persistedBytes: context.persistedBytes || 0 });
+      this.logger?.log("agent", `evicting inactive Pi session for chat ${sessionKey} from resident cache`);
+      await this.closeCached(sessionKey);
+      candidate = this.evictionCandidate(protectedKeys);
+    }
+    return evicted;
+  }
+
+  async enforceCachePolicy({ protectedSessionKeys = [] } = {}) {
+    const protectedKeys = new Set(protectedSessionKeys.map(String));
+    const evicted = [];
+    while (this.cacheOverLimit()) {
+      const candidate = this.evictionCandidate(protectedKeys);
+      if (!candidate) break;
+      const [sessionKey, context] = candidate;
+      evicted.push({ sessionKey, persistedBytes: context.persistedBytes || 0 });
+      this.logger?.log("agent", `evicting inactive Pi session for chat ${sessionKey} from resident cache`);
+      await this.closeCached(sessionKey);
+    }
+    return evicted;
   }
 
   closeCached(sessionKey) {
@@ -147,7 +218,12 @@ export class AgentSessionLifecycle {
 
   async getDiagnostic() {
     const contexts = await Promise.all([...this.sessions.entries()].map(async ([chatId, context]) => {
-      const base = { chatId };
+      const base = {
+        chatId,
+        activeUsers: context.activeUsers || 0,
+        persistedBytes: context.persistedBytes || 0,
+        lastAccessedAt: context.lastAccessedAt || null
+      };
       try {
         const stats = context.session.getSessionStats();
         const retained = this.summarizeContext(context.session.messages);
@@ -166,6 +242,7 @@ export class AgentSessionLifecycle {
       harness: "pi",
       sessions: this.sessions.size,
       closingSessions: this.sessionClosePromises.size,
+      cache: { ...this.cachePolicy, ...this.cacheUsage() },
       contexts
     };
   }

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

@@ -1,6 +1,6 @@
 import os from "node:os";
 import path from "node:path";
-import { arisaHomeDir } from "../../runtime/paths.js";
+import { arisaHomeDir } from "../../platform/paths.js";
 
 const defaultShellTimeoutMs = 60_000;
 

package/src/core/agent/pi-auth-login.js

@@ -1,5 +1,5 @@
 import { AuthStorage } from "@earendil-works/pi-coding-agent";
-import { piAuthFile } from "../../runtime/paths.js";
+import { piAuthFile } from "../../platform/paths.js";
 
 export function createPiOAuthLogin({ provider, onAuth, onDeviceCode, onPrompt, onProgress, onSelect } = {}) {
   const authStorage = AuthStorage.create(piAuthFile);

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/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/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";

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

@@ -19,7 +19,17 @@ export const daemonConfigDefaults = Object.freeze({
 export const toolExecutionConfigDefaults = Object.freeze({
   defaultCapacity: 2,
   maxQueuedPerClass: 100,
-  capacities: Object.freeze({ orchestrator: 1 })
+  maxWorkerRssMb: 384,
+  maxSwapUsedPercent: 95,
+  initialToolMemoryMb: 384,
+  minimumToolMemoryMb: 128,
+  maximumToolMemoryMb: 4096,
+  systemReserveMb: 128,
+  coreReserveMb: 384,
+  toolHeapPercent: 65,
+  toolMemoryHighPercent: 85,
+  toolSwapMaxMb: 128,
+  capacities: Object.freeze({ browser: 1, orchestrator: 1 })
 });
 
 export const telegramConfigDefaults = Object.freeze({
@@ -58,6 +68,17 @@ export const taskConfigDefaults = Object.freeze({
 export const piConfigDefaults = Object.freeze({
   thinkingLevel: "medium",
   speed: 1,
+  sessionCache: Object.freeze({
+    maxSessions: 3,
+    maxPersistedBytes: 48 * 1024 * 1024
+  }),
+  heapCircuitBreaker: Object.freeze({
+    enabled: true,
+    softPercent: 70,
+    criticalPercent: 82,
+    waitMs: 15_000,
+    pollMs: 500
+  }),
   compaction: Object.freeze({
     enabled: true,
     reserveTokens: 120_000,
@@ -108,6 +129,14 @@ export function applyConfigDefaults(config) {
     pi: {
       ...piConfigDefaults,
       ...configuredPi,
+      sessionCache: {
+        ...piConfigDefaults.sessionCache,
+        ...(configuredPi.sessionCache || {})
+      },
+      heapCircuitBreaker: {
+        ...piConfigDefaults.heapCircuitBreaker,
+        ...(configuredPi.heapCircuitBreaker || {})
+      },
       compaction: {
         ...piConfigDefaults.compaction,
         ...(configuredPi.compaction || {})

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

@@ -1,6 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { configFile } from "../../runtime/paths.js";
+import { configFile } from "../../platform/paths.js";
 import { applyConfigDefaults } from "./config-defaults.js";
 
 export function prepareConfigForSave(config) {

package/src/core/conversation/session-seed-store.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import {
   getChatLegacyConversationHistoryFile,
   getChatSessionSeedFile
-} from "../../runtime/paths.js";
+} from "../../platform/paths.js";
 
 function parseRecords(contents) {
   return String(contents || "")

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

@@ -1,7 +1,7 @@
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
-import { tasksFile } from "../../runtime/paths.js";
+import { tasksFile } from "../../platform/paths.js";
 
 const DEFAULT_RETRY = Object.freeze({
   maxAttempts: 3,