@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/runs/shared/owned-child-evidence.js

@@ -1,125 +0,0 @@
-import * as fs from "node:fs";
-import { resolveSubagentResultStatus } from "../../intercom/result-intercom.js";
-import { sumAttemptUsage } from "./model-fallback.js";
-const RUN_STATES = {
-    running: "live",
-    queued: "live",
-    complete: "completed",
-    completed: "completed",
-    failed: "failed",
-    "timed-out": "failed",
-    blocked: "blocked",
-    paused: "paused",
-};
-export function normalizedState(value) {
-    return value === undefined ? "unknown" : (RUN_STATES[value] ?? "unknown");
-}
-function asyncChildState(bg, terminalState) {
-    const unresolved = typeof bg.success !== "boolean" && (bg.exitCode === null || bg.exitCode === undefined);
-    return normalizedState(resolveSubagentResultStatus({
-        success: bg.success,
-        exitCode: bg.exitCode ?? undefined,
-        interrupted: bg.interrupted,
-        acceptance: bg.acceptance,
-        state: unresolved ? terminalState : undefined,
-    }));
-}
-function asyncChildResult(child, task) {
-    const { output, ...result } = child;
-    return {
-        ...result,
-        agent: child.agent ?? "unknown",
-        task: child.task ?? task ?? "Original child assignment unavailable",
-        exitCode: child.exitCode ?? (child.success === true ? 0 : 1),
-        finalOutput: child.finalOutput ?? output,
-        usage: child.usage ?? sumAttemptUsage(child.modelAttempts ?? []),
-    };
-}
-function childState(evidence) {
-    const { bg, fg, contract, step } = evidence;
-    if (bg) {
-        return asyncChildState(bg, evidence.terminalState);
-    }
-    if (fg && fg.status !== "detached") {
-        return normalizedState(fg.status);
-    }
-    if (contract?.result) {
-        return normalizedState(resolveSubagentResultStatus(contract.result));
-    }
-    if (evidence.live || evidence.pending) {
-        return "live";
-    }
-    return step && !["running", "pending"].includes(step.status)
-        ? normalizedState(step.status)
-        : "unknown";
-}
-function childResult(evidence, task) {
-    if (evidence.fg?.status !== "detached" && evidence.fg?.result) {
-        return evidence.fg.result;
-    }
-    const child = evidence.bg;
-    if (!child) {
-        return evidence.contract?.result ?? evidence.fg?.result;
-    }
-    return asyncChildResult(child, task);
-}
-function childLabel(evidence) {
-    return [evidence.contract?.label, evidence.step?.label, evidence.declared?.label].find((label) => label !== undefined);
-}
-function childAgent(evidence) {
-    return ([
-        evidence.fg?.agent,
-        evidence.bg?.agent,
-        evidence.step?.agent,
-        evidence.contract?.launch?.agent.name,
-        evidence.declared?.agent,
-    ].find((agent) => agent !== undefined) ?? "unknown");
-}
-function childTask(evidence, run) {
-    return [
-        evidence.contract?.task,
-        evidence.declared?.task,
-        evidence.fg?.result?.task,
-        run.children.length === 1 ? run.task : undefined,
-    ].find((task) => task !== undefined);
-}
-function childSelection(evidence) {
-    const selection = evidence.contract?.modelSelection ?? evidence.step ?? evidence.fg?.result?.progress;
-    return selection
-        ? {
-            model: selection.model,
-            thinking: selection.thinking,
-            modelStartedAt: selection.modelStartedAt,
-        }
-        : undefined;
-}
-function childActivity(evidence, state) {
-    if (state !== "live") {
-        return;
-    }
-    return evidence.pending ? { ...evidence.step, status: "pending" } : evidence.step;
-}
-function missingSession(session) {
-    return session !== undefined && session !== "" && !fs.existsSync(session);
-}
-export function projectOwnedChild(run, index, evidence, identityUnavailable) {
-    const { contract, declared, sessionFile } = evidence;
-    const state = childState(evidence);
-    const task = childTask(evidence, run);
-    return {
-        agent: childAgent(evidence),
-        index,
-        workflowNodeId: declared?.workflowNodeId,
-        sessionFile,
-        task,
-        label: childLabel(evidence),
-        ...(identityUnavailable ? { identityUnavailable: true } : {}),
-        modelSelection: childSelection(evidence),
-        activity: childActivity(evidence, state),
-        state,
-        result: childResult(evidence, task),
-        launch: contract?.launch,
-        configuration: contract?.launch ? "saved" : "legacy-partial",
-        ...(missingSession(sessionFile) ? { missingSession: true } : {}),
-    };
-}

