@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/runs/shared/run-history-queries.js

@@ -1,136 +0,0 @@
-import { runHistoryIndex } from "./history-index.js";
-import { ownedRunView, resolveOwnedRun } from "./run-records.js";
-function selectHistoryChild(view, index) {
-    const child = index === undefined && view.children.length === 1
-        ? view.children[0]
-        : view.children.find((entry) => entry.index === index);
-    if (!child) {
-        throw new Error("Choose index for a run with multiple children.");
-    }
-    return child;
-}
-function historyInput(view, child, params, signal) {
-    return {
-        runId: view.runId,
-        index: child.index,
-        limit: params.limit,
-        before: params.before,
-        cursor: params.cursor,
-        signal,
-        ...(child.state !== "live"
-            ? {
-                terminalEntryId: child.result?.terminalEntryId,
-                endedAt: (child.result?.terminalEntryId ?? "") !== "" ? undefined : view.updatedAt,
-            }
-            : {}),
-    };
-}
-function historyResult(view, child, page, limit) {
-    const earlier = (page.previousCursor ?? "") !== ""
-        ? {
-            action: "history",
-            id: view.runId,
-            index: child.index,
-            limit: limit ?? 100,
-            cursor: page.previousCursor,
-        }
-        : undefined;
-    const source = child.sessionFile;
-    return {
-        content: [
-            {
-                type: "text",
-                text: [
-                    `History: ${view.runId}, child ${child.index} (${child.agent}); ${page.entries.length} of ${page.count} indexed native entries.`,
-                    `Browse index: ${page.freshness.state}. These are bounded previews, not completion or delivery receipts.`,
-                    ...((page.unavailable ?? "") !== "" ? [page.unavailable] : []),
-                    ...page.entries.map((entry) => `- ${entry.id} · position ${entry.sequence}\n${JSON.stringify(entry.entry)}`),
-                    ...(earlier ? [`Earlier: agent_runs(${JSON.stringify(earlier)})`] : []),
-                    ...(source !== undefined && source !== ""
-                        ? [
-                            `Native source: ${source}. Open a selected record in Agents for validated full details.`,
-                        ]
-                        : []),
-                ].join("\n"),
-            },
-        ],
-        details: { mode: "management", results: [], runId: view.runId, history: page },
-    };
-}
-function searchInput(params, run, signal) {
-    if (params.query === undefined || params.query === "") {
-        throw new Error("Search requires query.");
-    }
-    if (params.sort !== undefined && !["relevance", "newest"].includes(params.sort)) {
-        throw new Error("Search sort must be relevance or newest.");
-    }
-    return {
-        query: params.query,
-        runId: run?.runId,
-        index: params.index,
-        limit: params.limit,
-        cursor: params.cursor,
-        sort: params.sort === "relevance" || params.sort === "newest" ? params.sort : undefined,
-        agent: params.agent,
-        signal,
-    };
-}
-function searchContinuation(input, page) {
-    if ((page.nextCursor ?? "") === "") {
-        return [];
-    }
-    const next = {
-        action: "search",
-        query: input.query,
-        ...(input.runId !== undefined ? { id: input.runId } : {}),
-        ...(input.index !== undefined ? { index: input.index } : {}),
-        ...((input.agent ?? "") !== "" ? { agent: input.agent } : {}),
-        ...(input.sort !== undefined ? { sort: input.sort } : {}),
-        limit: input.limit ?? 20,
-        cursor: page.nextCursor,
-    };
-    return [`Next: agent_runs(${JSON.stringify(next)})`];
-}
-async function searchHistory(index, input) {
-    const page = await index.search(input);
-    return {
-        content: [
-            {
-                type: "text",
-                text: [
-                    `Saved-text search: ${page.matches.length} matches in this owning session; index ${page.freshness.state}.`,
-                    "Indexed excerpts may be stale. They do not establish completion, ownership, or delivery; full selected records are validated separately.",
-                    ...page.matches.map((match) => `- ${match.runId}:${match.index} (${match.agent}) · entry ${match.entryId}\n${match.preview}\n${match.sessionFile}:${match.ref.start}`),
-                    ...searchContinuation(input, page),
-                ].join("\n"),
-            },
-        ],
-        details: { mode: "management", results: [], historySearch: page },
-    };
-}
-/** Browse observations never confer ownership or replace canonical control/receipt checks. */
-export async function ownedHistoryQuery(state, params, signal) {
-    const requested = params.id ?? params.runId;
-    const run = requested !== undefined && requested !== "" ? resolveOwnedRun(state, requested) : undefined;
-    if (requested !== undefined && requested !== "" && !run) {
-        throw new Error("Run not found in this owning session.");
-    }
-    const index = await runHistoryIndex(state, true);
-    if (params.action !== "history") {
-        if (params.action !== "search") {
-            throw new Error("Search requires query.");
-        }
-        return searchHistory(index, searchInput(params, run, signal));
-    }
-    if (!run) {
-        throw new Error("History requires an owned run ID.");
-    }
-    const view = ownedRunView(run, state, {
-        includeContinuations: false,
-        readConfiguration: false,
-        reconcile: false,
-    });
-    const child = selectHistoryChild(view, params.index);
-    const page = await index.historyPage(historyInput(view, child, params, signal));
-    return historyResult(view, child, page, params.limit);
-}

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

