@fitchmultz/pi-subagents 0.49.1 → 0.51.0

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

@@ -1,237 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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,111 +0,0 @@
-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 (isUnsubscribe(previousUnsubscribe)) {
-        try {
-            previousUnsubscribe();
-        }
-        catch {
-            // Best effort cleanup for stale handlers from an older reload.
-        }
-    }
-    const handleComplete = (data) => {
-        if (!isResult(data) ||
-            data.intercomResultDelivered === true ||
-            data.suppressNotification === true) {
-            return;
-        }
-        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;
-    return unsubscribe;
-}

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

@@ -1,72 +0,0 @@
-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 (!numericParallelGroup(group)) {
-        return false;
-    }
-    const { start, count, stepIndex } = group;
-    return (start >= 0 &&
-        count >= 0 &&
-        stepIndex >= 0 &&
-        stepIndex < chainStepCount &&
-        start + count <= stepCount);
-}
-export function normalizeParallelGroups(groups, stepCount, chainStepCount) {
-    if (!Array.isArray(groups)) {
-        return [];
-    }
-    const candidates = groups;
-    const sorted = candidates
-        .filter((group) => isValidParallelGroup(group, stepCount, chainStepCount))
-        .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)) {
-            continue;
-        }
-        logicalSteps.add(group.stepIndex);
-        normalized.push(group);
-    }
-    return normalized;
-}
-export function flatToLogicalStepIndex(flatIndex, chainStepCount, groups) {
-    let logicalIndex = 0;
-    let cursor = 0;
-    for (const group of groups) {
-        while (cursor < group.start && logicalIndex < chainStepCount) {
-            if (cursor === flatIndex) {
-                return logicalIndex;
-            }
-            cursor++;
-            logicalIndex++;
-        }
-        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) {
-            return logicalIndex;
-        }
-        cursor++;
-        logicalIndex++;
-    }
-    return Math.max(0, chainStepCount - 1);
-}

package/dist/runs/background/result-payload.js

