@fitchmultz/pi-subagents 0.49.1 → 0.51.0

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

@@ -1,202 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { compactForegroundResult, getSingleResultOutput } from "../../shared/utils.js";
-import { readAsyncResultFile } from "../background/async-result-file.js";
-import { exactAsyncRunLocation } from "../background/async-resume.js";
-import { getRunMetadataDir } from "./supervisor-questions.js";
-import { ASYNC_DIR, DEFAULT_MAX_OUTPUT, RESULTS_DIR, truncateOutput, } from "../../shared/types.js";
-import { repairOwnedRunAccounting } from "./run-persistence.js";
-import { ownedRunView } from "./owned-run-view.js";
-import { ownedRunProgressResult } from "./owned-run-progress.js";
-import { workflowDetails } from "./owned-workflow-details.js";
-export { ownedRunProgressResult } from "./owned-run-progress.js";
-function initialOutput(result, limits, artifactPath) {
-    const initial = result.initialOutput;
-    return initial !== undefined && initial !== ""
-        ? { initialOutput: truncateOutput(initial, limits, artifactPath).text }
-        : {};
-}
-function projectChild(child, limits) {
-    if (!child.result) {
-        return { ...child, result: undefined };
-    }
-    const { artifactPaths, ...result } = child.result;
-    const truncation = result.outputMode === "file-only" && result.exitCode === 0 && result.outputReference
-        ? { text: result.outputReference.message, truncated: false }
-        : truncateOutput(getSingleResultOutput(result), limits, artifactPaths?.outputPath);
-    const compacted = compactForegroundResult({
-        ...result,
-        finalOutput: truncation.text,
-        ...(truncation.truncated ? { truncation } : {}),
-        ...initialOutput(result, limits, artifactPaths?.outputPath),
-    });
-    return { ...child, result: { ...compacted, ...(artifactPaths ? { artifactPaths } : {}) } };
-}
-function publicResult(child) {
-    if (!child.result) {
-        return [];
-    }
-    const { artifactPaths, ...result } = child.result;
-    if (artifactPaths?.inputPath !== undefined &&
-        artifactPaths.inputPath !== "" &&
-        artifactPaths.outputPath !== undefined &&
-        artifactPaths.outputPath !== "" &&
-        artifactPaths.metadataPath !== undefined &&
-        artifactPaths.metadataPath !== "") {
-        return [
-            {
-                ...result,
-                artifactPaths: {
-                    inputPath: artifactPaths.inputPath,
-                    outputPath: artifactPaths.outputPath,
-                    metadataPath: artifactPaths.metadataPath,
-                },
-            },
-        ];
-    }
-    return [result];
-}
-function resultFailed(view, children, index) {
-    return index === undefined
-        ? ["failed", "unknown"].includes(view.state)
-        : children.length === 0 ||
-            children.some((child) => ["failed", "unknown"].includes(child.state));
-}
-function resultText(view, children, saved, index) {
-    const summary = index === undefined ? saved?.summary : undefined;
-    let text = summary !== undefined && summary !== ""
-        ? summary
-        : [
-            ...children.map((child) => {
-                if (!child.result) {
-                    return;
-                }
-                const output = getSingleResultOutput(child.result);
-                return output !== "" ? output : child.result.error;
-            }),
-            view.diagnosis,
-        ]
-            .filter((part) => part !== undefined && part !== "")
-            .join("\n\n");
-    const error = saved?.error;
-    if (resultFailed(view, children, index) &&
-        error !== undefined &&
-        error !== "" &&
-        !text.includes(error)) {
-        text = `${error}\n\n${text}`;
-    }
-    return text;
-}
-function outputArtifact(run, results, directory) {
-    if (run.mode === "single") {
-        return results[0]?.artifactPaths?.outputPath;
-    }
-    const logPath = path.join(directory, `subagent-log-${run.runId}.md`);
-    return fs.existsSync(logPath) ? logPath : undefined;
-}
-function summaryTruncation(view, results, output) {
-    const { text, limits } = output;
-    const only = results.length === 1 ? results[0] : undefined;
-    if (view.state === "completed" &&
-        view.mode === "single" &&
-        only?.outputMode === "file-only" &&
-        only.outputReference) {
-        return { text: only.outputReference.message, truncated: false };
-    }
-    if (view.state === "blocked") {
-        return { text, truncated: false };
-    }
-    const directory = view.asyncDir ?? getRunMetadataDir(view.runId);
-    return truncateOutput(text, limits, outputArtifact(view, results, directory));
-}
-function progressSummary(results, duration) {
-    return {
-        toolCount: results.reduce((total, result) => total + (result.progressSummary?.toolCount ?? 0), 0),
-        tokens: results.reduce((total, result) => total + (result.progressSummary?.tokens ?? 0), 0),
-        durationMs: duration ?? Math.max(0, ...results.map((result) => result.progressSummary?.durationMs ?? 0)),
-    };
-}
-function resultIdentity(run) {
-    return (run.predecessorRunId ?? "") !== ""
-        ? [
-            `Run: ${run.runId}\nPredecessor: ${run.predecessorRunId ?? ""} (child ${run.predecessorIndex ?? 0})`,
-        ]
-        : [];
-}
-function sharingText(saved) {
-    if (saved?.shareUrl !== undefined && saved.shareUrl !== "") {
-        return [`Session: ${saved.shareUrl}`];
-    }
-    return saved?.shareError !== undefined && saved.shareError !== ""
-        ? [`Session share error: ${saved.shareError}`]
-        : [];
-}
-function savedDetails(saved, results) {
-    if (!saved) {
-        return resultArtifacts(results);
-    }
-    return {
-        ...((saved.shareUrl ?? "") !== "" ? { shareUrl: saved.shareUrl } : {}),
-        ...((saved.gistUrl ?? "") !== "" ? { gistUrl: saved.gistUrl } : {}),
-        ...((saved.shareError ?? "") !== "" ? { shareError: saved.shareError } : {}),
-        ...(saved.outputs ? { outputs: saved.outputs } : {}),
-        ...workflowDetails(saved.workflowGraph),
-        ...resultArtifacts(results, saved.artifactsDir),
-    };
-}
-function resultArtifacts(results, directory) {
-    const files = results.flatMap((result) => (result.artifactPaths ? [result.artifactPaths] : []));
-    const first = files.at(0);
-    return first ? { artifacts: { dir: directory ?? path.dirname(first.outputPath), files } } : {};
-}
-function loadSavedResult(file) {
-    return file !== null && file !== "" ? readAsyncResultFile(file) : undefined;
-}
-function outputLimits(saved, view) {
-    return { ...DEFAULT_MAX_OUTPUT, ...(saved?.maxOutput ?? view.children.at(0)?.launch?.maxOutput) };
-}
-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 = loadSavedResult(location.resultPath);
-    const limits = outputLimits(saved, view);
-    const children = view.children.filter((child) => index === undefined || child.index === index);
-    const projected = view.children.map((child) => projectChild(child, limits));
-    const results = projected
-        .filter((child) => index === undefined || child.index === index)
-        .flatMap(publicResult);
-    const truncation = summaryTruncation({ ...view, asyncDir: location.asyncDir ?? view.asyncDir }, results, { text: resultText(view, children, saved, index), limits });
-    return {
-        content: [
-            {
-                type: "text",
-                text: [
-                    ...resultIdentity(run),
-                    truncation.text !== "" ? truncation.text : `Run ${run.runId}: ${view.state}.`,
-                    ...sharingText(saved),
-                ].join("\n\n"),
-            },
-        ],
-        ...(resultFailed(view, children, index) ? { isError: true } : {}),
-        details: {
-            mode: run.mode,
-            runId: run.runId,
-            asyncId: run.runId,
-            asyncDir: location.asyncDir ?? run.asyncDir,
-            results,
-            run: { ...view, children: projected },
-            progressSummary: progressSummary(results, saved?.durationMs),
-            ...(includeProgress
-                ? { progress: ownedRunProgressResult(run, state, index).details.progress }
-                : {}),
-            ...savedDetails(saved, results),
-            ...(truncation.truncated ? { truncation } : {}),
-        },
-    };
-}

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

