@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/dist/runs/background/completion-delivery.js

@@ -1,245 +1,251 @@
 import * as fs from "node:fs";
-import { RESULTS_DIR, SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.js";
-import { SessionEntryCursor } from "../../shared/session-entries.js";
-import { createParentReceiptReader } from "../shared/parent-receipts.js";
+import { RESULTS_DIR, SUBAGENT_ASYNC_COMPLETE_EVENT, } from "../../shared/types.js";
 import { finalizedChildUsage } from "../shared/parent-usage.js";
 import { ownedRunView, rememberOwnedRun, repairOwnedRunAccounting } from "../shared/run-records.js";
 import registerSubagentNotify from "./notify.js";
 import { createResultWatcher } from "./result-watcher.js";
+import { CompletionReceipts } from "./completion-receipts.js";
+import { errorMessage, hasText, isRecord, stringField } from "./async-value.js";
+function isAdmissions(value) {
+    if (!(value instanceof Map)) {
+        return false;
+    }
+    const entries = value;
+    return [...entries].every(([key, admission]) => typeof key === "string" &&
+        isRecord(admission) &&
+        (admission.sessionId === null || typeof admission.sessionId === "string") &&
+        typeof admission.pending === "boolean" &&
+        (admission.channel === "notification" || admission.channel === "intercom"));
+}
+function admissions() {
+    const store = globalThis;
+    const key = "__pi_subagents_queued_notifications__";
+    const existing = store[key];
+    const queued = isAdmissions(existing) ? existing : new Map();
+    store[key] = queued;
+    return queued;
+}
 /** Completion authority is the published parent receipt, never queue/send acceptance. */
-export function createCompletionDelivery(pi, state, parentUsage) {
-    const store = globalThis, queueKey = "__pi_subagents_queued_notifications__";
-    // Native custom queues survive extension reload, so their admission authority must too.
-    const queued = store[queueKey] instanceof Map ? store[queueKey] : new Map();
-    store[queueKey] = queued;
-    pi.on("turn_end", (event, ctx) => {
-        // ponytail: this is the next batch, not the whole queue. Retain ambiguous
-        // admissions until publication or empty queues; selective removal needs a public full-queue snapshot.
-        const pending = event.context.pendingMessages.length > 0;
-        for (const [key, admission] of queued) {
-            if (admission.channel !== "notification" || admission.sessionId !== ctx.sessionManager.getSessionId())
+class CompletionDelivery {
+    pi;
+    state;
+    parentUsage;
+    queued = admissions();
+    receipts;
+    watcher;
+    unsubscribe;
+    unsubscribeNotify;
+    constructor(pi, state, parentUsage) {
+        this.pi = pi;
+        this.state = state;
+        this.parentUsage = parentUsage;
+        this.receipts = new CompletionReceipts(state);
+        pi.on("turn_end", (event, ctx) => {
+            this.settleAdmissions(event.context.pendingMessages.length > 0, ctx);
+        });
+        this.state.isRunResultConsumed = (runId) => this.receipts.consumed(runId) !== undefined;
+        this.watcher = createResultWatcher(pi, state, RESULTS_DIR, {
+            reconcileDelivery: this.reconcileDelivery,
+            withReceiptBatch: this.receipts.batch,
+            isCompletionPublished: (runId, key) => this.receipts.publishedReceipt(runId, key) !== undefined,
+        });
+    }
+    settleAdmissions(pending, ctx) {
+        // ponytail: this is the next batch, not the whole queue. Full selective removal
+        // requires a public full-queue snapshot; ambiguous admissions remain until publication/empty queues.
+        for (const [key, admission] of this.queued) {
+            if (admission.channel !== "notification" ||
+                admission.sessionId !== ctx.sessionManager.getSessionId()) {
                 continue;
-            admission.pending = pending;
-            if (!admission.pending) {
-                queued.delete(key);
-                state.completionSeen.delete(key);
-            }
-        }
-    });
-    const publishedReceipts = createParentReceiptReader("live");
-    const indexReceipts = (saved) => {
-        const completed = new Map(), singles = new Map();
-        const completions = new Map(), legacy = new Map();
-        for (const entry of saved.values()) {
-            const details = entry.type === "message" && entry.message.role === "toolResult" ? entry.message.details
-                : entry.type === "custom_message" ? entry.details : undefined;
-            const data = details;
-            const wait = entry.type === "message" ? data?.wait : data?.result?.details?.wait;
-            if (wait?.status === "completed") {
-                const target = wait.index === undefined ? completed : wait.index === 0 ? singles : undefined;
-                if (target && !target.has(wait.runId))
-                    target.set(wait.runId, entry);
             }
-            if (entry.type !== "custom_message")
-                continue;
-            const completion = data?.completion ?? data?.subagentCompletion;
-            if (!completion?.runId)
-                continue;
-            for (const key of [completion.key, completion.completionId && `completion:${completion.completionId}`]) {
-                const identity = `${completion.runId}\0${key}`;
-                if (key && !completions.has(identity))
-                    completions.set(identity, entry);
+            admission.pending = pending;
+            if (!pending) {
+                this.queued.delete(key);
+                this.state.completionSeen.delete(key);
             }
-            if (!completion.completionId && (completion.ownerSessionId === undefined || completion.ownerSessionId === state.currentSessionId)
-                && !legacy.has(completion.runId))
-                legacy.set(completion.runId, entry);
-        }
-        return { saved, completed, singles, completions, legacy };
-    };
-    let batching = false;
-    let snapshot;
-    const readReceipts = () => {
-        const manager = state.lastUiContext?.sessionManager, file = manager?.getSessionFile();
-        const leaf = manager?.getLeafId?.(), count = manager?.getEntryCount?.();
-        if (batching && count !== undefined && snapshot && snapshot.manager === manager && snapshot.file === file && snapshot.leaf === leaf && snapshot.count === count)
-            return snapshot.index;
-        const index = indexReceipts(publishedReceipts.read(file));
-        if (batching)
-            snapshot = { manager, file, leaf, count, index };
-        return index;
-    };
-    const withReceiptBatch = (work) => {
-        // Proof is scoped to this synchronous stack, never async delivery. Every
-        // parent append changes count/leaf and forces another SHA-verified read.
-        batching = true;
-        snapshot = undefined;
-        try {
-            work();
         }
-        finally {
-            batching = false;
-            snapshot = undefined;
+    }
+    accountingProjection(children, ctx) {
+        const incomplete = children.find((child) => child.result?.accounting?.state === "incomplete");
+        if (incomplete) {
+            return { state: "incomplete", error: incomplete.result?.accounting?.error };
         }
-    };
-    const consumedReceipt = (index, runId) => index.completed.get(runId)
-        ?? (state.ownedRuns?.get(runId)?.mode === "single" ? index.singles.get(runId) : undefined);
-    const publishedReceipt = (index, runId, key) => consumedReceipt(index, runId)
-        ?? index.completions.get(`${runId}\0${key}`) ?? (key.startsWith("completion:legacy:") ? index.legacy.get(runId) : undefined);
-    const completedCursor = new SessionEntryCursor();
-    const receiptEntryIds = new Set();
-    const readParentChanges = () => {
-        const ctx = state.lastUiContext;
-        if (!ctx)
+        return {
+            state: this.parentUsage.isRecorded(finalizedChildUsage(children), ctx, this.receipts.read().saved)
+                ? "complete"
+                : "pending",
+        };
+    }
+    recordAccounting(runId) {
+        const run = this.state.ownedRuns?.get(runId);
+        const ctx = this.state.lastUiContext;
+        if (!run || !ctx) {
             return;
-        const changes = completedCursor.read(ctx.sessionManager);
-        if (changes.reset)
-            receiptEntryIds.clear();
-        for (const entry of changes.entries) {
-            if (entry.type === "message" && entry.message.role === "toolResult") {
-                if (["subagent", "delegate", "agent_runs"].includes(entry.message.toolName))
-                    receiptEntryIds.add(entry.id);
-            }
-            else if (entry.type === "custom_message" && ["subagent-notify", "intercom_message", "subagent-slash-result"].includes(entry.customType))
-                receiptEntryIds.add(entry.id);
         }
-    };
-    const consumed = (entry, runId) => {
-        const wait = entry.type === "message" ? entry.message?.details?.wait : entry.details?.result?.details?.wait;
-        const run = state.ownedRuns?.get(runId);
-        return wait?.runId === runId && wait.status === "completed" && (wait.index === undefined || run?.mode === "single" && wait.index === 0);
-    };
-    state.isRunResultConsumed = (runId) => Boolean(consumedReceipt(readReceipts(), runId));
-    const matches = (entry, runId, key) => {
-        if (consumed(entry, runId))
-            return true;
-        if (entry.type !== "custom_message")
-            return false;
-        const completion = entry.details?.completion ?? entry.details?.subagentCompletion;
-        return completion?.runId === runId && (completion.key === key || completion.completionId && `completion:${completion.completionId}` === key
-            || key.startsWith("completion:legacy:") && !completion.completionId && (completion.ownerSessionId === undefined || completion.ownerSessionId === state.currentSessionId));
-    };
-    const recordAccounting = (runId) => {
-        const run = state.ownedRuns?.get(runId), ctx = state.lastUiContext;
-        if (!run || !ctx)
-            return;
         try {
             repairOwnedRunAccounting(run);
-            const children = ownedRunView(run, state, { readConfiguration: false }).children;
-            const incomplete = children.find((child) => child.result?.accounting?.state === "incomplete");
-            const accounting = incomplete ? { state: "incomplete", error: incomplete.result?.accounting?.error }
-                : { state: parentUsage.isRecorded(finalizedChildUsage(children), ctx, readReceipts().saved) ? "complete" : "pending" };
-            rememberOwnedRun(state, { ...state.ownedRuns.get(runId), accounting });
+            const children = ownedRunView(run, this.state, { readConfiguration: false }).children;
+            const accounting = this.accountingProjection(children, ctx);
+            rememberOwnedRun(this.state, { ...(this.state.ownedRuns?.get(runId) ?? run), accounting });
         }
         catch (error) {
             try {
-                rememberOwnedRun(state, { ...state.ownedRuns.get(runId), accounting: { state: "incomplete", error: String(error) } });
+                rememberOwnedRun(this.state, {
+                    ...(this.state.ownedRuns?.get(runId) ?? run),
+                    accounting: { state: "incomplete", error: errorMessage(error) },
+                });
             }
             catch (saveError) {
                 console.error(`Could not save accounting projection for ${runId}:`, saveError);
             }
             console.error(`Subagent ${runId} accounting remains incomplete:`, error);
         }
-    };
-    const reconcileDelivery = (runId, key, accounting = true) => {
-        const run = state.ownedRuns?.get(runId);
-        const index = readReceipts(), saved = index.saved;
-        const receipt = publishedReceipt(index, runId, key);
-        if (receipt) {
-            queued.delete(key);
-            state.completionSeen.delete(key);
-            // Save delivery before optional accounting. Even a failed owner append cannot
-            // make this published identity eligible for another notification.
-            try {
-                if (run)
-                    rememberOwnedRun(state, { ...run, completion: { id: key, state: "journaled", entryId: receipt.id },
-                        delivery: { notifiedAt: Date.parse(receipt.timestamp), intercomDelivered: receipt.type === "custom_message" && receipt.customType === "intercom_message", completionId: key, entryId: receipt.id } });
-            }
-            catch (error) {
-                console.error(`Could not save delivery projection for ${runId}:`, error);
+    }
+    recordPublished(runId, key, receipt, accounting) {
+        this.queued.delete(key);
+        this.state.completionSeen.delete(key);
+        // Save delivery before accounting. Failed owner append cannot make a published identity eligible again.
+        try {
+            const run = this.state.ownedRuns?.get(runId);
+            if (run) {
+                const publishedAt = receipt.timestamp === undefined ? undefined : Date.parse(receipt.timestamp);
+                rememberOwnedRun(this.state, {
+                    ...run,
+                    completion: { id: key, state: "journaled", entryId: receipt.id },
+                    delivery: {
+                        // Legacy receipts without a valid timestamp use the publication observation time.
+                        notifiedAt: publishedAt !== undefined && Number.isFinite(publishedAt) ? publishedAt : Date.now(),
+                        intercomDelivered: receipt.type === "custom_message" && receipt.customType === "intercom_message",
+                        completionId: key,
+                        entryId: receipt.id,
+                    },
+                });
             }
-            if (accounting)
-                recordAccounting(runId);
-            return true;
         }
-        const ctx = state.lastUiContext;
-        if (!ctx)
+        catch (error) {
+            console.error(`Could not save delivery projection for ${runId}:`, error);
+        }
+        if (accounting) {
+            this.recordAccounting(runId);
+        }
+    }
+    hasAdmission(runId, key) {
+        const completion = this.state.ownedRuns?.get(runId)?.completion;
+        return this.queued.has(key) || (completion?.id === key && completion.state === "queued");
+    }
+    pendingQueue(ctx, key) {
+        return (!ctx || this.queued.get(key)?.pending === true || !ctx.isIdle() || ctx.hasPendingMessages());
+    }
+    queuedDelivery(runId, key) {
+        const ctx = this.state.lastUiContext;
+        const run = this.state.ownedRuns?.get(runId);
+        if (!this.hasAdmission(runId, key)) {
+            return false;
+        }
+        // The durable Intercom inbox owns restart reconciliation; remote acknowledgement exposes no parent commit boundary.
+        if (run?.completion?.channel === "intercom") {
             return true;
-        // An accepted but unflushed receipt or a native pending queue is ambiguous:
-        // keep pending rather than enqueueing a second copy. Official hosts expose
-        // queue occupancy, not individual queue contents.
-        readParentChanges();
-        if ([...receiptEntryIds].some((id) => {
-            if (saved.has(id))
-                return false; // Published candidates were checked above.
-            const entry = ctx.sessionManager.getEntry(id);
-            return entry !== undefined && matches(entry, runId, key);
-        })) {
-            queued.delete(key);
-            state.completionSeen.delete(key);
+        }
+        if (this.pendingQueue(ctx, key)) {
             return true;
         }
-        if (queued.has(key) || run?.completion?.id === key && run.completion.state === "queued") {
-            // The durable Intercom inbox owns its own queue/restart reconciliation.
-            // A remote acknowledgement exposes no parent commit/queue boundary.
-            if (run?.completion?.channel === "intercom")
-                return true;
-            // Settlement after abort need not drain the custom queue. Its actual
-            // turn boundary remains authoritative when coarse occupancy says idle.
-            if (queued.get(key)?.pending || !ctx.isIdle() || ctx.hasPendingMessages())
-                return true;
-            queued.delete(key);
-            state.completionSeen.delete(key);
-            if (run)
-                rememberOwnedRun(state, { ...run, completion: { id: key, state: "dropped" } });
+        this.queued.delete(key);
+        this.state.completionSeen.delete(key);
+        if (run) {
+            rememberOwnedRun(this.state, { ...run, completion: { id: key, state: "dropped" } });
         }
         return false;
+    }
+    reconcileDelivery = (runId, key, accounting = true) => {
+        const index = this.receipts.read();
+        const receipt = this.receipts.publishedReceipt(runId, key, index);
+        if (receipt) {
+            this.recordPublished(runId, key, receipt, accounting);
+            return true;
+        }
+        if (!this.state.lastUiContext) {
+            return true;
+        }
+        // Accepted-but-unflushed receipts and native pending queues are ambiguous, not duplicate admissions.
+        if (this.receipts.hasUnpublished(runId, key, index.saved)) {
+            this.queued.delete(key);
+            this.state.completionSeen.delete(key);
+            return true;
+        }
+        return this.queuedDelivery(runId, key);
     };
-    const watcher = createResultWatcher(pi, state, RESULTS_DIR, { reconcileDelivery, withReceiptBatch,
-        isCompletionPublished: (runId, key) => Boolean(publishedReceipt(readReceipts(), runId, key)) });
-    let unsubscribe, unsubscribeNotify;
-    const markQueued = (runId, key, channel = "notification") => {
-        const run = state.ownedRuns?.get(runId);
-        queued.set(key, { sessionId: state.currentSessionId, pending: false, channel });
-        if (run)
-            rememberOwnedRun(state, { ...run, completion: { id: key, state: "queued", channel, queuedAt: Date.now() } });
-    };
-    const start = () => {
-        if (!unsubscribe) {
-            unsubscribeNotify = registerSubagentNotify(pi, (key, runId) => { if (runId)
-                markQueued(runId, key); });
-            unsubscribe = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, (data) => {
-                const result = data;
-                const run = state.ownedRuns?.get(result.runId ?? result.id ?? "");
-                if (!run || result.sessionId !== state.currentSessionId && run.ownerSessionId !== state.currentSessionId)
-                    return;
-                if (result.completionKey) {
-                    if (result.intercomResultDelivered)
-                        markQueued(run.runId, result.completionKey, "intercom");
-                    reconcileDelivery(run.runId, result.completionKey);
+    markQueued(runId, key, channel = "notification") {
+        this.queued.set(key, { sessionId: this.state.currentSessionId, pending: false, channel });
+        const run = this.state.ownedRuns?.get(runId);
+        if (run) {
+            rememberOwnedRun(this.state, {
+                ...run,
+                completion: { id: key, state: "queued", channel, queuedAt: Date.now() },
+            });
+        }
+    }
+    completionRun(data) {
+        const runId = stringField(data, "runId") ?? stringField(data, "id") ?? "";
+        const run = this.state.ownedRuns?.get(runId);
+        if (!run ||
+            (data.sessionId !== this.state.currentSessionId &&
+                run.ownerSessionId !== this.state.currentSessionId)) {
+            return undefined;
+        }
+        return run;
+    }
+    completed(data) {
+        if (!isRecord(data)) {
+            return;
+        }
+        const run = this.completionRun(data);
+        if (!run) {
+            return;
+        }
+        if (typeof data.completionKey === "string" && data.completionKey.length > 0) {
+            if (data.intercomResultDelivered === true) {
+                this.markQueued(run.runId, data.completionKey, "intercom");
+            }
+            this.reconcileDelivery(run.runId, data.completionKey);
+        }
+        if (data.suppressNotification === true) {
+            this.recordAccounting(run.runId);
+        }
+    }
+    start = () => {
+        if (!this.unsubscribe) {
+            this.unsubscribeNotify = registerSubagentNotify(this.pi, (key, runId) => {
+                if (hasText(runId)) {
+                    this.markQueued(runId, key);
                 }
-                if (result.suppressNotification)
-                    recordAccounting(run.runId);
+            });
+            this.unsubscribe = this.pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, (data) => {
+                this.completed(data);
             });
         }
         fs.mkdirSync(RESULTS_DIR, { recursive: true });
-        watcher.startResultWatcher();
-        watcher.primeExistingResults();
+        this.watcher.startResultWatcher();
+        this.watcher.primeExistingResults();
     };
-    const stopListening = () => {
-        unsubscribe?.();
-        unsubscribe = undefined;
-        unsubscribeNotify?.();
-        unsubscribeNotify = undefined;
-        publishedReceipts.clear();
-        completedCursor.reset();
-        receiptEntryIds.clear();
+    stopListening() {
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        this.unsubscribeNotify?.();
+        this.unsubscribeNotify = undefined;
+        this.receipts.clear();
+    }
+    stop = () => {
+        this.watcher.stopResultWatcher();
+        this.stopListening();
     };
-    const stop = () => { watcher.stopResultWatcher(); stopListening(); };
-    const stopAndJoin = async (options = {}) => {
-        // Finish accepted delivery while the old owner and its listeners are valid.
-        watcher.stopResultWatcher({ ...options, joinInFlight: true });
-        await watcher.joinInFlight();
-        stopListening();
+    stopAndJoin = async (options = {}) => {
+        // Accepted deliveries settle while the old owner and listeners remain valid.
+        this.watcher.stopResultWatcher({ ...options, joinInFlight: true });
+        await this.watcher.joinInFlight();
+        this.stopListening();
     };
-    return { start, stop, stopAndJoin };
+}
+export function createCompletionDelivery(pi, state, parentUsage) {
+    const delivery = new CompletionDelivery(pi, state, parentUsage);
+    return { start: delivery.start, stop: delivery.stop, stopAndJoin: delivery.stopAndJoin };
 }