package/dist/runs/shared/owned-run-list.js

@@ -1,146 +0,0 @@
-import { runHistoryIndex } from "./history-index.js";
-import { getSingleResultOutput } from "../../shared/utils.js";
-import { errorMessage } from "../../shared/unknown.js";
-import { ownedRunView } from "./owned-run-view.js";
-import { compact, ownedRunControl } from "./owned-run-status.js";
-function unavailableRunView(run, error) {
-    return {
-        ...run,
-        state: "unknown",
-        updatedAt: run.startedAt,
-        attention: ["unknown"],
-        canInterrupt: false,
-        continuations: [],
-        children: run.children.map((child) => ({
-            ...child,
-            state: "unknown",
-            configuration: "legacy-partial",
-        })),
-        diagnosis: `Saved owner records unavailable: ${errorMessage(error)}. Completion is unconfirmed.`,
-    };
-}
-function selectedPage(state, indexed) {
-    // The index orders observations; only this bounded selected page gets authoritative controls.
-    return indexed.rows.map((row) => {
-        const run = state.ownedRuns?.get(row.runId);
-        if (!run || run.ownerSessionId !== row.ownerSessionId) {
-            throw new Error("Owning session changed while listing runs.");
-        }
-        try {
-            return ownedRunView(run, state, { includeContinuations: false, readConfiguration: false });
-        }
-        catch (error) {
-            return unavailableRunView(run, error);
-        }
-    });
-}
-function runSummary(view, owned) {
-    const { runId, source, mode, cwd, task, state, updatedAt, attention, review, rootRunId, predecessorRunId, predecessorIndex, } = view;
-    const outputs = view.children.map((child) => {
-        if (!child.result) {
-            return "";
-        }
-        const output = getSingleResultOutput(child.result);
-        return output !== "" ? output : (child.result.error ?? "");
-    });
-    return {
-        runId,
-        source,
-        mode,
-        cwd,
-        task: compact(task, 2048),
-        state,
-        updatedAt,
-        attention,
-        review,
-        rootRunId,
-        predecessorRunId,
-        predecessorIndex,
-        continuations: owned
-            .filter((candidate) => candidate.predecessorRunId === runId)
-            .map((candidate) => candidate.runId),
-        summary: compact(outputs.filter((output) => output !== "").join(" | ")),
-    };
-}
-function continuationDescription(run) {
-    const continuations = run.continuations ?? [];
-    return continuations.length > 0
-        ? [`continued as ${continuations.join(", ")} (separate results/reviews)`]
-        : [];
-}
-function runLine(run) {
-    return [
-        `- ${run.runId} | ${run.state}`,
-        ...(run.attention.length > 0 ? [run.attention.join(", ")] : []),
-        compact(run.task),
-        ...((run.summary ?? "") !== "" ? [run.summary ?? ""] : []),
-        `Launch cwd: ${run.cwd}`,
-        ...((run.predecessorRunId ?? "") !== ""
-            ? [`from ${run.predecessorRunId ?? ""}:${run.predecessorIndex ?? 0}`]
-            : []),
-        ...continuationDescription(run),
-    ].join(" | ");
-}
-function nextPage(indexed, params) {
-    if (indexed.nextCursor === undefined || indexed.nextCursor === "") {
-        return [];
-    }
-    const next = {
-        action: "list",
-        cursor: indexed.nextCursor,
-        limit: params.limit ?? 20,
-        ...(params.sort !== undefined ? { sort: params.sort } : {}),
-        ...((params.agent ?? "") !== "" ? { agent: params.agent } : {}),
-        ...(params.state !== undefined ? { state: params.state } : {}),
-        ...((params.text ?? "") !== "" ? { text: params.text } : {}),
-    };
-    return [`Next: agent_runs(${JSON.stringify(next)})`];
-}
-function listDescription(indexed, runs, params) {
-    if (indexed.total === 0) {
-        return "No delegated runs match in this owning session.";
-    }
-    const range = runs.length > 0 ? `${indexed.offset + 1}–${indexed.offset + runs.length}` : "none";
-    return [
-        `Owned runs: ${indexed.total} (showing ${range}; ${params.sort ?? "attention"} order)`,
-        ...(indexed.freshness.state !== "current"
-            ? [
-                `Browse index: ${indexed.freshness.state}; ordering/filter observations may be incomplete. Selected controls are checked against owner records.`,
-            ]
-            : []),
-        ...runs.map(runLine),
-        ...nextPage(indexed, params),
-    ].join("\n");
-}
-export async function ownedRunList(state, params) {
-    const sort = params.sort;
-    if (sort === "relevance") {
-        throw new Error("Run list sort must be attention, newest, or oldest.");
-    }
-    const index = await runHistoryIndex(state, true);
-    const indexed = await index.listRuns({ ...params, sort });
-    const page = selectedPage(state, indexed);
-    const owned = [...(state.ownedRuns?.values() ?? [])];
-    const runs = page.map((view) => runSummary(view, owned));
-    const controls = page.map(ownedRunControl);
-    const { total, offset, nextOffset, nextCursor, freshness, version } = indexed;
-    return {
-        content: [{ type: "text", text: listDescription(indexed, runs, params) }],
-        details: {
-            mode: "management",
-            results: [],
-            runs,
-            managementControls: controls,
-            managementControl: controls.find((control) => control.state === "live"),
-            runList: {
-                total,
-                offset,
-                limit: params.limit ?? 20,
-                version,
-                freshness,
-                ...(nextOffset !== undefined ? { nextOffset } : {}),
-                ...(nextCursor !== undefined && nextCursor !== "" ? { nextCursor } : {}),
-            },
-        },
-    };
-}