@@ -1,180 +0,0 @@
-import * as fs from "node:fs";
-import { getSingleResultOutput } from "../../shared/utils.js";
-import { buildManagementControl, formatAgentProcessExit, formatRunAction, } from "../../shared/status-format.js";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { acceptanceHumanAction } from "./acceptance-evaluation.js";
-import { ownedRunView } from "./owned-run-view.js";
-export function compact(value, max = 180) {
-    const text = value.replace(/\s+/g, " ").trim();
-    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-export 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 !== true);
-    return buildManagementControl({
-        state: view.state,
-        runId: view.runId,
-        index: resumable?.index,
-        canReview: view.state !== "live",
-        canResume: resumable !== undefined,
-        canNudge: active !== undefined,
-        canInterrupt: view.canInterrupt,
-        intercomTarget: active
-            ? resolveSubagentIntercomTarget(view.runId, active.agent, active.index)
-            : undefined,
-    });
-}
-function reviewDescription(run, full) {
-    const message = run.review?.message;
-    const suffix = message !== undefined && message !== "" ? ` — ${full ? message : compact(message)}` : "";
-    return `Parent review (not sent to child): ${run.review?.decision ?? "unreviewed"}${suffix}`;
-}
-function notificationDescription(run) {
-    if (!run.delivery) {
-        return "Notification: not recorded";
-    }
-    return `Notification: recorded ${new Date(run.delivery.notifiedAt).toISOString()}; intercom ${run.delivery.intercomDelivered ? "delivered" : "not confirmed"}`;
-}
-function optionalLine(prefix, value) {
-    return value !== undefined && value !== "" ? [`${prefix}${value}`] : [];
-}
-function runDescription(run, view, full) {
-    return [
-        `Run: ${run.runId}`,
-        `State: ${view.state}`,
-        `Mode: ${run.mode} (${run.source})`,
-        `Task: ${full ? run.task : compact(run.task)}`,
-        `Launch cwd: ${run.cwd}`,
-        `Root: ${run.rootRunId}`,
-        ...((run.predecessorRunId ?? "") !== ""
-            ? [`Predecessor: ${run.predecessorRunId ?? ""} (child ${run.predecessorIndex ?? 0})`]
-            : []),
-        reviewDescription(run, full),
-        notificationDescription(run),
-        ...(view.attention.length > 0 ? [`Attention: ${view.attention.join(", ")}`] : []),
-        ...optionalLine("Result: ", view.resultPath),
-        ...optionalLine("", view.diagnosis),
-    ];
-}
-function fileDescription(label, file) {
-    if (file === undefined || file === "") {
-        return [];
-    }
-    return [`  ${label}: ${file}${fs.existsSync(file) ? "" : " (missing)"}`];
-}
-function childEvidence(child) {
-    const result = child.result;
-    const output = result ? getSingleResultOutput(result) : "";
-    const humanAction = acceptanceHumanAction(result?.acceptance);
-    return [
-        ...optionalLine("  Needs your action — acceptance incomplete:\n", humanAction),
-        ...(child.state !== "live" ? [`  ${formatAgentProcessExit(result?.agentProcessExit)}`] : []),
-        ...childOutputPaths(child),
-        ...(output !== "" ? [`  Result: ${compact(output, 600)}`] : []),
-        ...optionalLine("  Error: ", result?.error),
-    ];
-}
-function childOutputPaths(child) {
-    const result = child.result;
-    return [
-        ...optionalLine("  Child observations / uncommitted output: ", result?.auditPath),
-        ...optionalLine("  Full output: ", result?.fullOutputPath),
-        ...fileDescription("Artifact", result?.artifactPaths?.outputPath),
-        ...fileDescription("Result metadata (acceptance details when configured)", result?.artifactPaths?.metadataPath),
-    ];
-}
-function childConfiguration(child, full) {
-    const launch = child.launch;
-    if (!launch) {
-        return ["  Configuration: legacy-partial; original profile snapshot was not recorded."];
-    }
-    return [
-        `  Effective model: ${launch.model ?? "native default"}; thinking: ${launch.thinking ?? "native default"}`,
-        `  Output: ${launch.output === false || launch.output === "" ? "disabled" : launch.output} (${launch.outputMode}); configuration: saved launch snapshot`,
-        ...(full ? [`  Saved launch configuration:\n${JSON.stringify(launch, null, 2)}`] : []),
-    ];
-}
-function childSession(child) {
-    const file = child.sessionFile;
-    if (file === undefined || file === "") {
-        return [];
-    }
-    return [
-        `  Session: ${file}${child.missingSession === true ? " (missing; continuation unavailable)" : ""}`,
-    ];
-}
-function childAccounting(child) {
-    const accounting = child.result?.accounting;
-    return accounting?.state === "incomplete"
-        ? [
-            `  Accounting incomplete: ${accounting.error ?? "Native billing evidence is unavailable; no work was repeated."}`,
-        ]
-        : [];
-}
-function childDescription(child, full) {
-    const result = child.result;
-    return [
-        `Child ${child.index}: ${child.agent} | ${child.state}${result?.acceptance ? ` | validation: ${result.acceptance.status}` : ""}`,
-        ...childEvidence(child),
-        ...childSession(child),
-        ...childAccounting(child),
-        ...childConfiguration(child, full),
-    ];
-}
-function actionDescription(view, control, options) {
-    const resumeIndex = control.nextActions.find((action) => action.action === "resume")?.index ?? 0;
-    return [
-        ...(control.capabilities.includes("review")
-            ? [
-                `Review (parent-only, not sent to child): ${formatRunAction("review", view.runId, { decision: "accepted" }, options.childSafe)} or decision: "needs_changes".`,
-            ]
-            : []),
-        ...(view.continuations.length > 0
-            ? [
-                "Continuation history:",
-                ...view.continuations.map((next) => `  ${next.predecessorRunId}:${next.predecessorIndex ?? 0} -> ${next.runId}`),
-            ]
-            : []),
-        ...(control.capabilities.includes("resume")
-            ? [
-                `Continue: ${formatRunAction("resume", view.runId, { ...(view.children.length > 1 ? { index: resumeIndex } : {}), message: "..." }, options.childSafe)}`,
-            ]
-            : []),
-        ...(options.full !== true
-            ? [
-                `Full task/configuration: ${formatRunAction("status", view.runId, { full: true }, options.childSafe)}`,
-            ]
-            : []),
-    ];
-}
-function runtimeDescription(runtime, include) {
-    if (!runtime || runtime.isError === true || !include) {
-        return [];
-    }
-    return runtime.content.flatMap((part) => (part.type === "text" ? [part.text] : []));
-}
-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 runtimeText = runtimeDescription(runtime, run.source === "async" || liveControl !== undefined);
-    const lines = [
-        ...runDescription(run, view, options.full === true),
-        ...runtimeText,
-        ...view.children.flatMap((child) => childDescription(child, options.full === true)),
-        ...actionDescription(view, control, options),
-    ];
-    return {
-        content: [{ type: "text", text: lines.join("\n") }],
-        details: {
-            ...runtime?.details,
-            mode: "management",
-            results: [],
-            run: view,
-            managementControl: control,
-        },
-    };
-}

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