@@ -1,176 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { historyDirectory, historyTransaction, openHistoryDatabase, } from "../../history/database.js";
-import { isRecord } from "../../shared/unknown.js";
-import { getAgentDir } from "../../shared/agent-dir.js";
-const MAX_AGENT_SAMPLES = 1000;
-const MAX_LEGACY_BYTES = 1024 * 1024;
-const TIMING_DATABASE = "run-timing.sqlite";
-function validIdentity(entry) {
-    return (typeof entry.agent === "string" &&
-        entry.agent.length > 0 &&
-        entry.agent.length <= 256 &&
-        typeof entry.task === "string");
-}
-function validTiming(entry) {
-    return (typeof entry.ts === "number" &&
-        Number.isSafeInteger(entry.ts) &&
-        entry.ts >= 0 &&
-        typeof entry.duration === "number" &&
-        Number.isFinite(entry.duration) &&
-        entry.duration >= 0);
-}
-function validEntry(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    return (validIdentity(value) &&
-        validTiming(value) &&
-        (value.status === "ok" || value.status === "error") &&
-        (value.exit === undefined ||
-            (typeof value.exit === "number" && Number.isSafeInteger(value.exit))));
-}
-/** Legacy samples are read-only, complete LF records from a bounded tail. */
-function legacySamples(agentDir, agent) {
-    let fd;
-    try {
-        fd = fs.openSync(path.join(agentDir, "run-history.jsonl"), "r");
-        const size = fs.fstatSync(fd).size, start = Math.max(0, size - MAX_LEGACY_BYTES);
-        const bytes = Buffer.alloc(size - start);
-        let count = 0;
-        while (count < bytes.length) {
-            const read = fs.readSync(fd, bytes, count, bytes.length - count, start + count);
-            if (read === 0) {
-                break;
-            }
-            count += read;
-        }
-        const complete = bytes.subarray(0, count), first = start > 0 ? complete.indexOf(10) + 1 : 0, last = complete.lastIndexOf(10);
-        if (last < first || (start > 0 && first === 0)) {
-            return [];
-        }
-        return parseLegacyLines(complete.subarray(first, last).toString("utf8").split("\n").reverse(), agent);
-    }
-    catch {
-        return [];
-    }
-    finally {
-        if (fd !== undefined) {
-            fs.closeSync(fd);
-        }
-    }
-}
-function parseLegacySample(line, agent) {
-    try {
-        const entry = JSON.parse(line);
-        if (!validEntry(entry) || (agent !== undefined && entry.agent !== agent)) {
-            return;
-        }
-        return entry;
-    }
-    catch {
-        // Invalid timing samples are not evidence; valid neighboring LF records survive.
-        return;
-    }
-}
-function parseLegacyLines(lines, agent) {
-    const samples = [];
-    const retained = new Map();
-    for (const line of lines) {
-        const entry = parseLegacySample(line, agent);
-        if (!entry || (retained.get(entry.agent) ?? 0) >= MAX_AGENT_SAMPLES) {
-            continue;
-        }
-        samples.push({ ...entry, task: entry.task.slice(0, 200) });
-        retained.set(entry.agent, (retained.get(entry.agent) ?? 0) + 1);
-        if (agent !== undefined && samples.length === MAX_AGENT_SAMPLES) {
-            break;
-        }
-    }
-    return samples;
-}
-export function recordRun(agent, task, exitCode, durationMs) {
-    const entry = {
-        agent,
-        task: task.slice(0, 200),
-        ts: Math.floor(Date.now() / 1000),
-        status: exitCode === 0 ? "ok" : "error",
-        duration: durationMs,
-        ...(exitCode !== 0 ? { exit: exitCode } : {}),
-    };
-    if (!validIdentity({ ...entry }) ||
-        !validTiming({ ...entry }) ||
-        !Number.isSafeInteger(exitCode)) {
-        return;
-    }
-    let db;
-    try {
-        const agentDir = getAgentDir();
-        fs.mkdirSync(agentDir, { recursive: true });
-        db = openHistoryDatabase(path.join(historyDirectory(agentDir), TIMING_DATABASE));
-        const connection = db;
-        const imported = connection
-            .prepare("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='timing_meta'")
-            .get() !== undefined &&
-            connection.prepare("SELECT key FROM timing_meta WHERE key='legacy-imported'").get() !==
-                undefined;
-        // Filesystem reads and JSON parsing must not consume another writer's admission budget.
-        const legacy = imported ? [] : legacySamples(agentDir).reverse();
-        // Allow brief native writer overlap; three attempts still bound best-effort admission.
-        connection.exec("PRAGMA busy_timeout=1000");
-        historyTransaction(connection, () => {
-            connection.exec(`CREATE TABLE IF NOT EXISTS timing_meta(key TEXT PRIMARY KEY);
-				CREATE TABLE IF NOT EXISTS samples(sequence INTEGER PRIMARY KEY,agent TEXT NOT NULL,task TEXT NOT NULL,ts INTEGER NOT NULL,status TEXT NOT NULL,duration REAL NOT NULL,exit INTEGER);
-				CREATE INDEX IF NOT EXISTS samples_agent ON samples(agent,sequence DESC);`);
-            const insert = connection.prepare("INSERT INTO samples(agent,task,ts,status,duration,exit) VALUES (?,?,?,?,?,?)");
-            const save = (sample) => insert.run(sample.agent, sample.task, sample.ts, sample.status, sample.duration, sample.exit ?? null);
-            if (!connection.prepare("SELECT key FROM timing_meta WHERE key='legacy-imported'").get()) {
-                // Another writer may have imported while this snapshot was being read.
-                for (const sample of legacy) {
-                    save(sample);
-                }
-                connection.exec("INSERT INTO timing_meta VALUES ('legacy-imported')");
-            }
-            save(entry);
-            connection
-                .prepare("DELETE FROM samples WHERE agent=? AND sequence NOT IN (SELECT sequence FROM samples WHERE agent=? ORDER BY sequence DESC LIMIT ?)")
-                .run(agent, agent, MAX_AGENT_SAMPLES);
-        });
-    }
-    catch {
-        /* Best-effort timing metadata must never interrupt a run. */
-    }
-    finally {
-        db?.close();
-    }
-}
-export function loadRunsForAgent(agent) {
-    const agentDir = getAgentDir(), file = path.join(agentDir, "history-index", TIMING_DATABASE);
-    if (!fs.existsSync(file)) {
-        return legacySamples(agentDir, agent);
-    }
-    let db;
-    try {
-        db = openHistoryDatabase(path.join(historyDirectory(agentDir, false), TIMING_DATABASE), true);
-        return db
-            .prepare("SELECT agent,task,ts,status,duration,exit FROM samples WHERE agent=? ORDER BY sequence DESC LIMIT ?")
-            .all(agent, MAX_AGENT_SAMPLES)
-            .flatMap((row) => {
-            const entry = {
-                agent: row.agent,
-                task: row.task,
-                ts: row.ts,
-                status: row.status,
-                duration: row.duration,
-                ...(row.exit === null ? {} : { exit: row.exit }),
-            };
-            return validEntry(entry) ? [entry] : [];
-        });
-    }
-    catch {
-        return [];
-    }
-    finally {
-        db?.close();
-    }
-}