@@ -1,178 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getRunMetadataDir } from "../shared/supervisor-questions.js";
-import { journalStamp } from "../../shared/journal-reader.js";
-import { resolveOrchestratorIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { attachNestedChildrenToResultChildren, buildSubagentResultIntercomPayload, compactNestedResultChildren, deliverSubagentResultIntercomEvent, resolveSubagentResultStatus, } from "../../intercom/result-intercom.js";
-import { projectNestedRegistryForRoot, sanitizeSummary } from "../shared/nested-events.js";
-import { isDurableRun, readAsyncResultFile, } from "./async-result-file.js";
-import { hasText } from "./async-value.js";
-function canonicalResult(notification, runId, durableFile) {
-    const canonicalPath = isDurableRun(notification) && !durableFile
-        ? path.join(getRunMetadataDir(runId), "result.json")
-        : undefined;
-    if (canonicalPath === undefined) {
-        return { data: notification };
-    }
-    return {
-        canonicalPath,
-        canonicalStamp: journalStamp(fs.statSync(canonicalPath, { bigint: true })),
-        data: readAsyncResultFile(canonicalPath),
-    };
-}
-function resultCompletionId(data, runId) {
-    return data.completionId ?? `legacy:${runId}:${data.timestamp ?? "unknown"}`;
-}
-export function readResultEnvelope(file, resultsDir) {
-    const durableFile = path.isAbsolute(file);
-    const resultPath = durableFile ? file : path.join(resultsDir, file);
-    const stamp = journalStamp(fs.statSync(resultPath, { bigint: true }));
-    const notification = readAsyncResultFile(resultPath);
-    const runId = notification.runId ?? notification.id ?? path.basename(file, ".json");
-    const { canonicalPath, canonicalStamp, data } = canonicalResult(notification, runId, durableFile);
-    if ((data.runId ?? data.id ?? runId) !== runId) {
-        throw new Error(`Result identity does not match notification '${runId}'.`);
-    }
-    if (durableFile && resultPath !== path.join(getRunMetadataDir(runId), "result.json")) {
-        throw new Error(`Canonical result identity does not match path '${resultPath}'.`);
-    }
-    return {
-        resultPath,
-        durableFile,
-        runId,
-        stamp,
-        canonicalPath,
-        canonicalStamp,
-        data: {
-            ...data,
-            completionId: resultCompletionId(data, runId),
-        },
-    };
-}
-function nestedChildren(value, resultPath, label) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!Array.isArray(value)) {
-        console.error(`Ignoring invalid nested children in subagent result file '${resultPath}' at ${label}: expected an array.`);
-        return undefined;
-    }
-    const children = value
-        .map(sanitizeSummary)
-        .filter((child) => child !== undefined);
-    if (children.length !== value.length) {
-        console.error(`Ignoring ${value.length - children.length} invalid nested child record(s) in subagent result file '${resultPath}' at ${label}.`);
-    }
-    return children.length > 0 ? children : undefined;
-}
-function resultSummary(result, fallback) {
-    const output = result.output ?? result.finalOutput ?? fallback;
-    const hasOutput = typeof output === "string" && output.trim().length > 0;
-    if (result.success === false && hasText(result.error)) {
-        return `${result.error}${hasOutput ? `\n\nOutput:\n${output}` : ""}`;
-    }
-    return hasOutput ? output : "(no output)";
-}
-function childResultStatus(result, overall) {
-    return resolveSubagentResultStatus({
-        success: result.success,
-        exitCode: result.exitCode ?? undefined,
-        acceptance: result.acceptance,
-        interrupted: result.interrupted,
-        state: result.interrupted === true || typeof result.success !== "boolean" ? overall : undefined,
-    });
-}
-function normalizeChild(result, index, envelope, count) {
-    const { data, resultPath } = envelope;
-    const artifacts = result.artifactPaths ?? {};
-    const sessionPath = result.sessionFile ?? (count === 1 ? data.sessionFile : undefined);
-    const children = nestedChildren(result.children, resultPath, `results[${index}].children`);
-    return {
-        agent: result.agent ?? data.agent ?? `step-${index + 1}`,
-        status: childResultStatus(result, data.state),
-        summary: resultSummary(result, data.summary),
-        index,
-        artifactPath: artifacts.outputPath,
-        metadataPath: artifacts.metadataPath,
-        ...(typeof sessionPath === "string" && fs.existsSync(sessionPath) ? { sessionPath } : {}),
-        ...(hasText(result.intercomTarget) ? { intercomTarget: result.intercomTarget } : {}),
-        ...(children ? { children } : {}),
-    };
-}
-export function prepareResult(envelope) {
-    const { data, resultPath, runId } = envelope;
-    let nested = compactNestedResultChildren(nestedChildren(data.nestedChildren, resultPath, "nestedChildren"));
-    if ((nested?.length ?? 0) === 0 && data.nestedChildren === undefined) {
-        try {
-            nested = compactNestedResultChildren(projectNestedRegistryForRoot(runId)?.children);
-        }
-        catch (error) {
-            console.error(`Failed to enrich subagent result file '${resultPath}' with nested registry children; will retry later:`, error);
-            return undefined;
-        }
-    }
-    const persistedResults = data.results ?? [];
-    const hasResultChildren = persistedResults.length > 0;
-    const results = hasResultChildren
-        ? persistedResults
-        : [{ agent: data.agent, output: data.summary, success: data.success }];
-    const children = attachNestedChildrenToResultChildren(runId, results.map((result, index) => normalizeChild(result, index, envelope, results.length)), nested);
-    return { nestedChildren: nested, children, hasResultChildren };
-}
-export async function deliverResultIntercom(events, envelope, prepared) {
-    const { data, runId } = envelope;
-    const target = resolveOrchestratorIntercomTarget(events, data.intercomTarget?.trim() ?? "");
-    if (target.length === 0) {
-        return false;
-    }
-    const fallbackMode = prepared.children.length > 1 ? "chain" : "single";
-    const mode = data.mode ?? fallbackMode;
-    const savedPath = path.join(getRunMetadataDir(runId), "result.json");
-    const payload = buildSubagentResultIntercomPayload({
-        to: target,
-        runId,
-        completionId: data.completionId,
-        mode,
-        source: "async",
-        ...(fs.existsSync(savedPath) ? { resultPath: savedPath } : {}),
-        status: resolveSubagentResultStatus({ state: data.terminalState }),
-        error: data.workflowGraph?.nodes.find((node) => hasText(node.error))?.error,
-        children: prepared.children,
-        asyncId: data.id,
-        asyncDir: data.asyncDir,
-    });
-    return deliverSubagentResultIntercomEvent(events, payload);
-}
-export function completionEvent(envelope, prepared, key, intercomDelivered) {
-    const { data, runId } = envelope;
-    const { terminalState: _terminalState, ...eventData } = data;
-    return {
-        ...eventData,
-        agent: data.agent ?? prepared.children.map((child) => child.agent).join(", "),
-        summary: hasText(data.summary?.trim())
-            ? data.summary
-            : prepared.children.map((child) => child.summary).join("\n\n"),
-        runId,
-        completionKey: key,
-        intercomResultDelivered: intercomDelivered,
-        ...((prepared.nestedChildren?.length ?? 0) > 0
-            ? { nestedChildren: prepared.nestedChildren }
-            : {}),
-        ...(data.results === undefined
-            ? {}
-            : {
-                results: prepared.hasResultChildren
-                    ? prepared.children.map((child, index) => ({
-                        ...data.results?.[index],
-                        agent: child.agent,
-                        status: child.status,
-                        summary: child.summary,
-                        index: child.index,
-                        artifactPath: child.artifactPath,
-                        sessionPath: child.sessionPath,
-                        children: child.children,
-                    }))
-                    : [],
-            }),
-    };
-}