package/dist/runs/shared/owned-run-observation.js

@@ -1,267 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { readStatus } from "../../shared/utils.js";
-import { isDurableRun, readAsyncResultFile } from "../background/async-result-file.js";
-import { parseAsyncStatus, parseForegroundResumeRun } from "../background/run-schemas.js";
-import { exactAsyncRunLocation } from "../background/async-resume.js";
-import { reconcileAsyncRun } from "../background/stale-run-reconciler.js";
-import { savedWorkflowNodes, workflowChildren } from "./workflow-graph.js";
-import { normalizedState, projectOwnedChild } from "./owned-child-evidence.js";
-import { getRunMetadataDir, questionProcessAlive, readQuestionContract, readRunJson, } from "./supervisor-questions.js";
-import { ASYNC_DIR, RESULTS_DIR, } from "../../shared/types.js";
-import { isRecord } from "../../shared/unknown.js";
-function processAlive(pid) {
-    return pid !== undefined && Number.isSafeInteger(pid) && pid > 0 && questionProcessAlive({ pid });
-}
-function readSavedStatus(run, root) {
-    const location = exactAsyncRunLocation(run.runId, ASYNC_DIR, RESULTS_DIR);
-    const asyncDir = location.asyncDir ?? run.asyncDir;
-    const liveStatus = asyncDir !== undefined && asyncDir !== "" ? readStatus(asyncDir) : null;
-    return {
-        savedStatus: liveStatus ?? readRunJson(path.join(root, "status.json"), parseAsyncStatus),
-        asyncDir,
-    };
-}
-function observedStatus(run, root, options) {
-    const { savedStatus, asyncDir } = readSavedStatus(run, root);
-    const launch = readRunJson(path.join(root, "launch.json"));
-    const durable = isDurableRun(savedStatus) || (isRecord(launch) && isDurableRun(launch));
-    const reconciliation = durable && options.reconcile !== false ? reconcileAsyncRun(asyncDir ?? root) : undefined;
-    return { savedStatus, durable, reconciliation, status: reconciliation?.status ?? savedStatus };
-}
-function observedIndices(foreground, result, status, declarationIndices) {
-    const terminal = result?.results?.map((_, index) => index) ?? foreground?.children.map((child) => child.index);
-    const indices = terminal ?? [
-        ...declarationIndices,
-        ...(status?.steps?.map((_, index) => index) ?? []),
-    ];
-    return [...new Set(indices)].sort((a, b) => a - b);
-}
-function uncertainIndices(run, status, nodes) {
-    if (run.mode !== "chain") {
-        return false;
-    }
-    if (!run.children.some((child) => (child.workflowNodeId ?? "") !== "")) {
-        return true;
-    }
-    return run.source === "async" && status !== undefined && status !== null && nodes === undefined;
-}
-function childLiveness(input) {
-    const { contract, step, parentLive } = input;
-    const live = processAlive(contract?.pid) ||
-        ((!step || step.status === "running" || step.status === "pending") && parentLive);
-    return { live, pending: childPending(input) };
-}
-function childPending(input) {
-    const { contract, step, fg, bg, parentLive } = input;
-    return (!fg &&
-        !bg &&
-        (contract?.pid ?? 0) === 0 &&
-        !contract?.result &&
-        (!step || step.status === "pending") &&
-        parentLive);
-}
-/** One bounded authoritative read owns receipt precedence and child identity reconciliation. */
-export class RunObservation {
-    root;
-    resultPath;
-    foreground;
-    result;
-    savedStatus;
-    status;
-    durable;
-    reconciliation;
-    contracts = new Map();
-    nodes;
-    declarations;
-    sessions = new Map();
-    sessionUses = new Map();
-    uncertainIndices;
-    indices;
-    run;
-    constructor(run, state, options) {
-        this.run = run;
-        this.root = getRunMetadataDir(run.runId);
-        this.resultPath = path.join(this.root, "result.json");
-        this.foreground =
-            readRunJson(path.join(this.root, "foreground.json"), parseForegroundResumeRun) ??
-                state.foregroundRuns?.get(run.runId);
-        this.result = fs.existsSync(this.resultPath) ? readAsyncResultFile(this.resultPath) : undefined;
-        const status = observedStatus(run, this.root, options);
-        this.savedStatus = status.savedStatus;
-        this.durable = status.durable;
-        this.reconciliation = status.reconciliation;
-        this.status = status.status;
-        this.readContracts(options);
-        this.nodes = savedWorkflowNodes(this.status);
-        this.declarations = workflowChildren(run.children, this.nodes ? this.status?.workflowGraph : undefined);
-        this.indices = observedIndices(this.foreground, this.result, this.status, [
-            ...this.declarations.map((child) => child.index),
-            ...this.contracts.keys(),
-        ]);
-        this.readSessionBindings();
-        this.uncertainIndices = uncertainIndices(run, this.status, this.nodes);
-    }
-    readContracts(options) {
-        const directory = path.join(this.root, "contracts");
-        for (const name of fs.existsSync(directory) ? fs.readdirSync(directory) : []) {
-            if (!/^\d+\.json$/.test(name)) {
-                continue;
-            }
-            const index = Number(name.slice(0, -5));
-            const contract = readQuestionContract(this.run.runId, index, undefined, {
-                endedAt: this.contractEnd(index),
-                readConfiguration: options.readConfiguration,
-            });
-            if (contract) {
-                this.contracts.set(index, contract);
-            }
-        }
-    }
-    contractEnd(index) {
-        return (this.status?.steps?.[index]?.endedAt ?? this.result?.timestamp ?? this.foreground?.updatedAt);
-    }
-    boundSession(index) {
-        return [
-            this.foreground?.children.find((child) => child.index === index)?.sessionFile,
-            this.result?.results?.[index]?.sessionFile,
-            this.status?.steps?.[index]?.sessionFile,
-            this.contracts.get(index)?.sessionFile,
-        ].find((file) => file !== undefined);
-    }
-    readSessionBindings() {
-        for (const index of this.indices) {
-            const file = this.boundSession(index);
-            this.sessions.set(index, file);
-            if (file !== undefined && file !== "") {
-                this.sessionUses.set(file, (this.sessionUses.get(file) ?? 0) + 1);
-            }
-        }
-    }
-    declaration(index, session) {
-        if (!this.uncertainIndices || this.nodes) {
-            return this.declarations.find((child) => child.index === index);
-        }
-        if (session === undefined || session === "" || this.sessionUses.get(session) !== 1) {
-            return;
-        }
-        return this.run.children.find((child) => child.sessionFile === session);
-    }
-    parentLive() {
-        return processAlive(this.status?.pid ?? this.run.pid);
-    }
-    evidence(index) {
-        const boundSession = this.sessions.get(index);
-        const declared = this.declaration(index, boundSession);
-        const contract = this.contracts.get(index);
-        const fg = this.foreground?.children.find((child) => child.index === index);
-        const bg = this.result?.results?.[index];
-        const step = this.status?.steps?.[index];
-        const parentLive = this.parentLive();
-        const { live, pending } = childLiveness({ contract, step, fg, bg, parentLive });
-        return {
-            boundSession,
-            declared,
-            contract,
-            fg,
-            bg,
-            step,
-            sessionFile: boundSession ?? declared?.sessionFile,
-            live,
-            pending,
-            terminalState: this.result?.terminalState,
-        };
-    }
-    identityUnavailable(evidence) {
-        if (this.run.mode !== "chain" || (evidence.declared?.workflowNodeId ?? "") !== "") {
-            return false;
-        }
-        return (evidence.boundSession === undefined ||
-            evidence.boundSession === "" ||
-            this.sessionUses.get(evidence.boundSession) !== 1);
-    }
-    child(index) {
-        const evidence = this.evidence(index);
-        return projectOwnedChild(this.run, index, evidence, this.identityUnavailable(evidence));
-    }
-    live(children) {
-        return (children.some((child) => child.state === "live") ||
-            (!this.result &&
-                (!this.status || this.status.state === "running" || this.status.state === "queued") &&
-                processAlive(this.status?.pid ?? this.run.pid)));
-    }
-    error() {
-        return (this.result?.error ??
-            this.foreground?.error ??
-            this.run.error ??
-            (this.status && !["running", "queued"].includes(this.status.state)
-                ? this.status.error
-                : undefined));
-    }
-    executionState(children, live, error) {
-        if ((error ?? "") !== "") {
-            return "failed";
-        }
-        if (this.result) {
-            return normalizedState(this.result.terminalState);
-        }
-        if (this.durable && !live) {
-            return "unknown";
-        }
-        if (live) {
-            return "live";
-        }
-        return this.childExecutionState(children);
-    }
-    childExecutionState(children) {
-        for (const state of ["failed", "blocked", "paused"]) {
-            if (children.some((child) => child.state === state)) {
-                return state;
-            }
-        }
-        if (children.length > 0 && children.every((child) => child.state === "completed")) {
-            return (this.foreground?.pausedReason ?? "") !== "" ? "paused" : "completed";
-        }
-        return this.status && !["running", "queued"].includes(this.status.state)
-            ? normalizedState(this.status.state)
-            : "unknown";
-    }
-    unknownDiagnosis() {
-        return (this.run.recoveryError ??
-            this.reconciliation?.message ??
-            "Completion is unconfirmed. Saved sessions are context, not proof of successful execution.");
-    }
-    canInterrupt(live, pending) {
-        return (pending ||
-            (live && this.savedStatus?.state === "running" && this.savedStatus.runId === this.run.runId));
-    }
-    updatedAt() {
-        return (this.result?.timestamp ??
-            this.status?.lastUpdate ??
-            this.foreground?.updatedAt ??
-            this.run.startedAt);
-    }
-    summary(children, pendingInput) {
-        const live = this.live(children);
-        const error = this.error();
-        const state = this.executionState(children, live, error);
-        return {
-            state,
-            canInterrupt: this.canInterrupt(live, pendingInput),
-            updatedAt: this.updatedAt(),
-            diagnosis: this.diagnosis(state, error),
-        };
-    }
-    diagnosis(state, error) {
-        if ((error ?? "") !== "") {
-            return error;
-        }
-        if (state === "paused" && (this.foreground?.pausedReason ?? "") !== "") {
-            return this.foreground?.pausedReason;
-        }
-        if (state === "unknown") {
-            return this.unknownDiagnosis();
-        }
-        return;
-    }
-}

