@fitchmultz/pi-subagents 0.44.7 → 0.46.0

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

@@ -0,0 +1,237 @@
+import { SessionEntryCursor } from "../../shared/session-entries.js";
+import { createParentReceiptReader } from "../shared/parent-receipts.js";
+import { hasText, isRecord, stringField } from "./async-value.js";
+function entryDetails(entry) {
+    return entry.type === "message" ? entry.message.details : entry.details;
+}
+function waitIdentity(value) {
+    if (!isRecord(value) ||
+        value.status !== "completed" ||
+        typeof value.runId !== "string" ||
+        (value.index !== undefined && typeof value.index !== "number")) {
+        return undefined;
+    }
+    return { runId: value.runId, index: value.index };
+}
+function completionIdentity(value) {
+    if (!isRecord(value) || typeof value.runId !== "string") {
+        return undefined;
+    }
+    if (!["key", "completionId", "ownerSessionId"].every((key) => value[key] === undefined || typeof value[key] === "string")) {
+        return undefined;
+    }
+    return {
+        runId: value.runId,
+        key: stringField(value, "key"),
+        completionId: stringField(value, "completionId"),
+        ownerSessionId: stringField(value, "ownerSessionId"),
+    };
+}
+function identity(entry) {
+    const details = entryDetails(entry);
+    if (!isRecord(details)) {
+        return {};
+    }
+    let wait;
+    if (entry.type === "message") {
+        wait = details.wait;
+    }
+    else if (isRecord(details.result) && isRecord(details.result.details)) {
+        wait = details.result.details.wait;
+    }
+    return {
+        wait: waitIdentity(wait),
+        completion: completionIdentity(details.completion ?? details.subagentCompletion),
+    };
+}
+function legacyOwner(completion, ownerSessionId) {
+    return (!hasText(completion.completionId) &&
+        (completion.ownerSessionId === undefined || completion.ownerSessionId === ownerSessionId));
+}
+class ReceiptIndexBuilder {
+    completed = new Map();
+    singles = new Map();
+    completions = new Map();
+    legacy = new Map();
+    addWait(wait, entry) {
+        let target;
+        if (wait.index === undefined) {
+            target = this.completed;
+        }
+        if (wait.index === 0) {
+            target = this.singles;
+        }
+        if (target && !target.has(wait.runId)) {
+            target.set(wait.runId, entry);
+        }
+    }
+    addCompletion(completion, entry, ownerSessionId) {
+        const keys = [
+            completion.key,
+            hasText(completion.completionId) ? `completion:${completion.completionId}` : undefined,
+        ];
+        for (const key of keys) {
+            if (hasText(key) && !this.completions.has(`${completion.runId}\0${key}`)) {
+                this.completions.set(`${completion.runId}\0${key}`, entry);
+            }
+        }
+        if (legacyOwner(completion, ownerSessionId) && !this.legacy.has(completion.runId)) {
+            this.legacy.set(completion.runId, entry);
+        }
+    }
+    add(entry, ownerSessionId) {
+        const data = identity(entry);
+        if (data.wait) {
+            this.addWait(data.wait, entry);
+        }
+        if (entry.type === "custom_message" && data.completion && data.completion.runId.length > 0) {
+            this.addCompletion(data.completion, entry, ownerSessionId);
+        }
+    }
+    snapshot(saved) {
+        return {
+            saved,
+            completed: this.completed,
+            singles: this.singles,
+            completions: this.completions,
+            legacy: this.legacy,
+        };
+    }
+}
+function indexReceipts(saved, ownerSessionId) {
+    const builder = new ReceiptIndexBuilder();
+    for (const entry of saved.values()) {
+        builder.add(entry, ownerSessionId);
+    }
+    return builder.snapshot(saved);
+}
+function snapshotKey(manager) {
+    const withCount = manager;
+    return {
+        manager,
+        file: manager?.getSessionFile(),
+        leaf: manager?.getLeafId(),
+        count: withCount?.getEntryCount?.(),
+    };
+}
+function sameSnapshot(saved, current) {
+    return (current.count !== undefined &&
+        saved.manager === current.manager &&
+        saved.file === current.file &&
+        saved.leaf === current.leaf &&
+        saved.count === current.count);
+}
+/** Publication proof and in-memory candidate tracking are scoped to one parent session. */
+export class CompletionReceipts {
+    state;
+    published = createParentReceiptReader("live");
+    completedCursor = new SessionEntryCursor();
+    entryIds = new Set();
+    batching = false;
+    snapshot;
+    constructor(state) {
+        this.state = state;
+    }
+    read() {
+        const current = snapshotKey(this.state.lastUiContext?.sessionManager);
+        if (this.batching && this.snapshot && sameSnapshot(this.snapshot, current)) {
+            return this.snapshot.index;
+        }
+        const index = indexReceipts(this.published.read(current.file), this.state.currentSessionId);
+        if (this.batching) {
+            this.snapshot = { ...current, index };
+        }
+        return index;
+    }
+    batch = (work) => {
+        // Only this synchronous stack shares proof. Parent count/leaf changes invalidate it.
+        this.batching = true;
+        this.snapshot = undefined;
+        try {
+            work();
+        }
+        finally {
+            this.batching = false;
+            this.snapshot = undefined;
+        }
+    };
+    consumed(runId, index = this.read()) {
+        return (index.completed.get(runId) ??
+            (this.state.ownedRuns?.get(runId)?.mode === "single" ? index.singles.get(runId) : undefined));
+    }
+    publishedReceipt(runId, key, index = this.read()) {
+        return (this.consumed(runId, index) ??
+            index.completions.get(`${runId}\0${key}`) ??
+            (key.startsWith("completion:legacy:") ? index.legacy.get(runId) : undefined));
+    }
+    consumedIdentity(wait, runId) {
+        return (wait?.runId === runId &&
+            (wait.index === undefined ||
+                (this.state.ownedRuns?.get(runId)?.mode === "single" && wait.index === 0)));
+    }
+    completionMatches(completion, key) {
+        return (completion.key === key ||
+            (hasText(completion.completionId) && `completion:${completion.completionId}` === key) ||
+            (key.startsWith("completion:legacy:") && legacyOwner(completion, this.state.currentSessionId)));
+    }
+    matches(entry, runId, key) {
+        let receipt;
+        if (entry.type === "custom_message") {
+            receipt = entry;
+        }
+        else if (entry.type === "message" && entry.message.role === "toolResult") {
+            receipt = { type: "message", id: entry.id, message: entry.message };
+        }
+        else {
+            return false;
+        }
+        const data = identity(receipt);
+        if (this.consumedIdentity(data.wait, runId)) {
+            return true;
+        }
+        if (entry.type !== "custom_message" || data.completion?.runId !== runId) {
+            return false;
+        }
+        return this.completionMatches(data.completion, key);
+    }
+    readParentChanges() {
+        const ctx = this.state.lastUiContext;
+        if (!ctx) {
+            return;
+        }
+        const changes = this.completedCursor.read(ctx.sessionManager);
+        if (changes.reset) {
+            this.entryIds.clear();
+        }
+        for (const entry of changes.entries) {
+            if (entry.type === "message" && entry.message.role === "toolResult") {
+                if (["subagent", "delegate", "agent_runs"].includes(entry.message.toolName)) {
+                    this.entryIds.add(entry.id);
+                }
+            }
+            else if (entry.type === "custom_message" &&
+                ["subagent-notify", "intercom_message", "subagent-slash-result"].includes(entry.customType)) {
+                this.entryIds.add(entry.id);
+            }
+        }
+    }
+    hasUnpublished(runId, key, saved) {
+        const ctx = this.state.lastUiContext;
+        if (!ctx) {
+            return false;
+        }
+        this.readParentChanges();
+        return [...this.entryIds].some((id) => {
+            if (saved.has(id)) {
+                return false;
+            }
+            const entry = ctx.sessionManager.getEntry(id);
+            return entry !== undefined && this.matches(entry, runId, key);
+        });
+    }
+    clear() {
+        this.published.clear();
+        this.completedCursor.reset();
+        this.entryIds.clear();
+    }
+}

