@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/runs/shared/run-records.js

@@ -1,679 +1,9 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { NativeJournal, journalStamp, readOutputPage } from "../../shared/journal-reader.js";
-import { snapshotNativeUsage, readNativeUsage } from "./native-usage.js";
-import { runHistoryIndex, updateRunHistory } from "./history-index.js";
-import { resolveCurrentSessionId } from "../../shared/session-identity.js";
-import { writeAtomicJson } from "../../shared/atomic-json.js";
-import { runCooperatively, runSynchronously } from "../../shared/cooperative.js";
-import { compactForegroundResult, getFinalOutput, getSingleResultOutput, readStatus } from "../../shared/utils.js";
-import { resolveSubagentResultStatus } from "../../intercom/result-intercom.js";
-import { buildManagementControl, formatAgentProcessExit, formatRunAction } from "../../shared/status-format.js";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { isDurableRun, readAsyncResultFile } from "../background/async-result-file.js";
-import { exactAsyncRunLocation } from "../background/async-resume.js";
-import { createAsyncRunDiscovery } from "../background/async-status.js";
-import { reconcileAsyncRun } from "../background/stale-run-reconciler.js";
-import { acceptanceHumanAction } from "./acceptance-evaluation.js";
-import { formatRunIdAmbiguity } from "./run-id-ambiguity.js";
-import { resolveFinalizationOutput } from "./acceptance-finalization.js";
-import { parseAcceptanceReport, validateAcceptanceReportShape } from "./acceptance-reports.js";
-import { sumAttemptUsage } from "./model-fallback.js";
-import { workflowAgentNodes } from "./workflow-graph.js";
-import { collectInvocationAgentNames } from "../../shared/settings.js";
-import { compactOwnerResult, getRunMetadataDir, listOwnedRunQuestions, migrateSupervisorQuestionSteps, questionProcessAlive, readQuestionContract, readRunJson, saveAsyncRunResult, saveRunStatus, saveQuestionOwner, saveQuestionContract } from "./supervisor-questions.js";
-import { ASYNC_DIR, DEFAULT_MAX_OUTPUT, RESULTS_DIR, SLASH_RESULT_TYPE, truncateOutput } from "../../shared/types.js";
-export const OWNED_RUN_ENTRY = "subagent-run";
-const failedAccountingSources = new Map();
-/** Repair only recorded native billing evidence; never execute or verify work again. */
-export function repairOwnedRunAccounting(run) {
-    const file = path.join(getRunMetadataDir(run.runId), "result.json");
-    if (!fs.existsSync(file))
-        return;
-    const saved = readAsyncResultFile(file);
-    let changed = false;
-    saved.results?.forEach((child, index) => {
-        if (child.accounting?.state !== "incomplete")
-            return;
-        const contract = readQuestionContract(run.runId, index, undefined, { readConfiguration: false });
-        const terminalEntryId = child.terminalEntryId ?? contract?.terminalEntryId;
-        if (!contract?.attemptBaseline || !terminalEntryId)
-            return;
-        const source = child.sessionFile ?? contract.sessionFile;
-        if (!source)
-            return;
-        const stat = fs.statSync(source, { bigint: true, throwIfNoEntry: false });
-        const key = `${run.runId}:${index}`, stamp = `${stat ? journalStamp(stat) : "missing"}:${terminalEntryId}:${JSON.stringify(contract.attemptBaseline)}`;
-        if (failedAccountingSources.get(key) === stamp)
-            return;
-        let usage;
-        try {
-            usage = readNativeUsage(source, new Set(contract.attemptBaseline), [], { terminalEntryId })?.[0];
-        }
-        catch (error) {
-            failedAccountingSources.set(key, stamp);
-            throw error;
-        }
-        if (!usage)
-            return;
-        failedAccountingSources.delete(key);
-        child.usage = usage;
-        child.accounting = { state: "complete" };
-        changed = true;
-        if (contract.result)
-            saveQuestionContract(run.runId, index, { accounting: child.accounting, result: { ...contract.result, usage, accounting: child.accounting } });
-    });
-    if (changed)
-        saveAsyncRunResult(run.runId, saved);
-}
-export function rememberOwnedRun(state, run) {
-    const previous = state.ownedRuns?.get(run.runId);
-    (state.ownedRuns ??= new Map()).set(run.runId, run);
-    if (JSON.stringify(previous) !== JSON.stringify(run)) {
-        state.persistOwnedRun?.(run);
-        updateRunHistory(state, run);
-        state.onRunsChanged?.();
-    }
-}
-export function resolveOwnedRun(state, requested) {
-    const id = requested.trim();
-    getRunMetadataDir(id); // Same ID boundary as the question and result files.
-    const exact = state.ownedRuns?.get(id);
-    if (exact && id !== "latest" && id !== "last")
-        return exact;
-    const runs = [...(state.ownedRuns?.values() ?? [])];
-    if (id === "latest" || id === "last")
-        return runs.sort((a, b) => b.startedAt - a.startedAt)[0];
-    const matches = runs.filter((run) => run.runId.startsWith(id));
-    if (matches.length > 1)
-        throw new Error(formatRunIdAmbiguity("owned", id, matches.map((run) => run.runId)));
-    return matches[0];
-}
-export function saveForegroundRun(input) {
-    const run = {
-        runId: input.runId, mode: input.mode, cwd: input.cwd, updatedAt: Date.now(),
-        ...(input.error ? { error: input.error } : {}),
-        ...(input.pausedReason ? { pausedReason: input.pausedReason } : {}),
-        children: input.results.map((result, index) => ({
-            agent: result.agent, index,
-            status: resolveSubagentResultStatus(result),
-            ...(!result.detached ? { summary: (getSingleResultOutput(result) || result.error)?.slice(-8192) } : {}),
-            artifactPath: result.artifactPaths?.outputPath,
-            sessionFile: result.sessionFile,
-            effectiveAcceptance: result.acceptance?.effectiveAcceptance,
-            result: compactOwnerResult(input.runId, index, compactForegroundResult(result)),
-        })),
-    };
-    writeAtomicJson(path.join(getRunMetadataDir(input.runId), "foreground.json"), run);
-    return run;
-}
-function receiptDetails(entry) {
-    if (entry.type === "message" && entry.message.role === "toolResult" && ["subagent", "delegate", "agent_runs"].includes(entry.message.toolName))
-        return entry.message.details;
-    if (entry.type === "custom_message" && entry.customType === SLASH_RESULT_TYPE) {
-        const details = entry.details;
-        return details?.result?.details;
-    }
-    return undefined;
-}
-function sessionFiles(root) {
-    if (!fs.existsSync(root))
-        return [];
-    return fs.readdirSync(root, { withFileTypes: true }).flatMap((entry) => entry.isDirectory()
-        ? sessionFiles(path.join(root, entry.name))
-        : entry.name.endsWith(".jsonl") ? [path.join(root, entry.name)] : []);
-}
-function recoverOutput(sessionFile, outputFile, endedAt) {
-    if (outputFile && fs.existsSync(outputFile))
-        return readOutputPage(outputFile).text;
-    if (!sessionFile || !fs.existsSync(sessionFile))
-        return undefined;
-    const journal = new NativeJournal(sessionFile);
-    for (const record of journal.branch(undefined, endedAt).reverse()) {
-        if (record.value.type !== "message" || record.value.message?.role !== "assistant")
-            continue;
-        const output = getFinalOutput([journal.body(record).message]);
-        if (output)
-            return output;
-    }
-}
-function recoverLegacyTerminalOutput(sessionFile, startedAt, endedAt, acceptance) {
-    const review = acceptance?.finalization;
-    const reviewedOutput = review?.status === "completed" ? review.turns.at(-1)?.rawOutput : undefined;
-    if (reviewedOutput?.trim())
-        return resolveFinalizationOutput(reviewedOutput, "") || undefined;
-    // Live and finalization logs are separate, mutable streams, not a final-answer receipt.
-    if (endedAt === undefined || !Number.isFinite(endedAt) || !sessionFile || !fs.existsSync(sessionFile))
-        return;
-    const journal = new NativeJournal(sessionFile);
-    const records = journal.branch(undefined, endedAt).filter(({ value }) => value.type === "message" && Date.parse(value.timestamp) >= startedAt);
-    const lastAssistant = records.findLastIndex(({ value }) => value.message?.role === "assistant");
-    const messages = records.map((record, index) => index === lastAssistant ? journal.body(record).message : record.value.message);
-    const index = messages.findLastIndex((message) => message.role === "assistant");
-    const last = messages[index];
-    if (last?.role !== "assistant" || last.errorMessage || !["stop", "toolUse"].includes(last.stopReason) || !Array.isArray(last.content))
-        return;
-    const calls = last.content.filter((part) => part.type === "toolCall");
-    if (!calls.length)
-        return index === messages.length - 1 && last.stopReason === "stop" ? resolveFinalizationOutput(getFinalOutput([last]), "") || undefined : undefined;
-    if (calls.length !== 1 || calls[0].name !== "structured_output")
-        return;
-    const following = messages.slice(index + 1);
-    const result = following.at(-1);
-    if (following.some((message) => message.role !== "toolResult") || result?.role !== "toolResult" || result.toolCallId !== calls[0].id || result.toolName !== "structured_output" || result.isError !== false)
-        return;
-    const value = calls[0].arguments.value;
-    if (!value || typeof value !== "object" || !("report" in value))
-        return;
-    if (typeof value.report === "string" && parseAcceptanceReport(value.report).report)
-        return resolveFinalizationOutput(value.report, "") || undefined;
-    if ("answer" in value && typeof value.answer === "string" && value.answer.trim() && !validateAcceptanceReportShape(value.report))
-        return value.answer;
-}
-export function workflowChildren(children, graph) {
-    if (!graph || (graph.mode !== "chain" && !children.some((child) => child.workflowNodeId)))
-        return children;
-    return workflowAgentNodes(graph).map((node, index) => {
-        const declared = children.find((child) => child.workflowNodeId === node.id);
-        return { ...declared, index, workflowNodeId: node.id, agent: node.agent ?? declared?.agent ?? "unknown",
-            ...(node.itemKey !== undefined ? { label: node.label } : {}) };
-    });
-}
-function savedWorkflowNodes(status) {
-    if (!status?.workflowGraph || status.workflowGraph.runId !== status.runId)
-        return;
-    const nodes = workflowAgentNodes(status.workflowGraph);
-    if (nodes.length !== status.steps?.length || new Set(nodes.map((node) => node.id)).size !== nodes.length)
-        return;
-    if (nodes.some((node, index) => typeof node.id !== "string" || !node.id || (node.agent && node.agent !== status.steps[index].agent)))
-        return;
-    return nodes;
-}
-export function restoreOwnedRuns(state, ctx) {
-    return runSynchronously(restoreOwnedRunSteps(state, ctx));
-}
-export async function restoreOwnedRunsAsync(state, ctx) {
-    const onRunsChanged = state.onRunsChanged;
-    // Publish readiness once restoration is complete, before starting browse/UI work.
-    state.onRunsChanged = undefined;
-    try {
-        return await runCooperatively(restoreOwnedRunSteps(state, ctx));
-    }
-    finally {
-        state.onRunsChanged = onRunsChanged;
-    }
-}
-function* restoreOwnedRunSteps(state, ctx) {
-    const startedAt = Date.now();
-    const ownerSessionId = ctx.sessionManager.getSessionId();
-    const entries = ctx.sessionManager.getEntries();
-    state.ownedRuns = new Map();
-    yield* migrateSupervisorQuestionSteps(ownerSessionId);
-    for (const entry of entries) {
-        yield;
-        if (entry.type !== "custom" || entry.customType !== OWNED_RUN_ENTRY)
-            continue;
-        const run = ctx.sessionManager.getEntry(entry.id)?.data;
-        if (run?.ownerSessionId === ownerSessionId && run.runId && Array.isArray(run.children))
-            state.ownedRuns.set(run.runId, run);
-    }
-    // Forks copy old entries. Their old receipts are evidence, not ownership for the new parent.
-    const inheritedIds = new Set();
-    const parentFile = ctx.sessionManager.getHeader()?.parentSession;
-    if (parentFile && fs.existsSync(parentFile)) {
-        for (const id of snapshotNativeUsage(parentFile))
-            inheritedIds.add(id);
-    }
-    const recoveredReceipts = [];
-    for (const entry of entries) {
-        yield;
-        if (!(entry.type === "message" && entry.message.role === "toolResult" && ["subagent", "delegate", "agent_runs"].includes(entry.message.toolName)
-            || entry.type === "custom_message" && entry.customType === SLASH_RESULT_TYPE))
-            continue;
-        const receipt = ctx.sessionManager.getEntry(entry.id);
-        if (receipt)
-            recoveredReceipts.push(receipt);
-    }
-    const calls = new Map();
-    const needsLegacyCalls = recoveredReceipts.some((entry) => { const details = receiptDetails(entry); return details && !state.ownedRuns.has(details.runId ?? details.asyncId ?? ""); });
-    for (const metadata of needsLegacyCalls ? entries : []) {
-        yield;
-        if (metadata.type !== "message" || metadata.message.role !== "assistant")
-            continue;
-        const entry = ctx.sessionManager.getEntry(metadata.id);
-        if (entry?.type !== "message" || entry.message.role !== "assistant" || !Array.isArray(entry.message.content))
-            continue;
-        for (const part of entry.message.content)
-            if (part.type === "toolCall" && ["subagent", "delegate"].includes(part.name))
-                calls.set(part.id, part.arguments);
-    }
-    for (const entry of recoveredReceipts) {
-        yield;
-        if (inheritedIds.has(entry.id) || (parentFile && !fs.existsSync(parentFile)))
-            continue;
-        const details = receiptDetails(entry);
-        const runId = details?.runId ?? details?.asyncId;
-        if (!runId || !details || !Array.isArray(details.results) || (details.mode !== "single" && details.mode !== "parallel" && details.mode !== "chain") || state.ownedRuns.has(runId))
-            continue;
-        const cwd = details.results.find((result) => result.sessionFile)?.sessionFile;
-        const request = entry.type === "message" && entry.message.role === "toolResult" ? calls.get(entry.message.toolCallId) : undefined;
-        const run = {
-            runId, ownerSessionId, rootRunId: details.managementControl?.revivedFromRunId ?? runId,
-            predecessorRunId: details.managementControl?.revivedFromRunId,
-            source: details.asyncId ? "async" : "foreground", mode: details.mode,
-            cwd: request?.cwd ? path.resolve(ctx.cwd, request.cwd) : ctx.cwd, task: details.results[0]?.task ?? request?.task ?? "Recovered delegated run",
-            startedAt: Date.parse(entry.timestamp), asyncDir: details.asyncDir, legacy: true,
-            children: details.results.length ? details.results.map((result, index) => ({ agent: result.agent, index, task: result.task, sessionFile: result.sessionFile })) : collectInvocationAgentNames(request ?? {}).map((agent, index) => ({ agent, index })),
-        };
-        try {
-            if (cwd && fs.existsSync(cwd)) {
-                const header = new NativeJournal(cwd).records[0]?.value;
-                if (header?.type === "session" && header.cwd)
-                    run.cwd = header.cwd;
-            }
-            if (run.source === "foreground")
-                saveForegroundRun({ ...run, results: details.results.map((result) => ({ ...result, finalOutput: result.finalOutput ?? recoverOutput(result.sessionFile, result.artifactPaths?.outputPath, Date.parse(entry.timestamp)) })) });
-            let owner;
-            try {
-                owner = readRunJson(path.join(getRunMetadataDir(runId), "question-owner.json"));
-            }
-            catch { /* Unusable metadata can be repaired from the genuine receipt. */ }
-            if (typeof owner?.sessionId !== "string" || !owner.sessionId.trim())
-                saveQuestionOwner(runId, ownerSessionId);
-            rememberOwnedRun(state, run);
-        }
-        catch (error) {
-            // The genuine receipt still establishes ownership. Keep completion
-            // unconfirmed when its supplemental output/context cannot be recovered.
-            rememberOwnedRun(state, { ...run, recoveryError: `Saved child recovery remains incomplete: ${String(error)}` });
-            console.error(`Could not recover legacy receipt ${runId}: ${String(error)}`);
-        }
-    }
-    // Pre-update background runs may have no parent tool receipt (for example slash launches).
-    const scan = createAsyncRunDiscovery(ASYNC_DIR, {
-        sessionId: ctx.sessionManager.getSessionFile() ?? resolveCurrentSessionId(ctx.sessionManager), ownerSessionId,
-        receiptRunIds: () => state.ownedRuns.keys(), skipInvalid: true,
-    });
-    function* discoverSteps() {
-        const records = yield* scan.steps();
-        for (const { location, status, durable } of records) {
-            yield;
-            try {
-                const asyncDir = location.asyncDir;
-                if (!asyncDir || !status)
-                    continue;
-                const terminal = !["running", "queued"].includes(status.state);
-                if (!durable && terminal)
-                    saveRunStatus(status.runId, status);
-                const old = state.ownedRuns.get(status.runId);
-                const nodes = savedWorkflowNodes(status);
-                const declared = status.mode === "chain" && nodes && !old?.children.some((child) => child.workflowNodeId) ? [] : old?.children ?? [];
-                const children = workflowChildren(declared, nodes ? status.workflowGraph : undefined);
-                rememberOwnedRun(state, {
-                    ...old, runId: status.runId, ownerSessionId, rootRunId: old?.rootRunId ?? status.runId,
-                    source: "async", mode: status.mode, cwd: status.cwd ?? old?.cwd ?? ctx.cwd,
-                    task: old?.task ?? "Recovered background run", startedAt: status.startedAt,
-                    asyncDir, pid: status.pid, legacy: old?.legacy ?? !durable,
-                    children: (status.steps ?? []).map((step, index) => ({ ...children.find((child) => child.index === index), agent: step.agent, index, ...(status.mode === "chain" && nodes?.[index] ? { workflowNodeId: nodes[index].id } : {}), label: step.label ?? children[index]?.label, sessionFile: step.sessionFile ?? (status.steps?.length === 1 ? status.sessionFile : undefined) })),
-                });
-                const resultPath = path.join(RESULTS_DIR, `${status.runId}.json`);
-                if (!durable && terminal && !fs.existsSync(path.join(getRunMetadataDir(status.runId), "result.json"))) {
-                    if (fs.existsSync(resultPath))
-                        saveAsyncRunResult(status.runId, readAsyncResultFile(resultPath));
-                    else if (status.steps?.length && status.steps.every((step) => !["running", "pending"].includes(step.status))) {
-                        const endedAt = status.endedAt ?? status.lastUpdate ?? status.startedAt;
-                        const results = status.steps.map((step) => {
-                            const sessionFile = step.sessionFile ?? (status.steps.length === 1 ? status.sessionFile : undefined);
-                            return { agent: step.agent, sessionFile, model: step.model, acceptance: step.acceptance,
-                                exitCode: step.exitCode, agentProcessExit: step.agentProcessExit, success: step.status === "complete" || step.status === "completed",
-                                interrupted: step.status === "paused" || undefined, timedOut: step.status === "timed-out" || undefined, error: step.error,
-                                output: recoverLegacyTerminalOutput(sessionFile, step.startedAt ?? status.startedAt, step.endedAt ?? status.endedAt, step.acceptance) ?? "" };
-                        });
-                        saveAsyncRunResult(status.runId, { id: status.runId, sessionId: status.sessionId, mode: status.mode, state: status.state,
-                            success: status.state === "complete", error: status.error, timestamp: endedAt, cwd: status.cwd, asyncDir, sessionFile: status.sessionFile, results });
-                    }
-                }
-            }
-            catch (error) {
-                console.error(`Could not recover owned async metadata for '${location.resolvedId}':`, error);
-            }
-        }
-        return records;
-    }
-    const discover = () => runSynchronously(discoverSteps());
-    const records = yield* discoverSteps();
-    for (const run of state.ownedRuns.values()) {
-        yield;
-        try {
-            const stored = readRunJson(path.join(getRunMetadataDir(run.runId), "foreground.json"));
-            if (stored)
-                (state.foregroundRuns ??= new Map()).set(run.runId, stored);
-            if (run.children.some((child) => child.sessionFile) || !run.legacy)
-                continue;
-            const file = ctx.sessionManager.getSessionFile();
-            if (!file)
-                continue;
-            const root = path.join(path.dirname(file), path.basename(file, ".jsonl"), run.runId);
-            const files = sessionFiles(root).sort();
-            if (files.length)
-                rememberOwnedRun(state, { ...run, children: files.map((sessionFile, index) => ({ agent: run.children[index]?.agent ?? "unknown", index, sessionFile })) });
-        }
-        catch (error) {
-            console.error(`Could not recover foreground owner ${run.runId}: ${String(error)}`);
-        }
-    }
-    return { startedAt, records, discover };
-}
-function normalizedState(value) {
-    if (value === "running" || value === "queued")
-        return "live";
-    if (value === "complete" || value === "completed")
-        return "completed";
-    if (value === "failed" || value === "timed-out")
-        return "failed";
-    if (value === "blocked")
-        return "blocked";
-    if (value === "paused")
-        return "paused";
-    return "unknown";
-}
-function processAlive(pid) {
-    return Boolean(pid && Number.isSafeInteger(pid) && pid > 0 && questionProcessAlive({ pid }));
-}
-function asyncChildResult(child, task) {
-    const { output, ...result } = child;
-    return {
-        ...result, agent: child.agent ?? "unknown", task: child.task ?? task, exitCode: child.exitCode ?? (child.success ? 0 : 1),
-        finalOutput: child.finalOutput ?? output, usage: child.usage ?? sumAttemptUsage(child.modelAttempts ?? []),
-    };
-}
-function runAttention(run, executionState, pendingInput) {
-    return [
-        ...(pendingInput ? ["awaiting_input"] : []),
-        ...(run.review?.decision === "needs_changes" ? ["needs_changes"] : []),
-        ...(run.review?.decision !== "accepted" && ["failed", "blocked", "paused", "unknown"].includes(executionState) ? [executionState] : []),
-        ...(executionState === "completed" && !run.review ? ["unreviewed"] : []),
-    ];
-}
-export function ownedRunView(run, state, options = {}) {
-    run = state.ownedRuns?.get(run.runId) ?? run;
-    const root = getRunMetadataDir(run.runId);
-    const foreground = readRunJson(path.join(root, "foreground.json")) ?? state.foregroundRuns?.get(run.runId);
-    const resultPath = path.join(root, "result.json");
-    const result = fs.existsSync(resultPath) ? readAsyncResultFile(resultPath) : undefined;
-    const location = exactAsyncRunLocation(run.runId, ASYNC_DIR, RESULTS_DIR);
-    const asyncDir = location.asyncDir ?? run.asyncDir;
-    const liveStatus = asyncDir ? readStatus(asyncDir) : null;
-    const savedStatus = liveStatus ?? readRunJson(path.join(root, "status.json"));
-    const durable = isDurableRun(savedStatus) || isDurableRun(readRunJson(path.join(root, "launch.json")));
-    const reconciliation = durable && options.reconcile !== false ? reconcileAsyncRun(asyncDir ?? root) : undefined;
-    const status = reconciliation?.status ?? savedStatus;
-    const contracts = new Map();
-    const contractDir = path.join(root, "contracts");
-    for (const name of fs.existsSync(contractDir) ? fs.readdirSync(contractDir) : []) {
-        if (!/^\d+\.json$/.test(name))
-            continue;
-        const index = Number(name.slice(0, -5));
-        const contract = readQuestionContract(run.runId, index, undefined, { endedAt: status?.steps?.[index]?.endedAt ?? result?.timestamp ?? foreground?.updatedAt, readConfiguration: options.readConfiguration });
-        if (contract)
-            contracts.set(index, contract);
-    }
-    const nodes = savedWorkflowNodes(status);
-    const declarations = workflowChildren(run.children, nodes ? status?.workflowGraph : undefined);
-    // Terminal snapshots contain materialized children; declared slots can include an empty fanout or unstarted downstream steps.
-    const terminalIndices = result?.results?.map((_, index) => index) ?? foreground?.children.map((child) => child.index);
-    const indices = new Set(terminalIndices ?? [...declarations.map((child) => child.index), ...contracts.keys(), ...(status?.steps?.map((_, index) => index) ?? [])]);
-    const sessions = new Map([...indices].map((index) => [index, foreground?.children.find((child) => child.index === index)?.sessionFile ?? result?.results?.[index]?.sessionFile ?? status?.steps?.[index]?.sessionFile ?? contracts.get(index)?.sessionFile]));
-    const sessionUses = new Map();
-    for (const file of sessions.values())
-        if (file)
-            sessionUses.set(file, (sessionUses.get(file) ?? 0) + 1);
-    const uncertainIndices = run.mode === "chain" && (!run.children.some((child) => child.workflowNodeId) || (run.source === "async" && status && !nodes));
-    const children = [...indices].sort((a, b) => a - b).map((index) => {
-        const boundSession = sessions.get(index);
-        const declared = uncertainIndices && !nodes
-            ? run.children.find((child) => boundSession && sessionUses.get(boundSession) === 1 && child.sessionFile === boundSession)
-            : declarations.find((child) => child.index === index);
-        const contract = contracts.get(index);
-        const fg = foreground?.children.find((child) => child.index === index);
-        const bg = result?.results?.[index];
-        const step = status?.steps?.[index];
-        const sessionFile = boundSession ?? declared?.sessionFile;
-        const live = processAlive(contract?.pid) || ((!step || step.status === "running" || step.status === "pending") && processAlive(status?.pid ?? run.pid));
-        const pending = !fg && !bg && !contract?.pid && !contract?.result && ((!step || step.status === "pending") && processAlive(status?.pid ?? run.pid));
-        const childState = bg ? normalizedState(resolveSubagentResultStatus({ success: bg.success, exitCode: bg.exitCode ?? undefined, interrupted: bg.interrupted, acceptance: bg.acceptance, state: typeof bg.success !== "boolean" && bg.exitCode == null ? result?.terminalState : undefined }))
-            : fg && fg.status !== "detached" ? normalizedState(fg.status)
-                : contract?.result ? normalizedState(resolveSubagentResultStatus(contract.result))
-                    : live || pending ? "live"
-                        : step && !["running", "pending"].includes(step.status) ? normalizedState(step.status) : "unknown";
-        const task = contract?.task ?? declared?.task ?? fg?.result?.task ?? (run.children.length === 1 ? run.task : undefined);
-        const selection = contract?.modelSelection ?? step ?? fg?.result?.progress;
-        return {
-            agent: fg?.agent ?? bg?.agent ?? step?.agent ?? contract?.launch?.agent.name ?? declared?.agent ?? "unknown", index, workflowNodeId: declared?.workflowNodeId, sessionFile,
-            task, label: contract?.label ?? step?.label ?? declared?.label,
-            ...(run.mode === "chain" && !declared?.workflowNodeId && (!boundSession || sessionUses.get(boundSession) !== 1) ? { identityUnavailable: true } : {}),
-            modelSelection: selection ? { model: selection.model, thinking: selection.thinking, modelStartedAt: selection.modelStartedAt } : undefined,
-            activity: childState === "live" ? (pending ? { ...step, status: "pending" } : step) : undefined,
-            state: childState, result: fg?.status !== "detached" && fg?.result ? fg.result : bg ? asyncChildResult(bg, task ?? "Original child assignment unavailable") : contract?.result ?? fg?.result,
-            launch: contract?.launch, configuration: contract?.launch ? "saved" : "legacy-partial",
-            ...(sessionFile && !fs.existsSync(sessionFile) ? { missingSession: true } : {}),
-        };
-    });
-    const live = children.some((child) => child.state === "live") || (!result && (!status || status.state === "running" || status.state === "queued") && processAlive(status?.pid ?? run.pid));
-    const error = result?.error ?? foreground?.error ?? run.error ?? (status && !["running", "queued"].includes(status.state) ? status.error : undefined);
-    const executionState = error ? "failed" : result ? normalizedState(result.terminalState)
-        : durable && !live ? "unknown"
-            : live ? "live"
-                : children.some((child) => child.state === "failed") ? "failed"
-                    : children.some((child) => child.state === "blocked") ? "blocked"
-                        : children.some((child) => child.state === "paused") ? "paused"
-                            : children.length && children.every((child) => child.state === "completed") ? (foreground?.pausedReason ? "paused" : "completed")
-                                : status && !["running", "queued"].includes(status.state) ? normalizedState(status.state) : "unknown";
-    const pendingInput = options.pendingInput ?? listOwnedRunQuestions(run.ownerSessionId, run.runId).some((question) => question.state === "awaiting_input" || question.state === "answer_pending");
-    return {
-        ...run, state: executionState, children, attention: runAttention(run, executionState, pendingInput),
-        canInterrupt: pendingInput || (live && savedStatus?.state === "running" && savedStatus.runId === run.runId),
-        updatedAt: result?.timestamp ?? status?.lastUpdate ?? foreground?.updatedAt ?? run.startedAt,
-        continuations: options.includeContinuations === false ? [] : [...(state.ownedRuns?.values() ?? [])].filter((candidate) => candidate.rootRunId === run.rootRunId && candidate.predecessorRunId).sort((a, b) => a.startedAt - b.startedAt).map((candidate) => ({ runId: candidate.runId, predecessorRunId: candidate.predecessorRunId, predecessorIndex: candidate.predecessorIndex })),
-        ...(result ? { resultPath } : foreground ? { resultPath: path.join(root, "foreground.json") } : {}),
-        ...(error ? { diagnosis: error } : executionState === "paused" && foreground?.pausedReason ? { diagnosis: foreground.pausedReason } : executionState === "unknown" ? { diagnosis: run.recoveryError ?? reconciliation?.message ?? "Completion is unconfirmed. Saved sessions are context, not proof of successful execution." } : {}),
-    };
-}
-function workflowDetails(graph) {
-    if (!graph)
-        return {};
-    if (graph.mode !== "chain")
-        return { workflowGraph: graph };
-    const current = graph.nodes.find((node) => node.id === graph.currentNodeId || node.children?.some((child) => child.id === graph.currentNodeId));
-    return { workflowGraph: graph, chainAgents: graph.nodes.map((node) => node.agent ?? node.label), totalSteps: graph.nodes.length,
-        ...(current?.stepIndex !== undefined ? { currentStepIndex: current.stepIndex } : {}) };
-}
-export function ownedRunExecutionResult(run, state, index, includeProgress = false) {
-    try {
-        repairOwnedRunAccounting(run);
-    }
-    catch (error) {
-        console.error(`Native accounting for ${run.runId} remains incomplete:`, error);
-    }
-    const view = ownedRunView(run, state);
-    const location = exactAsyncRunLocation(run.runId, ASYNC_DIR, RESULTS_DIR);
-    const saved = location.resultPath ? readAsyncResultFile(location.resultPath) : undefined;
-    const limits = { ...DEFAULT_MAX_OUTPUT, ...(saved?.maxOutput ?? view.children[0]?.launch?.maxOutput) };
-    const children = view.children.filter((child) => index === undefined || child.index === index);
-    const projected = view.children.map((child) => {
-        if (!child.result)
-            return { ...child, result: undefined };
-        const { artifactPaths, ...result } = child.result;
-        const finalOutput = getSingleResultOutput(result);
-        const truncation = result.outputMode === "file-only" && result.exitCode === 0 && result.outputReference
-            ? { text: result.outputReference.message, truncated: false } : truncateOutput(finalOutput, limits, artifactPaths?.outputPath);
-        const compacted = compactForegroundResult({ ...result, finalOutput: truncation.text,
-            ...(truncation.truncated ? { truncation } : {}),
-            ...(result.initialOutput ? { initialOutput: truncateOutput(result.initialOutput, limits, artifactPaths?.outputPath).text } : {}),
-        });
-        return { ...child, result: { ...compacted, ...(artifactPaths ? { artifactPaths } : {}) } };
-    });
-    const results = projected.filter((child) => index === undefined || child.index === index).flatMap((child) => {
-        if (!child.result)
-            return [];
-        const { artifactPaths, ...result } = child.result;
-        return [{ ...result, ...(artifactPaths?.inputPath && artifactPaths.outputPath && artifactPaths.metadataPath
-                    ? { artifactPaths: { inputPath: artifactPaths.inputPath, outputPath: artifactPaths.outputPath, metadataPath: artifactPaths.metadataPath } } : {}) }];
-    });
-    let text = (index === undefined ? saved?.summary : undefined) || [...children.map((child) => child.result ? getSingleResultOutput(child.result) || child.result.error : undefined), view.diagnosis].filter(Boolean).join("\n\n");
-    const failed = index === undefined ? ["failed", "unknown"].includes(view.state) : children.length === 0 || children.some((child) => ["failed", "unknown"].includes(child.state));
-    if (failed && saved?.error && !text.includes(saved.error))
-        text = `${saved.error}\n\n${text}`;
-    const logPath = path.join(location.asyncDir ?? run.asyncDir ?? getRunMetadataDir(run.runId), `subagent-log-${run.runId}.md`);
-    const artifactPath = run.mode === "single" ? results[0]?.artifactPaths?.outputPath : fs.existsSync(logPath) ? logPath : undefined;
-    const referenceOnly = view.state === "completed" && run.mode === "single" && results.length === 1 && results[0]?.outputMode === "file-only" && results[0].outputReference;
-    const truncation = referenceOnly ? { text: referenceOnly.message, truncated: false }
-        : view.state === "blocked" ? { text, truncated: false } : truncateOutput(text, limits, artifactPath);
-    const files = results.flatMap((result) => result.artifactPaths ? [result.artifactPaths] : []);
-    const progressSummary = { toolCount: results.reduce((total, result) => total + (result.progressSummary?.toolCount ?? 0), 0),
-        tokens: results.reduce((total, result) => total + (result.progressSummary?.tokens ?? 0), 0),
-        durationMs: saved?.durationMs ?? Math.max(0, ...results.map((result) => result.progressSummary?.durationMs ?? 0)) };
-    const share = saved?.shareUrl ? `Session: ${saved.shareUrl}` : saved?.shareError ? `Session share error: ${saved.shareError}` : undefined;
-    const identity = run.predecessorRunId ? `Run: ${run.runId}\nPredecessor: ${run.predecessorRunId} (child ${run.predecessorIndex ?? 0})` : undefined;
-    return { content: [{ type: "text", text: [identity, truncation.text || `Run ${run.runId}: ${view.state}.`, share].filter(Boolean).join("\n\n") }],
-        ...(failed ? { isError: true } : {}),
-        details: { mode: run.mode, runId: run.runId, asyncId: run.runId, asyncDir: location.asyncDir ?? run.asyncDir, results,
-            run: { ...view, children: projected }, progressSummary,
-            ...(includeProgress ? { progress: ownedRunProgressResult(run, state, index).details.progress } : {}),
-            ...(saved?.shareUrl ? { shareUrl: saved.shareUrl } : {}),
-            ...(saved?.gistUrl ? { gistUrl: saved.gistUrl } : {}),
-            ...(saved?.shareError ? { shareError: saved.shareError } : {}),
-            ...(files.length ? { artifacts: { dir: saved?.artifactsDir ?? path.dirname(files[0].outputPath), files } } : {}),
-            ...(truncation.truncated ? { truncation } : {}),
-            ...(saved?.outputs ? { outputs: saved.outputs } : {}), ...workflowDetails(saved?.workflowGraph) } };
-}
-/** Project the run owner's native activity for waiting callers without copying 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) => {
-        const step = status?.steps?.[child.index];
-        const live = child.state === "live";
-        return {
-            index: child.index, agent: child.agent, task: child.task ?? run.task,
-            status: step?.status ?? (child.state === "live" ? "pending" : child.state === "unknown" ? "failed" : child.state),
-            model: step?.model, thinking: step?.thinking, modelStartedAt: step?.modelStartedAt,
-            activityState: step?.activityState, lastActivityAt: step?.lastActivityAt, skills: step?.skills,
-            ...(live ? { currentTool: step?.currentTool, currentToolArgs: step?.currentToolArgs, currentToolStartedAt: step?.currentToolStartedAt,
-                currentPath: step?.currentPath, streamingText: step?.streamingText } : {}),
-            recentTools: live ? step?.recentTools?.slice(-10) ?? [] : [], recentOutput: live ? step?.recentOutput?.slice(-10) ?? [] : [],
-            toolCount: step?.toolCount ?? 0, turnCount: step?.turnCount, tokens: step?.tokens?.total ?? 0,
-            durationMs: step?.durationMs ?? Math.max(0, Date.now() - (step?.startedAt ?? run.startedAt)), error: step?.error,
-        };
-    });
-    const results = progress.map((item, position) => ({
-        agent: item.agent, task: item.task, exitCode: children[position]?.result?.exitCode ?? 0,
-        usage: children[position]?.result?.usage ?? { input: status?.steps?.[item.index]?.tokens?.input ?? 0, output: status?.steps?.[item.index]?.tokens?.output ?? 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: item.turnCount ?? 0 },
-        progress: item, model: item.model, sessionFile: children[position]?.sessionFile,
-        finalOutput: getSingleResultOutput(children[position]?.result ?? {}) || item.streamingText || item.recentOutput.at(-1),
-    }));
-    return { content: [{ type: "text", text: progress.map((item) => `${item.agent}: ${item.status}${item.currentTool ? ` — ${item.currentTool}${item.currentToolArgs ? ` ${item.currentToolArgs}` : ""}` : ""}`).join("\n") }],
-        details: { mode: run.mode, runId: run.runId, asyncId: run.runId, asyncDir: run.asyncDir, results, progress, ...workflowDetails(status?.workflowGraph) } };
-}
-function compact(value, max = 180) {
-    const text = value.replace(/\s+/g, " ").trim();
-    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-function ownedRunControl(view) {
-    const active = view.children.find((child) => child.state === "live" && child.activity?.status !== "pending");
-    const resumable = active ?? view.children.find((child) => child.state !== "live" && child.sessionFile && !child.missingSession);
-    return buildManagementControl({ state: view.state, runId: view.runId, index: resumable?.index, canReview: view.state !== "live", canResume: Boolean(resumable), canNudge: Boolean(active), canInterrupt: view.canInterrupt, intercomTarget: active ? resolveSubagentIntercomTarget(view.runId, active.agent, active.index) : undefined });
-}
-export function ownedRunStatusResult(run, state, runtime, options = {}) {
-    const view = ownedRunView(run, state);
-    const liveControl = view.state === "live" && runtime?.details.managementControl?.state === "live" ? runtime.details.managementControl : undefined;
-    const control = liveControl ?? ownedRunControl(view);
-    const lines = [
-        `Run: ${run.runId}`, `State: ${view.state}`, `Mode: ${run.mode} (${run.source})`, `Task: ${options.full ? run.task : compact(run.task)}`, `Launch cwd: ${run.cwd}`,
-        `Root: ${run.rootRunId}`, ...(run.predecessorRunId ? [`Predecessor: ${run.predecessorRunId} (child ${run.predecessorIndex ?? 0})`] : []),
-        `Parent review (not sent to child): ${run.review?.decision ?? "unreviewed"}${run.review?.message ? ` — ${options.full ? run.review.message : compact(run.review.message)}` : ""}`,
-        `Notification: ${run.delivery ? `recorded ${new Date(run.delivery.notifiedAt).toISOString()}; intercom ${run.delivery.intercomDelivered ? "delivered" : "not confirmed"}` : "not recorded"}`,
-        ...(view.attention.length ? [`Attention: ${view.attention.join(", ")}`] : []),
-        ...(view.resultPath ? [`Result: ${view.resultPath}`] : []), ...(view.diagnosis ? [view.diagnosis] : []),
-        ...(runtime && !runtime.isError && (run.source === "async" || liveControl) ? runtime.content.flatMap((part) => part.type === "text" ? [part.text] : []) : []),
-    ];
-    for (const child of view.children) {
-        lines.push(`Child ${child.index}: ${child.agent} | ${child.state}${child.result?.acceptance ? ` | validation: ${child.result.acceptance.status}` : ""}`);
-        const humanAction = acceptanceHumanAction(child.result?.acceptance);
-        if (humanAction)
-            lines.push(`  Needs your action — acceptance incomplete:\n${humanAction}`);
-        if (child.state !== "live")
-            lines.push(`  ${formatAgentProcessExit(child.result?.agentProcessExit)}`);
-        if (child.sessionFile)
-            lines.push(`  Session: ${child.sessionFile}${child.missingSession ? " (missing; continuation unavailable)" : ""}`);
-        if (child.result?.auditPath)
-            lines.push(`  Child observations / uncommitted output: ${child.result.auditPath}`);
-        if (child.result?.fullOutputPath)
-            lines.push(`  Full output: ${child.result.fullOutputPath}`);
-        if (child.result?.accounting?.state === "incomplete")
-            lines.push(`  Accounting incomplete: ${child.result.accounting.error ?? "Native billing evidence is unavailable; no work was repeated."}`);
-        const artifact = child.result?.artifactPaths?.outputPath;
-        if (artifact)
-            lines.push(`  Artifact: ${artifact}${fs.existsSync(artifact) ? "" : " (missing)"}`);
-        const metadata = child.result?.artifactPaths?.metadataPath;
-        if (metadata)
-            lines.push(`  Result metadata (acceptance details when configured): ${metadata}${fs.existsSync(metadata) ? "" : " (missing)"}`);
-        if (child.launch) {
-            const launch = child.launch;
-            lines.push(`  Effective model: ${launch.model ?? "native default"}; thinking: ${launch.thinking ?? "native default"}`, `  Output: ${launch.output || "disabled"} (${launch.outputMode}); configuration: saved launch snapshot`);
-            if (options.full)
-                lines.push(`  Saved launch configuration:\n${JSON.stringify(launch, null, 2)}`);
-        }
-        else
-            lines.push("  Configuration: legacy-partial; original profile snapshot was not recorded.");
-        const output = child.result && getSingleResultOutput(child.result);
-        if (output)
-            lines.push(`  Result: ${compact(output, 600)}`);
-        if (child.result?.error)
-            lines.push(`  Error: ${child.result.error}`);
-    }
-    if (control.capabilities.includes("review"))
-        lines.push(`Review (parent-only, not sent to child): ${formatRunAction("review", run.runId, { decision: "accepted" }, options.childSafe)} or decision: "needs_changes".`);
-    if (view.continuations.length)
-        lines.push("Continuation history:", ...view.continuations.map((next) => `  ${next.predecessorRunId}:${next.predecessorIndex ?? 0} -> ${next.runId}`));
-    if (control.capabilities.includes("resume"))
-        lines.push(`Continue: ${formatRunAction("resume", run.runId, { ...(view.children.length > 1 ? { index: control.nextActions.find((action) => action.action === "resume")?.index ?? 0 } : {}), message: "..." }, options.childSafe)}`);
-    if (!options.full)
-        lines.push(`Full task/configuration: ${formatRunAction("status", run.runId, { full: true }, options.childSafe)}`);
-    return {
-        content: [{ type: "text", text: lines.join("\n") }],
-        details: { ...runtime?.details, mode: "management", results: [], run: view, managementControl: control },
-    };
-}
-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: ${String(error)}. Completion is unconfirmed.` };
-}
-export async function ownedRunList(state, params) {
-    const limit = params.limit ?? 20, sort = params.sort;
-    if (sort === "relevance")
-        throw new Error("Run list sort must be attention, newest, or oldest.");
-    const indexed = await (await runHistoryIndex(state, true)).listRuns({ ...params, sort });
-    // The index orders observations; only the bounded selected page gets authoritative controls.
-    const page = 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);
-        }
-    });
-    const owned = [...(state.ownedRuns?.values() ?? [])];
-    const runs = page.map(({ runId, source, mode, cwd, task, state: runState, updatedAt, attention, review, rootRunId, predecessorRunId, predecessorIndex, children }) => ({ runId, source, mode, cwd, task: compact(task, 2048), state: runState, updatedAt, attention, review, rootRunId, predecessorRunId, predecessorIndex, continuations: owned.filter((candidate) => candidate.predecessorRunId === runId).map((candidate) => candidate.runId), summary: compact(children.map((child) => child.result ? getSingleResultOutput(child.result) || child.result.error || "" : "").filter(Boolean).join(" | ")) }));
-    const controls = page.map(ownedRunControl);
-    const { offset, nextOffset, nextCursor, total, freshness, version } = indexed;
-    const next = nextCursor ? { action: "list", cursor: nextCursor, limit, ...(sort ? { sort } : {}), ...(params.agent ? { agent: params.agent } : {}), ...(params.state ? { state: params.state } : {}), ...(params.text ? { text: params.text } : {}) } : undefined;
-    return {
-        content: [{ type: "text", text: total ? [`Owned runs: ${total} (showing ${page.length ? `${offset + 1}–${offset + page.length}` : "none"}; ${params.sort ?? "attention"} order)`, ...(freshness.state !== "current" ? [`Browse index: ${freshness.state}; ordering/filter observations may be incomplete. Selected controls are checked against owner records.`] : []), ...runs.map((run) => `- ${run.runId} | ${run.state}${run.attention.length ? ` | ${run.attention.join(", ")}` : ""} | ${compact(run.task)}${run.summary ? ` | ${run.summary}` : ""} | Launch cwd: ${run.cwd}${run.predecessorRunId ? ` | from ${run.predecessorRunId}:${run.predecessorIndex ?? 0}` : ""}${run.continuations.length ? ` | continued as ${run.continuations.join(", ")} (separate results/reviews)` : ""}`), ...(next ? [`Next: agent_runs(${JSON.stringify(next)})`] : [])].join("\n") : "No delegated runs match in this owning session." }],
-        details: { mode: "management", results: [], runs, managementControls: controls, managementControl: controls.find((control) => control.state === "live"), runList: { total, offset, limit, version, freshness, ...(nextOffset !== undefined ? { nextOffset } : {}), ...(nextCursor ? { nextCursor } : {}) } },
-    };
-}
+// Public run-management surface. Persistence, recovery, projection and presentation
+// have separate owners so browsing never becomes evidence of completion.
+export { OWNED_RUN_ENTRY, repairOwnedRunAccounting, rememberOwnedRun, resolveOwnedRun, saveForegroundRun, } from "./run-persistence.js";
+export { workflowChildren } from "./workflow-graph.js";
+export { restoreOwnedRuns, restoreOwnedRunsAsync, } from "./run-restoration.js";
+export { ownedRunView } from "./owned-run-view.js";
+export { ownedRunExecutionResult, ownedRunProgressResult } from "./owned-run-results.js";
+export { ownedRunStatusResult } from "./owned-run-status.js";
+export { ownedRunList } from "./owned-run-list.js";