@@ -1,51 +0,0 @@
-import * as path from "node:path";
-import { listOwnedRunQuestions } from "./supervisor-questions.js";
-import { RunObservation } from "./owned-run-observation.js";
-function runAttention(run, state, pendingInput) {
-    return [
-        ...(pendingInput ? ["awaiting_input"] : []),
-        ...(run.review?.decision === "needs_changes" ? ["needs_changes"] : []),
-        ...(run.review?.decision !== "accepted" &&
-            ["failed", "blocked", "paused", "unknown"].includes(state)
-            ? [state]
-            : []),
-        ...(state === "completed" && !run.review ? ["unreviewed"] : []),
-    ];
-}
-function continuations(run, state) {
-    return [...(state.ownedRuns?.values() ?? [])]
-        .filter((candidate) => candidate.rootRunId === run.rootRunId)
-        .sort((a, b) => a.startedAt - b.startedAt)
-        .flatMap((candidate) => candidate.predecessorRunId !== undefined && candidate.predecessorRunId !== ""
-        ? [
-            {
-                runId: candidate.runId,
-                predecessorRunId: candidate.predecessorRunId,
-                predecessorIndex: candidate.predecessorIndex,
-            },
-        ]
-        : []);
-}
-export function ownedRunView(requestedRun, state, options = {}) {
-    const run = state.ownedRuns?.get(requestedRun.runId) ?? requestedRun;
-    const observed = new RunObservation(run, state, options);
-    const children = observed.indices.map((index) => observed.child(index));
-    const pendingInput = options.pendingInput ??
-        listOwnedRunQuestions(run.ownerSessionId, run.runId).some((question) => question.state === "awaiting_input" || question.state === "answer_pending");
-    const summary = observed.summary(children, pendingInput);
-    const resultPath = observed.result ? observed.resultPath : undefined;
-    return {
-        ...run,
-        state: summary.state,
-        children,
-        attention: runAttention(run, summary.state, pendingInput),
-        canInterrupt: summary.canInterrupt,
-        updatedAt: summary.updatedAt,
-        continuations: options.includeContinuations === false ? [] : continuations(run, state),
-        ...(resultPath !== undefined ? { resultPath } : {}),
-        ...(!observed.result && observed.foreground
-            ? { resultPath: path.join(observed.root, "foreground.json") }
-            : {}),
-        diagnosis: summary.diagnosis,
-    };
-}