package/dist/runs/background/legacy-status-acceptance.js

@@ -0,0 +1,34 @@
+import { isRecord, isUnknownArray } from "../../shared/unknown.js";
+import { DEFAULT_FINALIZATION_MAX_TURNS } from "../shared/acceptance-defaults.js";
+function normalizeLegacyStep(value) {
+    if (!isRecord(value) || !isRecord(value.acceptance)) {
+        return value;
+    }
+    const acceptance = value.acceptance;
+    const effective = acceptance.effectiveAcceptance;
+    if (!isRecord(effective) ||
+        effective.explicit !== true ||
+        Object.hasOwn(effective, "finalization")) {
+        return value;
+    }
+    return {
+        ...value,
+        acceptance: {
+            ...acceptance,
+            effectiveAcceptance: {
+                ...effective,
+                finalization: {
+                    mode: "self-review-loop",
+                    maxTurns: DEFAULT_FINALIZATION_MAX_TURNS,
+                },
+            },
+        },
+    };
+}
+/** Restore the pre-v2 finalization default without repairing any other contract fields. */
+export function normalizeLegacyStatusAcceptance(value) {
+    if (!isRecord(value) || value.runtimeVersion !== undefined || !isUnknownArray(value.steps)) {
+        return value;
+    }
+    return { ...value, steps: value.steps.map(normalizeLegacyStep) };
+}

