@llblab/pi-kit 0.1.13 → 0.2.0

package/node_modules/@llblab/pi-actors/dist/lib/run-ui-runtime.js

@@ -4,19 +4,25 @@
  * Owns event-driven run UI coordination without owning actor execution semantics.
  */
 import * as AsyncRuns from "./async-runs.js";
+import * as Limits from "./limits.js";
 import * as Observability from "./observability.js";
 import * as Paths from "./paths.js";
 import * as Pi from "./pi.js";
+import * as RunDelivery from "./run-delivery.js";
 export function createRunUiRuntime(deps) {
     let activeContext;
     let activeOwnerId;
     let animationInterval;
+    let deliveryTimeout;
     let notifyTimeout;
+    let recoverQueuedBatch = false;
+    let recoverQueuedSteers = false;
     let running = false;
     let lastWatcherDiagnosticId = 0;
     const observation = Observability.createRunUiObservationState();
+    const deliveryRecoveryDiagnostics = new Set();
     const retirementAttempts = new Set();
-    const terminalNotificationsInFlight = new Set();
+    const steerDiagnostics = new Set();
     const close = () => {
         running = false;
         activeContext = undefined;
@@ -36,6 +42,13 @@ export function createRunUiRuntime(deps) {
         if (notifyTimeout)
             clearTimeout(notifyTimeout);
         notifyTimeout = undefined;
+        if (deliveryTimeout)
+            clearTimeout(deliveryTimeout);
+        deliveryTimeout = undefined;
+        recoverQueuedBatch = false;
+        recoverQueuedSteers = false;
+        deliveryRecoveryDiagnostics.clear();
+        steerDiagnostics.clear();
         if (animationInterval)
             clearInterval(animationInterval);
         animationInterval = undefined;
@@ -79,18 +92,199 @@ export function createRunUiRuntime(deps) {
             sendStop: async (candidate) => AsyncRuns.cancelRun(candidate.stateDir),
         }).catch((error) => stopAfterCallbackFailure("Run retirement callback", error, ctx));
     };
+    const journal = (ownerId) => RunDelivery.readRunDeliveryJournal(Paths.EXTENSION_RUNTIME_PATHS.tempDir, ownerId);
+    const finishPresentedBatch = (ownerId, batch) => {
+        if (batch.phase !== "presented")
+            return false;
+        for (const member of batch.members) {
+            AsyncRuns.markRunTerminalNotificationHandled(member.state_dir, member.status, member.run_instance_id);
+        }
+        return RunDelivery.finalizeRunCompletionBatch({
+            batchId: batch.batch_id,
+            ownerId,
+            tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+        });
+    };
+    const recoverPresentedBatch = (ownerId) => {
+        const batch = journal(ownerId).completion_batch;
+        if (batch?.phase === "presented")
+            finishPresentedBatch(ownerId, batch);
+    };
+    const finishPresentedSteer = (ownerId, steer) => {
+        if (steer.phase !== "presented")
+            return false;
+        AsyncRuns.markRunSteerPresentationHandled(steer.state_dir, steer.run_instance_id, steer.event_id, steer.steer_id);
+        return RunDelivery.finalizeRunSteer({
+            ownerId,
+            steerId: steer.steer_id,
+            tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+        });
+    };
+    const recoverPresentedSteers = (ownerId) => {
+        for (const steer of journal(ownerId).steers) {
+            if (steer.phase === "presented")
+                finishPresentedSteer(ownerId, steer);
+        }
+    };
+    const boundedSteerContent = (event) => {
+        const text = Observability.formatRunAttentionMessage(event);
+        if (Buffer.byteLength(text, "utf8") <= Limits.RUN_DELIVERY_STEER_MAX_BYTES) {
+            return text;
+        }
+        let end = Math.min(text.length, Limits.RUN_DELIVERY_STEER_MAX_BYTES - 3);
+        while (end > 0 && Buffer.byteLength(text.slice(0, end), "utf8") >
+            Limits.RUN_DELIVERY_STEER_MAX_BYTES - 3)
+            end -= 1;
+        return `${text.slice(0, end)}…`;
+    };
+    const admitSteerEvents = (ctx, ownerId, events) => {
+        for (const event of events.filter(Observability.isRunSteerAttentionEvent)) {
+            if (!event.runInstanceId) {
+                Observability.retryRunAttentionEvent(observation, event);
+                const key = `${event.stateDir}:${event.id}:missing_generation`;
+                if (!steerDiagnostics.has(key)) {
+                    steerDiagnostics.add(key);
+                    ctx.ui.notify(`Actor urgent steer ${event.id} remains retryable because its Run generation is unavailable.`, "warning");
+                }
+                continue;
+            }
+            try {
+                RunDelivery.admitRunSteerEnvelope({
+                    content: boundedSteerContent(event),
+                    eventId: event.id,
+                    kind: event.kind,
+                    level: event.level,
+                    occurredAt: event.ts,
+                    ownerId,
+                    run: event.run,
+                    runInstanceId: event.runInstanceId,
+                    stateDir: event.stateDir,
+                    tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+                });
+            }
+            catch (error) {
+                Observability.retryRunAttentionEvent(observation, event);
+                const message = error instanceof Error ? error.message : String(error);
+                const key = `${event.stateDir}:${event.id}:${message}`;
+                if (!steerDiagnostics.has(key)) {
+                    steerDiagnostics.add(key);
+                    ctx.ui.notify(`Actor urgent steer ${event.id} remains retryable: ${message.replaceAll(/\s+/g, " ").slice(0, 240)}`, "warning");
+                }
+            }
+        }
+    };
+    const admitCompletionTransitions = (ownerId, transitions) => {
+        const existing = journal(ownerId).completion_batch;
+        if (existing)
+            return true;
+        const members = Observability.collectRunCompletionBatchMembers(transitions)
+            .slice(0, Limits.RUN_DELIVERY_BATCH_MAX_MEMBERS);
+        if (members.length === 0)
+            return false;
+        RunDelivery.admitRunCompletionBatch({
+            members,
+            ownerId,
+            tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+        });
+        return true;
+    };
+    const isIdle = (ctx) => typeof ctx.isIdle !== "function" || ctx.isIdle();
+    let flushCompletionBatch = (_ctx) => false;
+    const flushSteers = (ctx, ownerId) => {
+        const recovering = recoverQueuedSteers;
+        for (const steer of journal(ownerId).steers) {
+            if (steer.phase === "presented") {
+                finishPresentedSteer(ownerId, steer);
+                continue;
+            }
+            let phase = steer.phase;
+            if (phase === "queued") {
+                if (!recovering)
+                    continue;
+                const evidence = Pi.inspectRunSteerSessionEvidence(ctx, {
+                    content: steer.content,
+                    eventId: steer.event_id,
+                    steerId: steer.steer_id,
+                });
+                if (evidence.status === "present")
+                    continue;
+                if (evidence.status !== "absent") {
+                    const key = `${steer.steer_id}:${evidence.status}:${evidence.reason ?? ""}`;
+                    if (!steerDiagnostics.has(key)) {
+                        steerDiagnostics.add(key);
+                        ctx.ui.notify(`Actor urgent steer recovery is ${evidence.status}: ${evidence.reason ?? "conflicting session evidence"}. Event ${steer.event_id} remains queued.`, "warning");
+                    }
+                    continue;
+                }
+                if (!RunDelivery.resetRunSteerPending({
+                    ownerId,
+                    steerId: steer.steer_id,
+                    tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+                }))
+                    continue;
+                phase = "pending";
+            }
+            if (phase !== "pending")
+                continue;
+            try {
+                Pi.sendRunSteer(deps.pi, {
+                    content: steer.content,
+                    eventId: steer.event_id,
+                    steerId: steer.steer_id,
+                });
+            }
+            catch (error) {
+                RunDelivery.recordRunSteerDeliveryFailure({
+                    error,
+                    ownerId,
+                    steerId: steer.steer_id,
+                    tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+                });
+                const message = error instanceof Error ? error.message : String(error);
+                ctx.ui.notify(`Actor urgent steer delivery failed for event ${steer.event_id}: ${message.replaceAll(/\s+/g, " ").slice(0, 240)}`, "error");
+                continue;
+            }
+            RunDelivery.markRunSteerQueued({
+                ownerId,
+                steerId: steer.steer_id,
+                tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+            });
+        }
+        recoverQueuedSteers = false;
+        return journal(ownerId).steers.length > 0;
+    };
+    const scheduleCompletionFlush = () => {
+        if (!running)
+            return;
+        if (deliveryTimeout)
+            clearTimeout(deliveryTimeout);
+        deliveryTimeout = setTimeout(() => {
+            deliveryTimeout = undefined;
+            runActiveCallback("completion delivery callback", (ctx) => {
+                flushCompletionBatch(ctx);
+            });
+        }, deps.deliveryDebounceMs ?? 100);
+        deliveryTimeout.unref?.();
+    };
     const update = (ctx, ownerId, notify = false, terminalOnly = false) => {
         const snapshot = Observability.readRunUiSnapshot(observation, ownerId);
         ctx.ui.setStatus("zz-pi-actors-runs", snapshot.status ? ctx.ui.theme.fg("dim", snapshot.status) : undefined);
         if (!notify)
-            return;
+            return false;
         const sink = Pi.createNotificationSink(deps.pi, ctx);
         retireCandidateRuns(ctx, snapshot.summary);
-        Observability.deliverRunTransitionNotifications(snapshot.transitions, sink, terminalNotificationsInFlight);
+        const hasCompletionCandidates = Observability.collectRunCompletionBatchMembers(snapshot.transitions).length > 0;
+        const hasCompletionBatch = Boolean(journal(ownerId).completion_batch);
+        admitSteerEvents(ctx, ownerId, snapshot.attentionEvents);
         Observability.pruneRunUiObservationState(observation, snapshot);
         if (!terminalOnly) {
-            Observability.deliverRunAttentionNotifications(snapshot.attentionEvents, sink);
+            Observability.deliverRunAttentionNotifications(snapshot.attentionEvents.filter((event) => !Observability.isRunSteerAttentionEvent(event)), sink);
+        }
+        const hasSteers = flushSteers(ctx, ownerId);
+        if ((hasCompletionBatch || hasCompletionCandidates) && isIdle(ctx)) {
+            scheduleCompletionFlush();
         }
+        return hasCompletionBatch || hasCompletionCandidates || hasSteers;
     };
     const reportDiagnostics = (ctx) => {
         for (const diagnostic of watcher.getDiagnostics()) {
@@ -108,8 +302,9 @@ export function createRunUiRuntime(deps) {
         notifyTimeout = setTimeout(() => {
             runActiveCallback("Run watcher callback", (ctx, ownerId) => {
                 watcher.refresh();
-                update(ctx, ownerId, true);
-                deps.onRunEvent();
+                const completionDeferred = update(ctx, ownerId, true);
+                if (!completionDeferred)
+                    deps.onRunEvent();
                 reportDiagnostics(ctx);
             });
         }, deps.notificationDelayMs ?? 50);
@@ -128,13 +323,7 @@ export function createRunUiRuntime(deps) {
         },
         reconcile: () => {
             runActiveCallback("terminal reconciliation callback", (ctx, ownerId) => {
-                Observability.reconcileRunTerminalNotifications({
-                    inFlight: terminalNotificationsInFlight,
-                    ownerId,
-                    sink: Pi.createNotificationSink(deps.pi, ctx),
-                    state: observation,
-                    includeAttention: true,
-                });
+                update(ctx, ownerId, true);
                 reportDiagnostics(ctx);
             });
         },
@@ -143,8 +332,143 @@ export function createRunUiRuntime(deps) {
                 watcher.refresh();
         },
     });
+    flushCompletionBatch = (ctx) => {
+        if (!running || activeContext !== ctx || deps.getActiveContext() !== ctx)
+            return false;
+        const ownerId = activeOwnerId;
+        if (!ownerId)
+            return false;
+        if (flushSteers(ctx, ownerId))
+            return true;
+        let batch = journal(ownerId).completion_batch;
+        if (!batch) {
+            const snapshot = Observability.readRunUiSnapshot(observation, ownerId);
+            admitCompletionTransitions(ownerId, snapshot.transitions);
+            Observability.pruneRunUiObservationState(observation, snapshot);
+            batch = journal(ownerId).completion_batch;
+        }
+        if (!batch)
+            return false;
+        if (batch.phase === "presented") {
+            finishPresentedBatch(ownerId, batch);
+            const snapshot = Observability.readRunUiSnapshot(observation, ownerId);
+            admitCompletionTransitions(ownerId, snapshot.transitions);
+            Observability.pruneRunUiObservationState(observation, snapshot);
+            batch = journal(ownerId).completion_batch;
+            if (!batch)
+                return false;
+        }
+        if (!isIdle(ctx))
+            return true;
+        const content = RunDelivery.formatRunCompletionBatchMessage(batch);
+        if (batch.phase === "queued") {
+            if (!recoverQueuedBatch)
+                return true;
+            recoverQueuedBatch = false;
+            const evidence = Pi.inspectRunCompletionBatchSessionEvidence(ctx, batch.batch_id, content);
+            if (evidence.status === "present")
+                return true;
+            if (evidence.status !== "absent") {
+                const diagnosticKey = `${batch.batch_id}:${evidence.status}:${evidence.reason ?? ""}`;
+                if (!deliveryRecoveryDiagnostics.has(diagnosticKey)) {
+                    deliveryRecoveryDiagnostics.add(diagnosticKey);
+                    ctx.ui.notify(`Actor completion recovery is ${evidence.status}: ${evidence.reason ?? "conflicting session evidence"}. Batch ${batch.batch_id} remains queued.`, "warning");
+                }
+                return true;
+            }
+            if (!RunDelivery.resetRunCompletionBatchPending({
+                batchId: batch.batch_id,
+                ownerId,
+                tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+            }))
+                return true;
+            batch = journal(ownerId).completion_batch;
+        }
+        if (!isIdle(ctx))
+            return true;
+        try {
+            Pi.sendRunCompletionBatch(deps.pi, batch.batch_id, content);
+        }
+        catch (error) {
+            RunDelivery.recordRunCompletionBatchDeliveryFailure({
+                batchId: batch.batch_id,
+                error,
+                ownerId,
+                tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+            });
+            throw error;
+        }
+        if (!RunDelivery.markRunCompletionBatchQueued({
+            batchId: batch.batch_id,
+            ownerId,
+            tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+        })) {
+            throw new Error("Completion batch changed before queue acknowledgment");
+        }
+        recoverQueuedBatch = false;
+        return true;
+    };
     return {
         close,
+        flushCompletionBatch,
+        projectContext(messages, ctx) {
+            if (!running || activeContext !== ctx || deps.getActiveContext() !== ctx) {
+                return messages;
+            }
+            const ownerId = activeOwnerId;
+            if (!ownerId)
+                return messages;
+            const steerContext = Pi.dedupeRunSteerContext(messages);
+            let contextMessages = steerContext.messages;
+            for (const steer of journal(ownerId).steers) {
+                const presented = steerContext.steers.get(steer.steer_id);
+                if (!presented ||
+                    presented.eventId !== steer.event_id ||
+                    presented.content !== steer.content) {
+                    contextMessages = Pi.removeRunSteerFromContext(contextMessages, steer.steer_id);
+                    continue;
+                }
+                if (!RunDelivery.markRunSteerQueued({
+                    ownerId,
+                    steerId: steer.steer_id,
+                    tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+                }))
+                    continue;
+                if (!RunDelivery.markRunSteerPresented({
+                    ownerId,
+                    steerId: steer.steer_id,
+                    tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+                }))
+                    continue;
+                const durable = journal(ownerId).steers.find((item) => item.steer_id === steer.steer_id);
+                if (durable)
+                    finishPresentedSteer(ownerId, durable);
+            }
+            const projected = Pi.dedupeRunCompletionBatchContext(contextMessages);
+            const batch = journal(ownerId).completion_batch;
+            if (!batch)
+                return projected.messages;
+            const content = projected.batches.get(batch.batch_id);
+            if (content !== RunDelivery.formatRunCompletionBatchMessage(batch)) {
+                return Pi.removeRunCompletionBatchFromContext(projected.messages, batch.batch_id);
+            }
+            if (!RunDelivery.markRunCompletionBatchQueued({
+                batchId: batch.batch_id,
+                ownerId,
+                tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+            }))
+                return projected.messages;
+            if (!RunDelivery.markRunCompletionBatchPresented({
+                batchId: batch.batch_id,
+                ownerId,
+                tempDir: Paths.EXTENSION_RUNTIME_PATHS.tempDir,
+            }))
+                return projected.messages;
+            const presented = journal(ownerId).completion_batch;
+            if (presented)
+                finishPresentedBatch(ownerId, presented);
+            return projected.messages;
+        },
         shutdown(eventReason, ownerId, ctx) {
             if (!ownerId)
                 return;
@@ -162,8 +486,12 @@ export function createRunUiRuntime(deps) {
             close();
             activeContext = ctx;
             activeOwnerId = ownerId;
+            recoverQueuedBatch = true;
+            recoverQueuedSteers = true;
             running = true;
             try {
+                recoverPresentedBatch(ownerId);
+                recoverPresentedSteers(ownerId);
                 Observability.primeRunAttentionState(observation, ownerId);
                 update(ctx, ownerId, true, true);
                 watcher.refresh();

package/node_modules/@llblab/pi-actors/dist/lib/runs-trace.d.ts

@@ -11,7 +11,7 @@ export interface TraceEvent {
     summary?: string;
     data?: unknown;
     level?: "info" | "warning" | "error";
-    attention?: "notify" | "followup";
+    attention?: "notify" | "followup" | "steer";
 }
 export interface AppendTraceEventInput {
     kind: string;

package/node_modules/@llblab/pi-actors/dist/lib/runs-trace.js

@@ -84,8 +84,9 @@ function normalizeTraceEventInput(input) {
     }
     if (record.attention !== undefined &&
         record.attention !== "notify" &&
-        record.attention !== "followup") {
-        throw new Error("Trace event attention must be notify or followup");
+        record.attention !== "followup" &&
+        record.attention !== "steer") {
+        throw new Error("Trace event attention must be notify, followup, or steer");
     }
     return {
         kind: record.kind,
@@ -212,7 +213,8 @@ function isTraceEvent(value) {
         return false;
     return record.attention === undefined ||
         record.attention === "notify" ||
-        record.attention === "followup";
+        record.attention === "followup" ||
+        record.attention === "steer";
 }
 function isCount(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;

package/node_modules/@llblab/pi-actors/dist/lib/session-evidence.d.ts

@@ -42,5 +42,21 @@ export interface SessionEvidenceReadOptions {
     maxToolCalls?: number;
     maxTurns?: number;
 }
+export type ActiveSessionEntryMatch = "present" | "conflict" | undefined;
+export interface ActiveSessionEntryEvidence {
+    examinedBytes: number;
+    examinedEntries: number;
+    reason?: string;
+    status: "present" | "absent" | "conflict" | "unknown";
+}
+export interface ActiveSessionEntryEvidenceInput {
+    getEntry(id: string): unknown;
+    leaf: unknown;
+    match(entry: Record<string, unknown>): ActiveSessionEntryMatch;
+    maxBytes?: number;
+    maxEntries?: number;
+}
+/** Walk only the active parent chain under exact entry and byte ceilings. */
+export declare function inspectBoundedActiveSessionEntries(input: ActiveSessionEntryEvidenceInput): ActiveSessionEntryEvidence;
 export declare function redactSessionEvidenceValue(value: unknown, maxTextChars?: number, seen?: WeakSet<object>): unknown;
 export declare function readSessionEvidence(path: string, options?: SessionEvidenceReadOptions): SessionEvidence;

package/node_modules/@llblab/pi-actors/dist/lib/session-evidence.js

@@ -6,6 +6,149 @@
 import * as Limits from "./limits.js";
 import { readJsonlFileResilient, } from "./state-readers.js";
 const SENSITIVE_KEY = /(?:^|[_-])(?:api[-_]?key|authorization|cookie|credential|password|private[-_]?key|secret|secret[-_]?access[-_]?key|token)$|^(?:access|refresh|auth|api)Token$|^(?:clientSecret|privateKey|secretAccessKey)$/i;
+function boundedJsonStringBytes(value) {
+    let bytes = Buffer.byteLength(value, "utf8") + 2;
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code === 0x22 || code === 0x5c)
+            bytes += 1;
+        else if (code < 0x20)
+            bytes += [0x08, 0x09, 0x0a, 0x0c, 0x0d].includes(code) ? 1 : 5;
+        else if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (next >= 0xdc00 && next <= 0xdfff)
+                index += 1;
+            else
+                bytes += 3;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff)
+            bytes += 3;
+    }
+    return bytes;
+}
+function boundedJsonBytes(value, ceiling, seen = new WeakSet()) {
+    if (value === null)
+        return 4;
+    if (typeof value === "string")
+        return boundedJsonStringBytes(value);
+    if (typeof value === "number")
+        return Number.isFinite(value) ? String(value).length : 4;
+    if (typeof value === "boolean")
+        return value ? 4 : 5;
+    if (typeof value !== "object")
+        return undefined;
+    if (seen.has(value))
+        return undefined;
+    seen.add(value);
+    let bytes = 2;
+    const values = Array.isArray(value)
+        ? value.map((item) => [
+            undefined,
+            item === undefined || typeof item === "function" || typeof item === "symbol"
+                ? null
+                : item,
+        ])
+        : Object.entries(value).filter(([, item]) => item !== undefined && typeof item !== "function" && typeof item !== "symbol");
+    for (const [key, item] of values) {
+        if (bytes > ceiling)
+            break;
+        if (bytes > 2)
+            bytes += 1;
+        if (key !== undefined)
+            bytes += boundedJsonStringBytes(key) + 1;
+        const itemBytes = boundedJsonBytes(item, ceiling - bytes, seen);
+        if (itemBytes === undefined) {
+            seen.delete(value);
+            return undefined;
+        }
+        bytes += itemBytes;
+    }
+    seen.delete(value);
+    return bytes;
+}
+/** Walk only the active parent chain under exact entry and byte ceilings. */
+export function inspectBoundedActiveSessionEntries(input) {
+    const maxBytes = input.maxBytes ?? Limits.RUN_DELIVERY_SESSION_MAX_BYTES;
+    const maxEntries = input.maxEntries ?? Limits.RUN_DELIVERY_SESSION_MAX_ENTRIES;
+    if (input.leaf === undefined || input.leaf === null) {
+        return { examinedBytes: 0, examinedEntries: 0, status: "absent" };
+    }
+    const visited = new Set();
+    let current = input.leaf;
+    let examinedBytes = 0;
+    let examinedEntries = 0;
+    while (current !== undefined) {
+        if (!current || typeof current !== "object" || Array.isArray(current)) {
+            return {
+                examinedBytes,
+                examinedEntries,
+                reason: "active session entry is malformed",
+                status: "unknown",
+            };
+        }
+        const entry = current;
+        if (typeof entry.id !== "string" || !entry.id) {
+            return {
+                examinedBytes,
+                examinedEntries,
+                reason: "active session entry id is malformed",
+                status: "unknown",
+            };
+        }
+        if (visited.has(entry.id)) {
+            return {
+                examinedBytes,
+                examinedEntries,
+                reason: "active session entry cycle detected",
+                status: "unknown",
+            };
+        }
+        visited.add(entry.id);
+        const bytes = boundedJsonBytes(entry, maxBytes - examinedBytes);
+        if (bytes === undefined) {
+            return {
+                examinedBytes,
+                examinedEntries,
+                reason: "active session entry is not serializable",
+                status: "unknown",
+            };
+        }
+        if (examinedEntries >= maxEntries || examinedBytes + bytes > maxBytes) {
+            return {
+                examinedBytes,
+                examinedEntries,
+                reason: "active session evidence exceeds its inspection bound",
+                status: "unknown",
+            };
+        }
+        examinedEntries += 1;
+        examinedBytes += bytes;
+        const matched = input.match(entry);
+        if (matched)
+            return { examinedBytes, examinedEntries, status: matched };
+        if (entry.parentId === null) {
+            return { examinedBytes, examinedEntries, status: "absent" };
+        }
+        if (typeof entry.parentId !== "string" || !entry.parentId) {
+            return {
+                examinedBytes,
+                examinedEntries,
+                reason: "active session parent is malformed",
+                status: "unknown",
+            };
+        }
+        current = input.getEntry(entry.parentId);
+        if (current === undefined) {
+            return {
+                examinedBytes,
+                examinedEntries,
+                reason: "active session parent is unavailable",
+                status: "unknown",
+            };
+        }
+    }
+    return { examinedBytes, examinedEntries, status: "unknown" };
+}
 const SENSITIVE_TEXT = /(bearer\s+)[A-Za-z0-9._~+/=-]+|["']?\b(api[-_]?key|authorization|clientSecret|cookie|password|private[-_]?key|privateKey|secret|secretAccessKey|token)["']?(\s*[:=]\s*)["']?([^\s,;"'}]+)/gi;
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)

package/node_modules/@llblab/pi-actors/dist/lib/temp.js

@@ -7,7 +7,7 @@ import { mkdir, readdir, readFile, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 export const DEFAULT_TEMP_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 export const DEFAULT_RUN_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-export async function cleanupStaleTempEntries(tempDir, maxAgeMs = DEFAULT_TEMP_MAX_AGE_MS, now = Date.now(), preservedEntries = new Set(["runs"])) {
+export async function cleanupStaleTempEntries(tempDir, maxAgeMs = DEFAULT_TEMP_MAX_AGE_MS, now = Date.now(), preservedEntries = new Set(["runs", "delivery"])) {
     let entries;
     let removed = 0;
     try {

package/node_modules/@llblab/pi-actors/dist/lib/tools-inspect.js

@@ -102,7 +102,9 @@ function runtimeTriage(ctx, deps) {
         if (!stateDir)
             return [];
         return RunsTrace.readRunTraceEvents(stateDir)
-            .filter((event) => event.attention === "notify" || event.attention === "followup")
+            .filter((event) => event.attention === "notify" ||
+            event.attention === "followup" ||
+            event.attention === "steer")
             .map((event) => ({
             run: run.run,
             id: event.id,