package/dist/runs/shared/owned-run-progress.js

@@ -1,109 +0,0 @@
-import { getSingleResultOutput, readStatus } from "../../shared/utils.js";
-import { getRunMetadataDir } from "./supervisor-questions.js";
-import { ownedRunView } from "./owned-run-view.js";
-import { workflowDetails } from "./owned-workflow-details.js";
-function fallbackStatus(child) {
-    if (child.state === "live") {
-        return "pending";
-    }
-    return child.state === "unknown" ? "failed" : child.state;
-}
-function activity(child, step) {
-    if (child.state !== "live" || !step) {
-        return { recentTools: [], recentOutput: [] };
-    }
-    return {
-        currentTool: step.currentTool,
-        currentToolArgs: step.currentToolArgs,
-        currentToolStartedAt: step.currentToolStartedAt,
-        currentPath: step.currentPath,
-        streamingText: step.streamingText,
-        recentTools: step.recentTools?.slice(-10) ?? [],
-        recentOutput: step.recentOutput?.slice(-10) ?? [],
-    };
-}
-function progressDuration(step, startedAt) {
-    return step?.durationMs ?? Math.max(0, Date.now() - (step?.startedAt ?? startedAt));
-}
-function progressCounters(step, startedAt) {
-    return {
-        toolCount: step?.toolCount ?? 0,
-        turnCount: step?.turnCount,
-        tokens: step?.tokens?.total ?? 0,
-        durationMs: progressDuration(step, startedAt),
-    };
-}
-function stepConfiguration(step) {
-    return step
-        ? {
-            model: step.model,
-            thinking: step.thinking,
-            modelStartedAt: step.modelStartedAt,
-            activityState: step.activityState,
-            lastActivityAt: step.lastActivityAt,
-            skills: step.skills,
-            error: step.error,
-        }
-        : {};
-}
-function childProgress(run, child, step) {
-    return {
-        index: child.index,
-        agent: child.agent,
-        task: child.task ?? run.task,
-        status: step?.status ?? fallbackStatus(child),
-        ...stepConfiguration(step),
-        ...activity(child, step),
-        ...progressCounters(step, run.startedAt),
-    };
-}
-function progressUsage(item, child, step) {
-    return (child.result?.usage ?? {
-        input: step?.tokens?.input ?? 0,
-        output: step?.tokens?.output ?? 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        cost: 0,
-        turns: item.turnCount ?? 0,
-    });
-}
-function progressResult(item, child, step) {
-    const output = getSingleResultOutput(child.result ?? {});
-    const streaming = item.streamingText ?? "";
-    const fallback = streaming !== "" ? streaming : item.recentOutput.at(-1);
-    return {
-        agent: item.agent,
-        task: item.task,
-        exitCode: child.result?.exitCode ?? 0,
-        usage: progressUsage(item, child, step),
-        progress: item,
-        model: item.model,
-        sessionFile: child.sessionFile,
-        finalOutput: output !== "" ? output : fallback,
-    };
-}
-function progressLine(item) {
-    const tool = item.currentTool ?? "";
-    const args = item.currentToolArgs ?? "";
-    const suffix = tool !== "" ? ` — ${tool}${args !== "" ? ` ${args}` : ""}` : "";
-    return `${item.agent}: ${item.status}${suffix}`;
-}
-/** Project native activity for waiting callers without copying or owning its journal. */
-export function ownedRunProgressResult(run, state, index, view = ownedRunView(run, state, { readConfiguration: false, includeContinuations: false })) {
-    const status = readStatus(run.asyncDir ?? getRunMetadataDir(run.runId));
-    const children = view.children.filter((child) => index === undefined || child.index === index);
-    const progress = children.map((child) => childProgress(run, child, status?.steps?.[child.index]));
-    const results = progress.map((item, position) => progressResult(item, children[position], status?.steps?.[item.index]));
-    return {
-        content: [{ type: "text", text: progress.map(progressLine).join("\n") }],
-        details: {
-            mode: run.mode,
-            runId: run.runId,
-            asyncId: run.runId,
-            asyncDir: run.asyncDir,
-            results,
-            progress,
-            ...workflowDetails(status?.workflowGraph),
-        },
-    };
-}

package/dist/runs/shared/owned-run-read-state.js

@@ -1 +0,0 @@
-export {};