package/dist/runs/shared/owned-workflow-details.js

@@ -1,17 +0,0 @@
-/** Saved graph facts shared by result and activity projections, never workflow execution. */
-export 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) === true);
-    return {
-        workflowGraph: graph,
-        chainAgents: graph.nodes.map((node) => node.agent ?? node.label),
-        totalSteps: graph.nodes.length,
-        ...(current?.stepIndex !== undefined ? { currentStepIndex: current.stepIndex } : {}),
-    };
-}

package/dist/runs/shared/owner-output.js

@@ -1,43 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getRunMetadataDir, QUESTIONS_DIR } from "./run-metadata-paths.js";
-function writeOwnedOutput(slot, text, initial) {
-    const name = initial ? `${slot.index}.initial.txt` : `${slot.index}.txt`;
-    const file = path.join(getRunMetadataDir(slot.runId, slot.root), "outputs", name);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, text, { mode: 0o600 });
-    return file;
-}
-function terminalOutputPath(result, slot) {
-    const output = result.finalOutput ?? result.output;
-    let file = result.fullOutputPath;
-    if (output === undefined || output.length <= 8192) {
-        return file;
-    }
-    file ??= result.artifactPaths?.outputPath;
-    return file === undefined || file === "" ? writeOwnedOutput(slot, output, false) : file;
-}
-function initialOutputPath(result, slot) {
-    const output = result.initialOutput;
-    const file = result.initialOutputPath;
-    if (output === undefined || output.length <= 8192) {
-        return file;
-    }
-    return file === undefined || file === "" ? writeOwnedOutput(slot, output, true) : file;
-}
-export function compactOwnerResult(runId, index, result, root = QUESTIONS_DIR) {
-    const slot = { runId, index, root };
-    const fullOutputPath = terminalOutputPath(result, slot);
-    const initialPath = initialOutputPath(result, slot);
-    return {
-        ...result,
-        messages: undefined,
-        ...((fullOutputPath ?? "") !== "" ? { fullOutputPath } : {}),
-        ...((initialPath ?? "") !== "" ? { initialOutputPath: initialPath } : {}),
-        ...(result.finalOutput !== undefined ? { finalOutput: result.finalOutput.slice(-8192) } : {}),
-        ...(result.output !== undefined ? { output: result.output.slice(-8192) } : {}),
-        ...(result.initialOutput !== undefined
-            ? { initialOutput: result.initialOutput.slice(-8192) }
-            : {}),
-    };
-}