package/dist/runs/shared/run-id-ambiguity.js

@@ -1,4 +0,0 @@
-export function formatRunIdAmbiguity(kind, prefix, candidates) {
-    const preview = candidates.slice(0, 5);
-    return `Ambiguous ${kind} run id prefix '${prefix}' matched: ${preview.join(", ")}. ${candidates.length} matches (showing ${preview.length}). Provide a longer prefix or full run id.`;
-}

package/dist/runs/shared/run-metadata-paths.js

@@ -1,14 +0,0 @@
-import * as path from "node:path";
-import { getAgentDir } from "../../shared/agent-dir.js";
-import { TEMP_ROOT_DIR } from "../../shared/types.js";
-export const LEGACY_QUESTIONS_DIR = path.join(TEMP_ROOT_DIR, "supervisor-questions");
-export const QUESTIONS_DIR = path.join(getAgentDir(), "sessions", "subagent-runs");
-export function safeId(value) {
-    if (typeof value !== "string" || !/^[a-zA-Z0-9_-]+$/.test(value)) {
-        throw new Error("Invalid run or question ID.");
-    }
-    return value;
-}
-export function getRunMetadataDir(runId, root = QUESTIONS_DIR) {
-    return path.join(root, safeId(runId));
-}

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

@@ -1,158 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { randomUUID } from "node:crypto";
-import { parseAsyncResult, parseSupervisorRunContract } from "../background/run-schemas.js";
-import { hasErrorCode, isRecord } from "../../shared/unknown.js";
-import { writeAtomicJson } from "../../shared/atomic-json.js";
-import { NativeJournal, ownerProjection, readJsonProjection } from "../../shared/journal-reader.js";
-import { runSynchronously } from "../../shared/cooperative.js";
-import { getRunMetadataDir, safeId, QUESTIONS_DIR, LEGACY_QUESTIONS_DIR, } from "./run-metadata-paths.js";
-export { getRunMetadataDir, safeId, QUESTIONS_DIR, LEGACY_QUESTIONS_DIR, } from "./run-metadata-paths.js";
-import { compactOwnerResult } from "./owner-output.js";
-export { compactOwnerResult } from "./owner-output.js";
-function conflictingCompletion(previous, incoming) {
-    return (previous !== undefined &&
-        previous !== "" &&
-        incoming !== undefined &&
-        incoming !== "" &&
-        previous !== incoming);
-}
-export function saveAsyncRunResult(runId, result) {
-    const file = path.join(getRunMetadataDir(runId), "result.json");
-    const previous = readRunJson(file, parseAsyncResult);
-    if (conflictingCompletion(previous?.completionId, result.completionId)) {
-        throw new Error("Conflicting completion identity");
-    }
-    const saved = {
-        ...result,
-        recordVersion: 3,
-        completionId: previous?.completionId ?? result.completionId ?? randomUUID(),
-        ...(preserveLegacyOwner(file, previous) ? { legacySource: `${file}.legacy` } : {}),
-        results: result.results?.map((child, index) => compactOwnerResult(runId, index, child)),
-    };
-    writeAtomicJson(file, saved);
-    return saved;
-}
-function preserveLegacyOwner(file, previous) {
-    if (!previous || previous.recordVersion === 3) {
-        return false;
-    }
-    try {
-        fs.copyFileSync(file, `${file}.legacy`, fs.constants.COPYFILE_EXCL);
-    }
-    catch (error) {
-        if (!hasErrorCode(error, "EEXIST")) {
-            throw error;
-        }
-    }
-    return true;
-}
-export function saveRunStatus(runId, status) {
-    writeAtomicJson(path.join(getRunMetadataDir(runId), "status.json"), status);
-}
-export function readRunJson(file, project) {
-    try {
-        const value = readJsonProjection(file, ownerProjection);
-        return project === undefined ? value : project(value);
-    }
-    catch (error) {
-        if (hasErrorCode(error, "ENOENT")) {
-            return;
-        }
-        throw error;
-    }
-}
-export function readQuestionOwner(runId, root = QUESTIONS_DIR) {
-    const value = readRunJson(path.join(getRunMetadataDir(runId, root), "question-owner.json"));
-    return isRecord(value) && typeof value.sessionId === "string"
-        ? { sessionId: value.sessionId }
-        : undefined;
-}
-export function saveQuestionOwner(runId, sessionId, root = QUESTIONS_DIR) {
-    writeAtomicJson(path.join(root, safeId(runId), "question-owner.json"), { sessionId });
-}
-function preservedAttemptBaseline(previous, incoming) {
-    return previous?.attemptBaseline && incoming.baselineSource !== "native-migration"
-        ? { attemptBaseline: previous.attemptBaseline }
-        : {};
-}
-export function saveQuestionContract(runId, index, contract, root = QUESTIONS_DIR) {
-    if (!Number.isSafeInteger(index) || index < 0) {
-        throw new Error("Child index must be a non-negative integer.");
-    }
-    const file = path.join(root, safeId(runId), "contracts", `${index}.json`);
-    const previous = readRunJson(file, parseSupervisorRunContract);
-    writeAtomicJson(file, {
-        ...previous,
-        ...contract,
-        recordVersion: 3,
-        ...(preserveLegacyOwner(file, previous) ? { legacySource: `${file}.legacy` } : {}),
-        ...preservedAttemptBaseline(previous, contract),
-        ...(contract.result ? { result: compactOwnerResult(runId, index, contract.result, root) } : {}),
-        ...(previous?.launch ? { launch: previous.launch } : {}),
-    });
-}
-function nativeConfigurationAllowed(contract) {
-    return (contract.recordVersion !== 3 &&
-        !contract.effectiveConfiguration &&
-        contract.launch?.model?.startsWith("claude-code/") !== true);
-}
-function recoverNativeConfiguration(contract, sessionFile, endedAt) {
-    if (!nativeConfigurationAllowed(contract)) {
-        return;
-    }
-    if (sessionFile === undefined || sessionFile === "" || !fs.existsSync(sessionFile)) {
-        return;
-    }
-    const journal = new NativeJournal(sessionFile, "inspect", true);
-    return { effectiveConfiguration: journal.configuration(endedAt, contract.terminalLeafId) };
-}
-function withNativeConfiguration(contract, launch, effectiveConfiguration) {
-    const native = effectiveConfiguration ?? {};
-    return { ...contract, effectiveConfiguration, launch: { ...launch, ...native } };
-}
-export function readQuestionContract(runId, index, root = QUESTIONS_DIR, projection = {}) {
-    const contract = readRunJson(path.join(root, safeId(runId), "contracts", `${index}.json`), parseSupervisorRunContract);
-    if (!contract?.launch || projection.readConfiguration === false) {
-        return contract;
-    }
-    const sessionFile = projection.sessionFile ?? contract.sessionFile;
-    // Read native selection once, without rewriting the frozen requested launch.
-    const recovery = recoverNativeConfiguration(contract, sessionFile, projection.endedAt);
-    if (recovery) {
-        saveQuestionContract(runId, index, recovery, root);
-    }
-    const effectiveConfiguration = recovery?.effectiveConfiguration ?? contract.effectiveConfiguration;
-    return withNativeConfiguration(contract, contract.launch, effectiveConfiguration);
-}
-export function migrateSupervisorQuestions(ownerSessionId, runId) {
-    runSynchronously(migrateSupervisorQuestionSteps(ownerSessionId, runId));
-}
-export function* migrateSupervisorQuestionSteps(ownerSessionId, runId) {
-    if (!fs.existsSync(LEGACY_QUESTIONS_DIR)) {
-        return;
-    }
-    const runs = runId === undefined
-        ? fs
-            .readdirSync(LEGACY_QUESTIONS_DIR, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name)
-        : [safeId(runId)];
-    for (const id of runs) {
-        yield;
-        try {
-            const source = getRunMetadataDir(id, LEGACY_QUESTIONS_DIR);
-            const owner = readQuestionOwner(id, LEGACY_QUESTIONS_DIR);
-            if (owner?.sessionId !== ownerSessionId) {
-                continue;
-            }
-            fs.cpSync(source, getRunMetadataDir(id), { recursive: true, force: false });
-        }
-        catch (error) {
-            if (runId !== undefined) {
-                throw error;
-            }
-            console.error(`Could not recover legacy questions for ${id}:`, error);
-        }
-    }
-}

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