package/dist/runs/background/notify.js

@@ -1,13 +1,93 @@
-/**
- * Subagent completion notifications.
- */
 import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.js";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.js";
+import { hasText, isRecord } from "./async-value.js";
+function isResult(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const strings = [
+        "runId",
+        "completionId",
+        "completionKey",
+        "summary",
+        "state",
+        "sessionFile",
+        "shareUrl",
+        "shareError",
+    ];
+    const numbers = ["exitCode", "timestamp", "durationMs", "taskIndex", "totalTasks"];
+    return (strings.every((key) => value[key] === undefined || typeof value[key] === "string") &&
+        numbers.every((key) => value[key] === undefined || typeof value[key] === "number") &&
+        ["id", "agent"].every((key) => value[key] === undefined || value[key] === null || typeof value[key] === "string") &&
+        ["success", "intercomResultDelivered", "suppressNotification"].every((key) => value[key] === undefined || typeof value[key] === "boolean"));
+}
+function notificationStatus(result, summary) {
+    if (result.state === "blocked") {
+        return "blocked";
+    }
+    if (result.success !== true &&
+        (result.exitCode === 0 ||
+            result.state === "paused" ||
+            summary.startsWith("Paused after interrupt."))) {
+        return "paused";
+    }
+    return result.success === true ? "completed" : "failed";
+}
+function sessionLine(result) {
+    if (hasText(result.shareUrl)) {
+        return `Session: ${result.shareUrl}`;
+    }
+    if (hasText(result.shareError)) {
+        return `Session share error: ${result.shareError}`;
+    }
+    return hasText(result.sessionFile) ? `Session file: ${result.sessionFile}` : undefined;
+}
+function taskLabel(result) {
+    return result.taskIndex !== undefined && result.totalTasks !== undefined
+        ? ` (${result.taskIndex + 1}/${result.totalTasks})`
+        : "";
+}
+function buildNotification(result) {
+    const agent = result.agent ?? "unknown";
+    const summary = result.summary ?? "";
+    const status = notificationStatus(result, summary);
+    const taskInfo = taskLabel(result);
+    const session = sessionLine(result);
+    const displaySummary = summary.trim().length > 0 ? summary : "(no output)";
+    const content = [
+        `Background task ${status}: **${agent}**${taskInfo}`,
+        "",
+        displaySummary,
+        hasText(session) ? "" : undefined,
+        session,
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n");
+    const details = hasText(result.runId) && hasText(result.completionKey)
+        ? {
+            agent,
+            status,
+            taskInfo: taskInfo.trim(),
+            resultPreview: displaySummary.trim(),
+            ...(hasText(session)
+                ? {
+                    sessionLabel: session.slice(0, session.indexOf(":")).toLowerCase(),
+                    sessionValue: session.slice(session.indexOf(":") + 1).trim(),
+                }
+                : {}),
+            completion: { runId: result.runId, key: result.completionKey },
+        }
+        : undefined;
+    return { customType: "subagent-notify", content, display: true, ...(details ? { details } : {}) };
+}
+function isUnsubscribe(value) {
+    return typeof value === "function";
+}
 export default function registerSubagentNotify(pi, onQueued) {
     const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
     const globalStore = globalThis;
     const previousUnsubscribe = globalStore[unsubscribeStoreKey];
-    if (typeof previousUnsubscribe === "function") {
+    if (isUnsubscribe(previousUnsubscribe)) {
         try {
             previousUnsubscribe();
         }
@@ -16,54 +96,22 @@ export default function registerSubagentNotify(pi, onQueued) {
         }
     }
     const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
-    const ttlMs = 10 * 60 * 1000;
     const handleComplete = (data) => {
-        const result = data;
-        if (result.intercomResultDelivered === true || result.suppressNotification === true)
+        if (!isResult(data) ||
+            data.intercomResultDelivered === true ||
+            data.suppressNotification === true) {
             return;
-        const now = Date.now();
-        const key = buildCompletionKey(result, "notify");
+        }
+        const key = buildCompletionKey(data, "notify");
         // Owned completion keys are governed by the shared queue/journal lifecycle, not a TTL.
-        if ((!onQueued || !result.completionKey) && markSeenWithTtl(seen, key, now, ttlMs))
+        if ((onQueued === undefined || !hasText(data.completionKey)) &&
+            markSeenWithTtl(seen, key, Date.now(), 10 * 60 * 1000)) {
             return;
-        const agent = result.agent ?? "unknown";
-        const summary = typeof result.summary === "string" ? result.summary : "";
-        const paused = !result.success && (result.exitCode === 0
-            || result.state === "paused"
-            || summary.startsWith("Paused after interrupt."));
-        const status = result.state === "blocked" ? "blocked" : paused ? "paused" : result.success ? "completed" : "failed";
-        const taskInfo = result.taskIndex !== undefined && result.totalTasks !== undefined
-            ? ` (${result.taskIndex + 1}/${result.totalTasks})`
-            : "";
-        const sessionLine = result.shareUrl
-            ? `Session: ${result.shareUrl}`
-            : result.shareError
-                ? `Session share error: ${result.shareError}`
-                : result.sessionFile
-                    ? `Session file: ${result.sessionFile}`
-                    : undefined;
-        const displaySummary = summary.trim() ? summary : "(no output)";
-        const content = [
-            `Background task ${status}: **${agent}**${taskInfo}`,
-            "",
-            displaySummary,
-            sessionLine ? "" : undefined,
-            sessionLine,
-        ]
-            .filter((line) => line !== undefined)
-            .join("\n");
-        pi.sendMessage({
-            customType: "subagent-notify",
-            content,
-            display: true,
-            ...(result.runId && result.completionKey ? { details: {
-                    agent, status, taskInfo: taskInfo.trim(), resultPreview: displaySummary.trim(),
-                    ...(sessionLine ? { sessionLabel: sessionLine.slice(0, sessionLine.indexOf(":")).toLowerCase(), sessionValue: sessionLine.slice(sessionLine.indexOf(":") + 1).trim() } : {}),
-                    completion: { runId: result.runId, key: result.completionKey },
-                } } : {}),
-        }, { triggerTurn: true });
-        if (result.completionKey)
-            onQueued?.(result.completionKey, result.runId);
+        }
+        pi.sendMessage(buildNotification(data), { triggerTurn: true });
+        if (hasText(data.completionKey)) {
+            onQueued?.(data.completionKey, data.runId);
+        }
     };
     const unsubscribe = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
     globalStore[unsubscribeStoreKey] = unsubscribe;

package/dist/runs/background/parallel-groups.js

@@ -1,30 +1,44 @@
+function numericParallelGroup(group) {
+    if (typeof group !== "object" ||
+        group === null ||
+        !("start" in group && "count" in group && "stepIndex" in group)) {
+        return false;
+    }
+    return (typeof group.start === "number" &&
+        typeof group.count === "number" &&
+        typeof group.stepIndex === "number" &&
+        [group.start, group.count, group.stepIndex].every(Number.isInteger));
+}
 function isValidParallelGroup(group, stepCount, chainStepCount) {
-    if (typeof group !== "object" || group === null)
+    if (!numericParallelGroup(group)) {
         return false;
+    }
     const { start, count, stepIndex } = group;
-    return typeof start === "number"
-        && typeof count === "number"
-        && typeof stepIndex === "number"
-        && Number.isInteger(start)
-        && Number.isInteger(count)
-        && Number.isInteger(stepIndex)
-        && start >= 0
-        && count >= 0
-        && stepIndex >= 0
-        && stepIndex < chainStepCount
-        && start + count <= stepCount;
+    return (start >= 0 &&
+        count >= 0 &&
+        stepIndex >= 0 &&
+        stepIndex < chainStepCount &&
+        start + count <= stepCount);
 }
 export function normalizeParallelGroups(groups, stepCount, chainStepCount) {
-    if (!Array.isArray(groups))
+    if (!Array.isArray(groups)) {
         return [];
-    const sorted = groups
+    }
+    const candidates = groups;
+    const sorted = candidates
         .filter((group) => isValidParallelGroup(group, stepCount, chainStepCount))
-        .sort((left, right) => left.stepIndex - right.stepIndex || left.start - right.start);
+        .sort((left, right) => {
+        const logical = left.stepIndex - right.stepIndex;
+        return logical === 0 ? left.start - right.start : logical;
+    });
     const normalized = [];
     const logicalSteps = new Set();
     for (const group of sorted) {
-        if (logicalSteps.has(group.stepIndex) || normalized.some((existing) => group.start < existing.start + existing.count && existing.start < group.start + group.count))
+        if (logicalSteps.has(group.stepIndex) ||
+            normalized.some((existing) => group.start < existing.start + existing.count &&
+                existing.start < group.start + group.count)) {
             continue;
+        }
         logicalSteps.add(group.stepIndex);
         normalized.push(group);
     }
@@ -35,19 +49,22 @@ export function flatToLogicalStepIndex(flatIndex, chainStepCount, groups) {
     let cursor = 0;
     for (const group of groups) {
         while (cursor < group.start && logicalIndex < chainStepCount) {
-            if (cursor === flatIndex)
+            if (cursor === flatIndex) {
                 return logicalIndex;
+            }
             cursor++;
             logicalIndex++;
         }
-        if (flatIndex >= group.start && flatIndex < group.start + group.count)
+        if (flatIndex >= group.start && flatIndex < group.start + group.count) {
             return group.stepIndex;
+        }
         cursor = group.start + group.count;
         logicalIndex = group.stepIndex + 1;
     }
     while (cursor <= flatIndex && logicalIndex < chainStepCount) {
-        if (cursor === flatIndex)
+        if (cursor === flatIndex) {
             return logicalIndex;
+        }
         cursor++;
         logicalIndex++;
     }