package/dist/runs/shared/parallel-utils.js

@@ -1,49 +0,0 @@
-export function isParallelGroup(step) {
-    return "parallel" in step && Array.isArray(step.parallel);
-}
-export function isDynamicRunnerGroup(step) {
-    return ("expand" in step && "collect" in step && "parallel" in step && !Array.isArray(step.parallel));
-}
-export function flattenSteps(steps) {
-    const flat = [];
-    for (const step of steps) {
-        if (isParallelGroup(step)) {
-            for (const task of step.parallel) {
-                flat.push(task);
-            }
-        }
-        else if (isDynamicRunnerGroup(step)) {
-            continue;
-        }
-        else {
-            flat.push(step);
-        }
-    }
-    return flat;
-}
-function parallelResultStatus(result, hasOutput) {
-    const error = result.error ?? "";
-    if (error.length > 0) {
-        return `WARNING: ${error}`;
-    }
-    return hasOutput ? "" : "EMPTY OUTPUT (no textual response returned)";
-}
-export function aggregateParallelOutputs(results, headerFormat = (i, agent) => `=== Parallel Task ${i + 1} (${agent}) ===`) {
-    return results
-        .map((result, index) => {
-        const header = headerFormat(result.taskIndex ?? index, result.agent);
-        const hasOutput = result.output.trim().length > 0;
-        const status = parallelResultStatus(result, hasOutput);
-        let body = result.output;
-        if (status.length > 0) {
-            body = hasOutput ? `${status}\n${result.output}` : status;
-        }
-        return `${header}\n${body}`;
-    })
-        .join("\n\n");
-}
-export const FAIL_FAST_REASON = "subagent-fail-fast";
-export function isFailFastAbort(signal) {
-    return signal?.aborted === true && signal.reason === FAIL_FAST_REASON;
-}
-export const MAX_PARALLEL_CONCURRENCY = 4;

package/dist/runs/shared/parent-receipts.js

