@fitchmultz/pi-subagents 0.44.7 → 0.45.0

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

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

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

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

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