@astralyn/pi 1.4.5 → 1.4.7

package/dist/core/tasks/runtime.js

@@ -1,40 +1,50 @@
 import { randomUUID } from "node:crypto";
-import { TASKS_WAIT_DEFAULT_MS, TASKS_WAIT_MAX_MS } from "./limits.js";
-import { boundText, finiteLimit, readOutputSlice, retainResult, sliceText, TASK_INFO_BYTES, TASK_TITLE_BYTES, } from "./output.js";
-import { changed, snapshotOf, TaskStore } from "./store.js";
-import { TASK_BACKGROUND_REJECTION, TaskExecutionError, TaskLookupError, } from "./types.js";
-function errorText(error) {
-    try {
-        return boundText(error instanceof Error ? error.message : String(error), 4096);
-    }
-    catch {
-        return "Task execution failed (unprintable error)";
-    }
-}
+import { finiteLimit } from "../../utils/number.js";
+import { Execution } from "./execution.js";
+import { boundWaitMs, TASKS_WAIT_DEFAULT_MS } from "./limits.js";
+import { boundFacts, boundInput, boundText, errorText, readOutputSlice, sliceText, TASK_LABEL_BYTES, TASK_TITLE_BYTES, } from "./output.js";
+import { TaskRecord } from "./record.js";
+import { TaskScheduler } from "./scheduler.js";
+import { TaskStore } from "./store.js";
+import { TASK_BACKGROUND_REJECTION, TASK_KIND_PATTERN, TaskLookupError, } from "./types.js";
 /** Session-local supervision. Executors own their processes, items and output files. */
 export class TaskRuntime {
-    get closed() {
-        return this._closed;
-    }
-    get session() {
-        return this.options.session;
-    }
     constructor(options = {}) {
         this.executions = new Map();
+        this.scheduler = new TaskScheduler();
         this.listeners = new Set();
         this._closed = false;
-        this.pauses = 0;
         this.options = options;
         this.configuredEnabled = options.enabled ?? false;
-        this.maxActive = Math.max(1, finiteLimit(options.maxActive, 8, 128));
+        this.maxBackground = Math.max(1, finiteLimit(options.maxBackground, 8, 128));
         this.maxHistory = finiteLimit(options.maxHistory, 32, 1024);
         // Separate foreground and background histories, plus the protected-record allowance.
-        this.maxRetained = this.maxActive + 2 * Math.max(1, this.maxHistory) + this.maxHistory;
+        this.maxRetained = this.maxBackground + 2 * Math.max(1, this.maxHistory) + this.maxHistory;
         this.store = new TaskStore(this.maxHistory, this.maxRetained, () => this.closed, options.onCleanupError);
+        const runtime = this;
+        this.host = {
+            get closed() {
+                return runtime.closed;
+            },
+            emit: () => this.emit(),
+            settle: (task, usage) => this.options.onSettled?.(task, usage),
+            released: (execution) => {
+                this.executions.delete(execution.task.id);
+                this.scheduler.release(execution);
+                this.store.trim();
+                this.emit();
+            },
+        };
+    }
+    get closed() {
+        return this._closed;
+    }
+    get session() {
+        return this.options.session;
     }
     /**
-     * Rehydrate terminal version-2 custom data only, newest endedAt in each history
-     * (later input wins ties). Existing runtime records win ID collisions. No execution, accounting,
+     * Rehydrate terminal snapshots only, newest endedAt in each history (later input wins
+     * ties). Existing runtime records win ID collisions. No execution, accounting,
      * notification, or deletion ownership is restored. Foreground records take their output
      * from the branch's tool results. The host supplies the current branch; closed services
      * ignore restoration.
@@ -49,16 +59,15 @@ export class TaskRuntime {
         this.configuredEnabled = enabled;
         this.emit();
     }
-    /** Foreground work is bounded by its caller; only background work holds a slot. */
+    /** Foreground work is bounded by its caller; only background work, queued or running, holds a slot. */
+    activeBackground() {
+        return this.store.unsettled().filter((record) => record.task.mode === "background");
+    }
     backgroundActive() {
-        let count = 0;
-        for (const record of this.store.records.values())
-            if (!record.settled && record.task.mode === "background")
-                count++;
-        return count;
+        return this.activeBackground().length;
     }
     limitError() {
-        return new Error(`Background task limit reached (${this.maxActive}); stop or wait for a background task, or run in the foreground.`);
+        return new Error(`Background task limit reached (${this.maxBackground}); stop or wait for a background task, or run in the foreground.`);
     }
     async execute(execution) {
         // Admission and registration happen synchronously, before invoking user code or awaiting anything.
@@ -69,302 +78,106 @@ export class TaskRuntime {
         if (execution.background) {
             if (!this.enabled)
                 throw new Error("Background execution is not available in this host");
-            if (this.backgroundActive() >= this.maxActive)
+            if (this.backgroundActive() >= this.maxBackground)
                 throw this.limitError();
-            if (this.store.records.size + this.store.cleanups.size >= this.maxRetained) {
+            if (this.store.retainedCount() >= this.maxRetained) {
                 throw new Error("Task history retention limit reached; deliver pending notifications or release pinned or claimed records");
             }
         }
         if (execution.signal?.aborted)
             throw execution.signal.reason ?? new Error("Execution aborted");
-        if (!/^[a-z][a-z0-9-]{0,63}$/.test(execution.kind))
+        if (!TASK_KIND_PATTERN.test(execution.kind))
             throw new Error("Invalid task source");
+        const concurrency = execution.concurrency;
+        if (concurrency && (!concurrency.key || !Number.isSafeInteger(concurrency.limit) || concurrency.limit < 1))
+            throw new Error("Invalid task concurrency");
         const anchorId = this.options.anchor?.() ?? null;
         if (anchorId !== null && Buffer.byteLength(anchorId) > 8192)
             throw new Error("Task branch anchor is too large");
-        const info = execution.info === undefined ? undefined : boundText(execution.info, TASK_INFO_BYTES);
         const task = {
             id: `${execution.kind}-${randomUUID()}`,
             kind: execution.kind,
+            label: boundText(execution.label ?? execution.kind, TASK_LABEL_BYTES),
             title: boundText(execution.title, TASK_TITLE_BYTES),
+            output: execution.output ?? "log",
+            ...(execution.input ? { input: boundInput(execution.input) } : {}),
+            ...(execution.facts?.length ? { facts: boundFacts(execution.facts) } : {}),
             toolCallId: boundText(execution.toolCallId, 512),
             anchorId,
             mode: execution.background ? "background" : "foreground",
             status: "queued",
             startedAt: Date.now(),
-            command: execution.command === undefined ? undefined : boundText(execution.command, 8192),
-            commandTruncated: execution.command === undefined ? undefined : boundText(execution.command, 8192) !== execution.command,
-            cwd: execution.cwd === undefined ? undefined : boundText(execution.cwd, 4096),
-            info: info === undefined ? undefined : { text: info, truncated: info !== execution.info },
-        };
-        let resolveCaller;
-        let rejectCaller;
-        const caller = new Promise((resolve, reject) => {
-            resolveCaller = resolve;
-            rejectCaller = reject;
-        });
-        let resolveDone;
-        const record = {
-            task,
-            settled: false,
-            visible: true,
-            delivery: "none",
-            pins: 0,
-            deliveryHolds: 0,
-            waiters: new Set(),
         };
-        const active = {
-            controller: new AbortController(),
-            accepted: false,
-            handedOff: false,
-            detachRequested: execution.background ?? false,
-            modeListeners: new Set(),
-            removeParent: () => { },
-            handoff: () => {
-                if (!active.accepted ||
-                    !active.detachRequested ||
-                    record.settled ||
-                    active.handedOff ||
-                    this.closed ||
-                    !record.visible ||
-                    active.controller.signal.aborted)
-                    return;
-                active.handedOff = true;
-                task.mode = "background";
-                changed(record);
-                active.removeParent();
-                resolveCaller({ kind: "background", task: snapshotOf(record) });
-                this.emit();
-            },
-            done: new Promise((resolve) => {
-                resolveDone = resolve;
-            }),
-        };
-        const parentSignal = execution.signal;
-        let onUpdate = execution.background ? undefined : execution.onUpdate;
-        const parentAbort = () => {
-            if (!active.detachRequested || !active.accepted)
-                this.cancel(record);
-        };
-        parentSignal?.addEventListener("abort", parentAbort, { once: true });
-        active.removeParent = () => {
-            parentSignal?.removeEventListener("abort", parentAbort);
-            onUpdate = undefined;
-        };
-        this.store.records.set(task.id, record);
+        const record = new TaskRecord(task);
+        const active = new Execution(this.host, record, execution);
+        this.store.add(record);
         this.executions.set(task.id, active);
-        const control = {
-            id: task.id,
-            signal: active.controller.signal,
-            get mode() {
-                return task.mode;
-            },
-            onModeChange: (listener) => {
-                if (record.settled || this.closed)
-                    return () => { };
-                active.modeListeners.add(listener);
-                return () => {
-                    active.modeListeners.delete(listener);
-                };
-            },
-            requestCancel: () => this.cancel(record),
-            accept: () => {
-                if (record.settled || active.accepted || this.closed || active.controller.signal.aborted)
-                    return;
-                active.accepted = true;
-                if (task.status === "queued")
-                    task.status = "running";
-                changed(record);
-                if (active.detachRequested)
-                    active.removeParent();
-                // Let an already available final result win over a handoff.
-                queueMicrotask(() => queueMicrotask(active.handoff));
-                this.emit();
-            },
-            publish: (result) => {
-                if (record.settled || this.closed)
-                    return;
-                retainResult(task, result);
-                changed(record);
-                if (result.usage !== undefined)
-                    active.publishedUsage = structuredClone(result.usage);
-                if (!active.detachRequested && !active.handedOff) {
-                    try {
-                        onUpdate?.(result);
-                    }
-                    catch {
-                        /* UI observers cannot stop execution. */
-                    }
-                }
-                this.emit();
-            },
-            setOutputPath: (path, cleanup) => {
-                if (record.settled) {
-                    if (cleanup)
-                        throw new Error("Task execution has settled");
-                    return;
-                }
-                if (record.cleanup)
-                    throw new Error("Managed output is already registered");
-                // Never truncate a real filesystem path into a different path.
-                if (Buffer.byteLength(path) > 8192)
-                    throw new Error("Task output path is too large");
-                record.cleanup = cleanup;
-                task.outputPath = path;
-                changed(record);
-                this.emit();
-            },
-        };
-        const finish = (completion, error) => {
-            if (record.settled)
-                return;
-            record.settled = true;
-            active.modeListeners.clear();
-            active.removeParent();
-            task.endedAt = Date.now();
-            const failed = completion === undefined;
-            task.status =
-                completion?.status ??
-                    (error instanceof TaskExecutionError
-                        ? error.status
-                        : active.controller.signal.aborted
-                            ? "cancelled"
-                            : failed
-                                ? "failed"
-                                : "completed");
-            if (completion) {
-                retainResult(task, completion.result);
-                if (completion.error !== undefined)
-                    task.error = boundText(completion.error, 4096);
-                if (completion.exitCode !== undefined)
-                    task.exitCode = completion.exitCode;
-            }
-            if (failed) {
-                task.error = errorText(error);
-                retainResult(task, { content: [{ type: "text", text: task.error }, ...(task.result?.content ?? [])], details: undefined }, task.resultTruncated);
-            }
-            changed(record);
-            let settlementWarning;
-            try {
-                this.options.onSettled?.(snapshotOf(record), completion?.usage ?? completion?.result.usage ?? active.publishedUsage);
-            }
-            catch (accountingError) {
-                const warning = `Usage settlement failed: ${errorText(accountingError)}`;
-                settlementWarning = warning;
-                task.error = boundText([task.error, warning].filter(Boolean).join("\n"), 8192);
-                retainResult(task, { content: [{ type: "text", text: warning }, ...(task.result?.content ?? [])], details: undefined }, task.resultTruncated);
-                changed(record);
-            }
-            active.publishedUsage = undefined;
-            // Delivery becomes eligible only after settlement is persisted.
-            record.delivery = active.handedOff ? "pending" : "delivered";
-            if (!active.handedOff) {
-                if (failed)
-                    rejectCaller(error);
-                else {
-                    const { usage: _usage, ...result } = completion.result;
-                    if (settlementWarning)
-                        result.content = [{ type: "text", text: settlementWarning }, ...result.content];
-                    resolveCaller({ kind: "result", result, status: task.status, error: task.error });
-                }
-            }
-            for (const waiter of [...record.waiters])
-                waiter();
-            resolveDone();
-            this.executions.delete(task.id);
-            this.store.trim();
-            this.emit();
-        };
-        // The rejection handler is installed immediately, including for synchronous preflight throws.
-        try {
-            const running = execution.run(control);
-            void Promise.resolve(running).then((result) => finish(result), (error) => finish(undefined, error));
-        }
-        catch (error) {
-            finish(undefined, error);
-        }
+        this.scheduler.schedule(active);
+        // Queued background work returns at once; started work hands off after its own accept().
+        if (active.queued)
+            active.handoff();
         this.emit();
-        return caller;
+        return active.caller;
     }
     detachable(record) {
-        const active = this.executions.get(record.task.id);
-        return !!active && !record.settled && !active.detachRequested && !active.controller.signal.aborted;
+        return this.executions.get(record.task.id)?.detachable ?? false;
     }
     detachForeground() {
         if (!this.enabled)
             return 0;
-        const eligible = [...this.store.records.values()]
-            .filter((record) => this.detachable(record))
+        const eligible = [...this.executions.values()]
+            .filter((execution) => execution.detachable)
             .sort((left, right) => left.task.startedAt - right.task.startedAt);
         if (!eligible.length)
             return 0;
-        const free = this.maxActive - this.backgroundActive();
+        const free = this.maxBackground - this.backgroundActive();
         if (free <= 0)
             throw this.limitError();
-        const records = eligible.slice(0, free);
-        for (const record of records)
-            this.prepareDetach(record);
-        for (const record of records)
-            this.finishDetach(record);
+        const executions = eligible.slice(0, free);
+        for (const execution of executions)
+            execution.requestDetach();
+        for (const execution of executions)
+            execution.completeDetach();
         this.emit();
-        return records.length;
+        return executions.length;
     }
     canDetach(id) {
         const record = this.lookup(id);
-        return this.enabled && this.backgroundActive() < this.maxActive && this.detachable(record);
+        return this.enabled && this.backgroundActive() < this.maxBackground && this.detachable(record);
     }
     detach(id) {
         const record = this.lookup(id);
         if (!this.enabled || !this.detachable(record))
             return false;
-        if (this.backgroundActive() >= this.maxActive)
+        if (this.backgroundActive() >= this.maxBackground)
             throw this.limitError();
-        this.prepareDetach(record);
-        this.finishDetach(record);
+        const execution = this.executions.get(record.task.id);
+        execution.requestDetach();
+        execution.completeDetach();
         this.emit();
         return true;
     }
-    prepareDetach(record) {
-        const active = this.executions.get(record.task.id);
-        active.detachRequested = true;
-        record.task.mode = "background";
-        changed(record);
-        if (active.accepted)
-            active.removeParent();
-    }
-    finishDetach(record) {
-        const active = this.executions.get(record.task.id);
-        active.handoff();
-        for (const listener of active.modeListeners) {
-            try {
-                listener(record.task.mode);
-            }
-            catch {
-                /* Executors own their diagnostics. */
-            }
-        }
-    }
     list() {
-        return [...this.store.records.values()].filter((record) => record.visible).map(snapshotOf);
+        return this.store.visible().map((record) => record.snapshot());
     }
     lookup(id) {
-        const exact = this.store.records.get(id);
+        const exact = this.store.get(id);
         if (exact)
             return exact;
-        const matches = [...this.store.records.values()].filter(({ task }) => task.id.startsWith(id) || task.id.slice(task.kind.length + 1).startsWith(id));
+        const matches = this.store.match(id);
         if (!id || matches.length !== 1) {
-            throw new TaskLookupError(matches.length > 1 ? "ambiguous" : "unknown", matches.map(snapshotOf));
+            throw new TaskLookupError(matches.length > 1 ? "ambiguous" : "unknown", matches.map((record) => record.snapshot()));
         }
         return matches[0];
     }
     get(id) {
-        return snapshotOf(this.lookup(id));
+        return this.lookup(id).snapshot();
     }
     async read(id, options = {}) {
         const record = this.lookup(id);
         const release = this.retain(record.task.id);
         try {
-            const task = snapshotOf(record);
+            const task = record.snapshot();
             if (task.outputPath) {
                 try {
                     return { task, ...(await readOutputSlice(task.outputPath, options)) };
@@ -384,12 +197,7 @@ export class TaskRuntime {
         }
     }
     resultText(task) {
-        return boundText(task.result?.content
-            .filter((block) => block.type === "text")
-            .map((block) => block.text)
-            .join("\n") ||
-            task.error ||
-            "No output yet.");
+        return task.result?.text || task.error || "No output yet.";
     }
     /** One event-driven waiter can observe a whole waitAny cohort without per-task timers. */
     waitForRecords(records, timeoutMs, signal, interruptSignal) {
@@ -422,47 +230,82 @@ export class TaskRuntime {
                 record.waiters.add(wake);
             signal?.addEventListener("abort", abort, { once: true });
             interruptSignal?.addEventListener("abort", interrupt, { once: true });
-            timer = setTimeout(wake, finiteLimit(timeoutMs, TASKS_WAIT_DEFAULT_MS, TASKS_WAIT_MAX_MS));
+            timer = setTimeout(wake, boundWaitMs(timeoutMs));
             if (this.closed || interruptSignal?.aborted)
                 wake();
             if (signal?.aborted)
                 abort();
         });
     }
-    /** Observe completion without consuming delivery; the host acknowledges only persisted tool results. */
-    async wait(id, timeoutMs = TASKS_WAIT_DEFAULT_MS, signal, interruptSignal) {
-        if (signal?.aborted)
-            throw signal.reason ?? new Error("Wait aborted");
+    /**
+     * One observation: hold delivery for the observed records, wait, read, then register the
+     * receipt with the host, and only then release. Nothing the caller does between those steps
+     * can leak a settled result into an automatic notification or lose it.
+     */
+    async observe(records, options, 
+    /** Record to read when none settled; a cohort has none. */
+    fallback) {
+        const { signal } = options;
+        const releases = records.map((record) => this.holdRecord(record));
+        try {
+            const start = Date.now();
+            const interrupt = this.options.waits?.interruptSignal;
+            await this.waitForRecords(records, options.timeoutMs ?? TASKS_WAIT_DEFAULT_MS, signal, interrupt);
+            const waitedMs = Date.now() - start;
+            const settled = records
+                .filter((record) => record.settled)
+                .sort((left, right) => (left.task.endedAt ?? 0) - (right.task.endedAt ?? 0))[0];
+            const outcome = settled
+                ? "settled"
+                : this.closed
+                    ? "closed"
+                    : interrupt?.aborted
+                        ? "interrupted"
+                        : "timed_out";
+            const running = records
+                .filter((record) => record.visible && !record.settled)
+                .map((record) => record.snapshot());
+            const observed = settled ?? fallback;
+            const read = options.read && observed && outcome !== "interrupted"
+                ? await this.read(observed.task.id, options.read)
+                : undefined;
+            signal?.throwIfAborted();
+            if (settled && settled.task.mode === "background" && options.toolCallId)
+                this.options.waits?.bind(options.toolCallId, settled.task.id);
+            return { outcome, waitedMs, settled, running, read };
+        }
+        finally {
+            for (const release of releases)
+                release();
+        }
+    }
+    async wait(id, options = {}) {
+        if (options.signal?.aborted)
+            throw options.signal.reason ?? new Error("Wait aborted");
         const record = this.lookup(id);
-        if (record.settled)
-            return snapshotOf(record);
-        await this.waitForRecords([record], timeoutMs, signal, interruptSignal);
-        return snapshotOf(record);
-    }
-    async waitAny(timeoutMs = TASKS_WAIT_DEFAULT_MS, signal, interruptSignal) {
-        if (signal?.aborted)
-            throw signal.reason ?? new Error("Wait aborted");
-        const records = [...this.store.records.values()].filter((record) => record.visible && record.task.mode === "background" && !record.settled);
-        if (records.length === 0 || interruptSignal?.aborted)
-            return undefined;
-        await this.waitForRecords(records, timeoutMs, signal, interruptSignal);
-        const settled = records
-            .filter((record) => record.settled)
-            .sort((left, right) => (left.task.endedAt ?? 0) - (right.task.endedAt ?? 0))[0];
-        return settled ? snapshotOf(settled) : undefined;
+        const { outcome, waitedMs, read } = await this.observe([record], options, record);
+        return { outcome, waitedMs, task: record.snapshot(), ...(read ? { read } : {}) };
+    }
+    async waitAny(options = {}) {
+        if (options.signal?.aborted)
+            throw options.signal.reason ?? new Error("Wait aborted");
+        const records = this.activeBackground().filter((record) => record.visible);
+        if (records.length === 0)
+            return { outcome: "no_tasks", waitedMs: 0, running: [] };
+        const { outcome, waitedMs, settled, running, read } = await this.observe(records, options);
+        return {
+            outcome,
+            waitedMs,
+            running,
+            ...(settled ? { task: settled.snapshot() } : {}),
+            ...(read ? { read } : {}),
+        };
     }
     kill(id) {
         return this.cancel(this.lookup(id));
     }
     cancel(record) {
-        const active = this.executions.get(record.task.id);
-        if (!active || record.settled || active.controller.signal.aborted)
-            return false;
-        record.task.status = "stopping";
-        changed(record);
-        active.controller.abort();
-        this.emit();
-        return true;
+        return this.executions.get(record.task.id)?.cancel() ?? false;
     }
     subscribe(listener) {
         if (this.closed)
@@ -476,7 +319,9 @@ export class TaskRuntime {
      * Retention protects snapshots and logs only. Delivery has its own explicit hold.
      */
     retain(id) {
-        const record = this.lookup(id);
+        return this.pin(this.lookup(id));
+    }
+    pin(record) {
         record.pins++;
         let released = false;
         return () => {
@@ -485,13 +330,16 @@ export class TaskRuntime {
             released = true;
             record.pins--;
             this.store.trim();
-            if (!this.closed && this.pauses === 0 && this.candidate(record))
+            // Listeners decide whether delivery may proceed; TaskDelivery owns pausing.
+            if (!this.closed && record.deliverable)
                 this.emit();
         };
     }
     holdDelivery(id) {
-        const record = this.lookup(id);
-        const releaseRetention = this.retain(id);
+        return this.holdRecord(this.lookup(id));
+    }
+    holdRecord(record) {
+        const releasePin = this.pin(record);
         record.deliveryHolds++;
         let released = false;
         return () => {
@@ -499,50 +347,27 @@ export class TaskRuntime {
                 return;
             released = true;
             record.deliveryHolds--;
-            releaseRetention();
-        };
-    }
-    pause() {
-        this.pauses++;
-        let resumed = false;
-        return () => {
-            if (resumed)
-                return;
-            resumed = true;
-            this.pauses--;
-            this.emit();
+            releasePin();
         };
     }
     pendingNotifications() {
-        if (this.closed || this.pauses > 0)
+        if (this.closed)
             return [];
-        return [...this.store.records.values()].filter((record) => this.candidate(record)).map(snapshotOf);
-    }
-    /** Only explicit result-delivery holds delay an automatic completion. */
-    candidate(record) {
-        return record.visible && record.delivery === "pending" && record.waiters.size === 0 && record.deliveryHolds === 0;
+        return this.store.deliverable().map((record) => record.snapshot());
     }
     claimNotification(id) {
-        if (this.closed || this.pauses > 0)
-            return false;
-        const record = this.store.records.get(id);
-        if (!record || !this.candidate(record))
-            return false;
-        record.delivery = "claimed";
-        return true;
+        return !this.closed && (this.store.get(id)?.claim() ?? false);
     }
     markDelivered(id) {
-        const record = this.store.records.get(id);
+        const record = this.store.get(id);
         if (!record)
             return;
-        record.delivery = "delivered";
+        record.acknowledge();
         this.store.trim();
     }
     releaseNotification(id) {
-        const record = this.store.records.get(id);
-        if (!record || record.delivery !== "claimed")
+        if (!this.store.get(id)?.unclaim())
             return;
-        record.delivery = "pending";
         this.store.trim();
         this.emit();
     }
@@ -551,8 +376,8 @@ export class TaskRuntime {
             return;
         this._closed = true;
         this.listeners.clear();
-        for (const record of this.store.records.values()) {
-            this.executions.get(record.task.id)?.removeParent();
+        for (const record of this.store.all()) {
+            this.executions.get(record.task.id)?.releaseParent();
             this.cancel(record);
             for (const waiter of [...record.waiters])
                 waiter();
@@ -561,22 +386,24 @@ export class TaskRuntime {
     }
     async shutdown(graceMs = 2000) {
         this.close();
-        await this.drain([...this.store.records.values()], graceMs);
+        await this.drain(this.store.all(), graceMs);
     }
     /** Running tasks whose launch anchor is outside the branch made of `ancestors`. */
     activeOutsideBranch(ancestors) {
-        return [...this.store.records.values()]
-            .filter((record) => !record.settled && record.task.anchorId !== null && !ancestors.has(record.task.anchorId))
-            .map(snapshotOf);
+        return this.store
+            .unsettled()
+            .filter((record) => record.task.anchorId !== null && !ancestors.has(record.task.anchorId))
+            .map((record) => record.snapshot());
     }
     /**
      * Hidden results stay pending: returning to their branch delivers them again.
      * Restored history is already delivered.
      */
     async cancelOutsideBranch(ancestors) {
-        for (const record of this.store.records.values())
+        const records = this.store.all();
+        for (const record of records)
             record.visible = record.task.anchorId === null || ancestors.has(record.task.anchorId);
-        const outside = [...this.store.records.values()].filter((record) => !record.visible);
+        const outside = records.filter((record) => !record.visible);
         for (const record of outside)
             this.cancel(record);
         this.store.trim();
@@ -587,7 +414,7 @@ export class TaskRuntime {
         let timer;
         try {
             await Promise.race([
-                Promise.all(records.map((record) => this.executions.get(record.task.id)?.done)).then(() => Promise.all(this.store.cleanups)),
+                Promise.all(records.map((record) => this.executions.get(record.task.id)?.done)).then(() => this.store.cleanupsDone()),
                 new Promise((resolve) => {
                     timer = setTimeout(resolve, finiteLimit(graceMs, 2000, 60_000));
                 }),