@@ -1,126 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import { journalStamp, scanJournal, } from "../../shared/journal-reader.js";
-import { isRecord as isObject } from "../../shared/unknown.js";
-import { nonempty } from "./child-presence.js";
-import { observedUsage, optionalString, requiredString } from "./child-message-validation.js";
-function hashRange(fd, start, end, hash) {
-    const bytes = Buffer.allocUnsafe(64 * 1024);
-    let position = start;
-    while (position < end) {
-        const count = fs.readSync(fd, bytes, 0, Math.min(bytes.length, end - position), position);
-        if (count === 0) {
-            throw new Error("Parent journal truncated during inspection");
-        }
-        hash.update(bytes.subarray(0, count));
-        position += count;
-    }
-}
-const receiptProjection = (keys) => {
-    if (keys.length === 0 || ["type", "id", "timestamp", "customType"].includes(String(keys[0]))) {
-        return true;
-    }
-    if (keys[0] === "details") {
-        return projectedReceiptDetails(keys);
-    }
-    if (keys[0] === "message") {
-        return projectedReceiptMessage(keys);
-    }
-    return false;
-};
-function projectedReceiptDetails(keys) {
-    return (keys.length === 1 ||
-        (["completion", "subagentCompletion", "result"].includes(String(keys[1])) &&
-            (keys[1] !== "result" || keys.length <= 3 || keys[3] === "wait")));
-}
-function projectedReceiptMessage(keys) {
-    return (keys.length === 1 ||
-        ["role", "toolName", "usage"].includes(String(keys[1])) ||
-        (keys[1] === "details" &&
-            (keys.length === 2 || ["wait", "parentUsage"].includes(String(keys[2])))));
-}
-function parseReceipt(value) {
-    if (value.type === "custom_message") {
-        return {
-            ...value,
-            type: "custom_message",
-            id: requiredString(value.id, "receipt ID"),
-            timestamp: optionalString(value.timestamp, "timestamp"),
-            customType: optionalString(value.customType, "customType"),
-        };
-    }
-    if (value.type !== "message" || !isObject(value.message) || value.message.role !== "toolResult") {
-        return;
-    }
-    return {
-        ...value,
-        type: "message",
-        id: requiredString(value.id, "receipt ID"),
-        timestamp: optionalString(value.timestamp, "timestamp"),
-        message: {
-            ...value.message,
-            role: "toolResult",
-            toolName: requiredString(value.message.toolName, "toolName"),
-            usage: observedUsage(value.message.usage),
-        },
-    };
-}
-function verifiedPrefix(fd, location, cache) {
-    const hash = createHash("sha256");
-    if (!cache ||
-        cache.file !== location.file ||
-        cache.identity !== location.identity ||
-        location.size < cache.end) {
-        return { hash };
-    }
-    // Coarse timestamps can hide same-size edits; stat hits still require verified bytes.
-    hashRange(fd, 0, cache.end, hash);
-    return hash.copy().digest("hex") === cache.digest
-        ? { hash, previous: cache }
-        : { hash: createHash("sha256") };
-}
-/** Cache only LF-published receipt fields, never transcripts or accepted-but-unsaved messages. */
-export function createParentReceiptReader(policy) {
-    let cache;
-    return {
-        clear() {
-            cache = undefined;
-        },
-        read(file) {
-            if (!nonempty(file) || !fs.existsSync(file)) {
-                cache = undefined;
-                return new Map();
-            }
-            const fd = fs.openSync(file, "r");
-            try {
-                const stat = fs.fstatSync(fd, { bigint: true });
-                const stamp = journalStamp(stat);
-                const identity = `${stat.dev}:${stat.ino}`;
-                const { hash, previous } = verifiedPrefix(fd, { file, identity, size: Number(stat.size) }, cache);
-                if (previous && Number(stat.size) === previous.end) {
-                    if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== stamp) {
-                        throw new Error("Parent journal changed during inspection");
-                    }
-                    return previous.records;
-                }
-                const start = previous?.end ?? 0;
-                const records = new Map(previous?.records);
-                const end = scanJournal(fd, receiptProjection, ({ value }) => {
-                    const receipt = parseReceipt(value);
-                    if (receipt) {
-                        records.set(receipt.id, receipt);
-                    }
-                }, { policy, requireNewline: true, start, end: Number(stat.size) });
-                hashRange(fd, start, end, hash);
-                if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== stamp) {
-                    throw new Error("Parent journal changed during inspection");
-                }
-                cache = { file, identity, end, digest: hash.digest("hex"), records };
-                return records;
-            }
-            finally {
-                fs.closeSync(fd);
-            }
-        },
-    };
-}