@@ -1,131 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { journalStamp } from "../../shared/journal-reader.js";
-import { readNativeUsage } from "./native-usage.js";
-import { updateRunHistory } from "./history-index.js";
-import { writeAtomicJson } from "../../shared/atomic-json.js";
-import { compactForegroundResult, getSingleResultOutput } from "../../shared/utils.js";
-import { resolveSubagentResultStatus } from "../../intercom/result-intercom.js";
-import { readAsyncResultFile } from "../background/async-result-file.js";
-import { formatRunIdAmbiguity } from "./run-id-ambiguity.js";
-import { compactOwnerResult, getRunMetadataDir, readQuestionContract, saveAsyncRunResult, saveQuestionContract, } from "./supervisor-questions.js";
-import { setOwnedRun } from "./run-state-owner.js";
-export const OWNED_RUN_ENTRY = "subagent-run";
-const failedAccountingSources = new Map();
-function accountingSource(run, index, child) {
-    const contract = readQuestionContract(run.runId, index, undefined, { readConfiguration: false });
-    if (!contract?.attemptBaseline) {
-        return undefined;
-    }
-    const terminalEntryId = child.terminalEntryId ?? contract.terminalEntryId ?? "";
-    const source = child.sessionFile ?? contract.sessionFile ?? "";
-    if (terminalEntryId === "" || source === "") {
-        return undefined;
-    }
-    const stat = fs.statSync(source, { bigint: true, throwIfNoEntry: false });
-    return {
-        key: `${run.runId}:${index}`,
-        stamp: `${stat ? journalStamp(stat) : "missing"}:${terminalEntryId}:${JSON.stringify(contract.attemptBaseline)}`,
-        source,
-        terminalEntryId,
-        baseline: contract.attemptBaseline,
-    };
-}
-function repairChildAccounting(run, index, child) {
-    if (child.accounting?.state !== "incomplete") {
-        return child;
-    }
-    const evidence = accountingSource(run, index, child);
-    if (!evidence || failedAccountingSources.get(evidence.key) === evidence.stamp) {
-        return child;
-    }
-    let usage;
-    try {
-        usage = readNativeUsage(evidence.source, new Set(evidence.baseline), [], {
-            terminalEntryId: evidence.terminalEntryId,
-        })?.[0];
-    }
-    catch (error) {
-        failedAccountingSources.set(evidence.key, evidence.stamp);
-        throw error;
-    }
-    if (!usage) {
-        return child;
-    }
-    failedAccountingSources.delete(evidence.key);
-    const repaired = { ...child, usage, accounting: { state: "complete" } };
-    const contract = readQuestionContract(run.runId, index, undefined, { readConfiguration: false });
-    if (contract?.result) {
-        saveQuestionContract(run.runId, index, {
-            accounting: repaired.accounting,
-            result: { ...contract.result, usage, accounting: repaired.accounting },
-        });
-    }
-    return repaired;
-}
-/** 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);
-    const children = saved.results ?? [];
-    const results = children.map((child, index) => repairChildAccounting(run, index, child));
-    if (results.some((child, index) => child !== children[index])) {
-        saveAsyncRunResult(run.runId, { ...saved, results });
-    }
-}
-export function rememberOwnedRun(state, run) {
-    const previous = setOwnedRun(state, 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 !== true
-                ? {
-                    summary: (getSingleResultOutput(result) === ""
-                        ? result.error
-                        : getSingleResultOutput(result))?.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;
-}

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

@@ -1,9 +0,0 @@
-// 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";