clinkx 0.3.0 → 1.0.0

package/clinkx-workflows/dist/dashboard/lazy-content.js

@@ -0,0 +1,748 @@
+import { createHash, randomBytes } from "node:crypto";
+import { z } from "zod";
+import { ContainedFileTooLargeError, containedFileFingerprintsEqual, readContainedRelativeFile, } from "../contained-file.js";
+import { validateRunId } from "../run-id.js";
+import { isPlanReviewRunState } from "../plan-review/admission.js";
+import { IdSchema } from "../schema.js";
+import { MAX_RESULT_ENVELOPE_BYTES, } from "../plan-review/contract.js";
+import { PLAN_REVIEW_RESULT_RELPATH, validatePlanReviewPublicationBytes, } from "../plan-review/publication.js";
+import { extractCouncilPlanReviewCard } from "../run-summary/cards/council-plan-review.js";
+import { createValidatorRegistry, } from "../validators/index.js";
+import { DashboardWorkflowInputSchema, MAX_DASHBOARD_ID_CHARS, MAX_DASHBOARD_STAGE_CALL_RECORDS, } from "./contracts.js";
+import { createDashboardRunReader, } from "./read-model.js";
+export const DASHBOARD_WORKFLOW_SNAPSHOT_MAX_BYTES = 2 * 1_024 * 1_024;
+export const DASHBOARD_WORKFLOW_INPUT_MAX_BYTES = 1 * 1_024 * 1_024;
+export const DASHBOARD_LAZY_CONTENT_MAX_BYTES = 2 * 1_024 * 1_024;
+export const MAX_DASHBOARD_CONTEXT_FROM_REFERENCES = 2_000;
+export const MAX_DASHBOARD_CONTEXT_FROM_REFERENCE_CHARS = MAX_DASHBOARD_ID_CHARS * 2 + 1;
+const SnapshotIdSchema = IdSchema.max(MAX_DASHBOARD_ID_CHARS);
+const DashboardSnapshotCallSchema = z.object({
+    id: SnapshotIdSchema,
+    cli_name: SnapshotIdSchema,
+    role: SnapshotIdSchema,
+    validator_schema_id: z.string().min(1).max(256).optional(),
+    context_from: z.array(z.string().min(1).max(MAX_DASHBOARD_CONTEXT_FROM_REFERENCE_CHARS)).max(MAX_DASHBOARD_CONTEXT_FROM_REFERENCES).optional(),
+});
+const DashboardSnapshotStageSchema = z.object({
+    id: SnapshotIdSchema,
+    description: z.string().min(1).max(256).optional(),
+    calls: z.array(DashboardSnapshotCallSchema).max(MAX_DASHBOARD_STAGE_CALL_RECORDS),
+});
+const DashboardWorkflowSnapshotSchema = z.object({
+    name: SnapshotIdSchema,
+    version: z.string().min(1).max(128),
+    stages: z.array(DashboardSnapshotStageSchema).max(MAX_DASHBOARD_STAGE_CALL_RECORDS),
+}).superRefine((snapshot, ctx) => {
+    const stageIds = new Set();
+    const stageIndexes = new Map();
+    let records = snapshot.stages.length;
+    for (const [stageIndex, stage] of snapshot.stages.entries()) {
+        if (stageIds.has(stage.id)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "snapshot stage IDs must be unique",
+                path: ["stages", stageIndex, "id"],
+            });
+        }
+        stageIds.add(stage.id);
+        stageIndexes.set(stage.id, stageIndex);
+    }
+    let contextReferences = 0;
+    for (const [stageIndex, stage] of snapshot.stages.entries()) {
+        const callIds = new Set();
+        records += stage.calls.length;
+        for (const [callIndex, call] of stage.calls.entries()) {
+            if (callIds.has(call.id)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: "snapshot call IDs must be unique within a stage",
+                    path: ["stages", stageIndex, "calls", callIndex, "id"],
+                });
+            }
+            callIds.add(call.id);
+            const contextFrom = call.context_from ?? [];
+            contextReferences += contextFrom.length;
+            const callReferences = new Set();
+            for (const [referenceIndex, reference] of contextFrom.entries()) {
+                const path = [
+                    "stages",
+                    stageIndex,
+                    "calls",
+                    callIndex,
+                    "context_from",
+                    referenceIndex,
+                ];
+                if (callReferences.has(reference)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: "context_from references must be unique within a call",
+                        path,
+                    });
+                    continue;
+                }
+                callReferences.add(reference);
+                const parts = reference.split(".");
+                if (parts.length > 2 ||
+                    parts.some((part) => !SnapshotIdSchema.safeParse(part).success)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: "context_from must be a stage ID or stage.call ID",
+                        path,
+                    });
+                    continue;
+                }
+                const referencedStageId = parts[0];
+                const referencedStageIndex = stageIndexes.get(referencedStageId);
+                if (referencedStageIndex === undefined || referencedStageIndex >= stageIndex) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: "context_from must reference an earlier snapshot stage",
+                        path,
+                    });
+                    continue;
+                }
+                const referencedCallId = parts[1];
+                if (referencedCallId !== undefined &&
+                    !snapshot.stages[referencedStageIndex].calls.some((candidate) => candidate.id === referencedCallId)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: "context_from references a missing snapshot call",
+                        path,
+                    });
+                }
+            }
+        }
+    }
+    if (records > MAX_DASHBOARD_STAGE_CALL_RECORDS) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "snapshot stage/call limit exceeded",
+            path: ["stages"],
+        });
+    }
+    if (contextReferences > MAX_DASHBOARD_CONTEXT_FROM_REFERENCES) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "snapshot context_from reference limit exceeded",
+            path: ["stages"],
+        });
+    }
+});
+function dependencyStageIds(snapshot, stage) {
+    const referencedStages = new Set();
+    for (const call of stage.calls) {
+        for (const reference of call.context_from ?? []) {
+            referencedStages.add(reference.split(".", 1)[0]);
+        }
+    }
+    return snapshot.stages
+        .map((candidate) => candidate.id)
+        .filter((stageId) => referencedStages.has(stageId));
+}
+class SnapshotUnavailableError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+    }
+}
+class DashboardBodyIdentityChangedError extends Error {
+}
+function hasErrorCode(error, code) {
+    return error?.code === code;
+}
+function stateGeneration(result) {
+    return result.kind === "admitted"
+        ? result.runGeneration
+        : result.kind === "unavailable"
+            ? result.admission?.runGeneration
+            : undefined;
+}
+function validateRouteId(id) {
+    return SnapshotIdSchema.safeParse(id).success;
+}
+function callByEquality(state, stageId, callId) {
+    return state.stages.find((stage) => stage.stageId === stageId)
+        ?.calls.find((call) => call.callId === callId);
+}
+function contentResult(content, mediaType) {
+    return { kind: "value", value: { content, mediaType } };
+}
+function capInline(content) {
+    return Buffer.byteLength(content, "utf-8") <= DASHBOARD_LAZY_CONTENT_MAX_BYTES
+        ? { kind: "value", value: content }
+        : { kind: "unavailable", reason: "content_too_large_for_dashboard" };
+}
+export function createDashboardLazyContentReader(options = {}) {
+    const runReader = options.runReader ?? createDashboardRunReader({
+        includeUnavailableAdmissionMetadata: true,
+    });
+    const validators = options.validatorRegistry ?? createValidatorRegistry();
+    const readFile = options.readContainedFile ?? readContainedRelativeFile;
+    const standaloneRevisions = new Map();
+    function stateRevisionFor(runsRoot, admitted) {
+        if (options.stateRevisionFor !== undefined) {
+            return options.stateRevisionFor(runsRoot, admitted);
+        }
+        const key = `${runsRoot}\0${admitted.runId}`;
+        const current = standaloneRevisions.get(key);
+        if (current !== undefined &&
+            current.runGeneration === admitted.runGeneration &&
+            containedFileFingerprintsEqual(current.fingerprint, admitted.stateFingerprint))
+            return current.revision;
+        const revision = randomBytes(16).toString("base64url");
+        standaloneRevisions.set(key, {
+            runGeneration: admitted.runGeneration,
+            fingerprint: admitted.stateFingerprint,
+            revision,
+        });
+        return revision;
+    }
+    async function readBoundFile(runsRoot, admitted, relativePath, maxBytes, wantBytes = true, dependency) {
+        const read = await readFile(runsRoot, `${admitted.runId}/${relativePath}`, {
+            ...(wantBytes ? { wantBytes: true } : {}),
+            requireRegular: true,
+            maxBytes,
+            containerLabel: "runs root",
+            pathLabel: "persisted producer pointer",
+            requireExactRequestedPath: true,
+            beforeClose: async () => {
+                const current = await runReader.inspectDirectoryIdentity?.(runsRoot, admitted.runId);
+                if (current !== undefined &&
+                    (current.kind !== "present" ||
+                        current.directoryIdentity.dev !== admitted.directoryIdentity.dev ||
+                        current.directoryIdentity.ino !== admitted.directoryIdentity.ino ||
+                        current.directoryIdentity.birthtimeNs !== admitted.directoryIdentity.birthtimeNs ||
+                        current.rootIdentity.dev !== admitted.rootIdentity.dev ||
+                        current.rootIdentity.ino !== admitted.rootIdentity.ino ||
+                        current.rootIdentity.birthtimeNs !== admitted.rootIdentity.birthtimeNs)) {
+                    throw new DashboardBodyIdentityChangedError();
+                }
+            },
+        });
+        if (dependency !== undefined) {
+            dependency.collector.push({
+                relativePath,
+                role: dependency.role,
+                maxBytes,
+                fingerprint: read.fingerprint,
+                ...(dependency.contentCommitment === undefined
+                    ? {}
+                    : { contentCommitment: dependency.contentCommitment }),
+            });
+        }
+        return read;
+    }
+    async function stableRead(request, action) {
+        for (const attempt of [1, 2]) {
+            const before = await runReader.read(request.runsRoot, request.runId);
+            if (before.kind !== "admitted") {
+                const generation = stateGeneration(before);
+                if (generation !== undefined && generation !== request.runGeneration) {
+                    return { kind: "run_generation_changed" };
+                }
+                if (before.kind === "missing" && attempt === 2 && runReader.inspectGeneration !== undefined) {
+                    const directory = await runReader.inspectGeneration(request.runsRoot, request.runId);
+                    if (directory.kind === "missing" ||
+                        directory.runGeneration !== request.runGeneration)
+                        return { kind: "run_generation_changed" };
+                }
+                return attempt === 2
+                    ? { kind: "run_state_changed" }
+                    : { kind: "unavailable", reason: "not_found" };
+            }
+            if (before.runGeneration !== request.runGeneration) {
+                return { kind: "run_generation_changed" };
+            }
+            let value;
+            try {
+                value = await action(before);
+            }
+            catch (error) {
+                if (error instanceof DashboardBodyIdentityChangedError) {
+                    if (attempt === 2)
+                        return { kind: "run_state_changed" };
+                    continue;
+                }
+                throw error;
+            }
+            await options.afterLazyRead?.(attempt);
+            const after = await runReader.read(request.runsRoot, request.runId);
+            if (after.kind === "missing") {
+                const directory = await runReader.inspectGeneration?.(request.runsRoot, request.runId);
+                if (directory === undefined ||
+                    directory.kind === "missing" ||
+                    directory.runGeneration !== before.runGeneration)
+                    return { kind: "run_generation_changed" };
+            }
+            else if (stateGeneration(after) !== before.runGeneration) {
+                return { kind: "run_generation_changed" };
+            }
+            if (after.kind === "admitted" &&
+                containedFileFingerprintsEqual(before.stateFingerprint, after.stateFingerprint)) {
+                return value.kind === "unavailable"
+                    ? value
+                    : { kind: "available", value: value.value, admission: after };
+            }
+            if (attempt === 2)
+                return { kind: "run_state_changed" };
+        }
+        return { kind: "run_state_changed" };
+    }
+    async function loadSnapshot(runsRoot, admitted, dependencies) {
+        const { workflowSnapshotPath, workflowSnapshotHash } = admitted.state;
+        if (workflowSnapshotPath === undefined)
+            throw new SnapshotUnavailableError("missing");
+        if (workflowSnapshotPath !== "workflow.snapshot.json") {
+            throw new SnapshotUnavailableError("invalid");
+        }
+        if (workflowSnapshotHash === undefined)
+            throw new SnapshotUnavailableError("hash_mismatch");
+        let read;
+        try {
+            read = await readBoundFile(runsRoot, admitted, workflowSnapshotPath, DASHBOARD_WORKFLOW_SNAPSHOT_MAX_BYTES, true, dependencies === undefined
+                ? undefined
+                : {
+                    role: "snapshot",
+                    contentCommitment: workflowSnapshotHash,
+                    collector: dependencies,
+                });
+        }
+        catch (error) {
+            if (error instanceof DashboardBodyIdentityChangedError)
+                throw error;
+            if (error instanceof ContainedFileTooLargeError)
+                throw new SnapshotUnavailableError("too_large");
+            if (hasErrorCode(error, "ENOENT"))
+                throw new SnapshotUnavailableError("missing");
+            throw new SnapshotUnavailableError("unreadable");
+        }
+        const bytes = read.bytes;
+        if (createHash("sha256").update(bytes).digest("hex") !== workflowSnapshotHash) {
+            throw new SnapshotUnavailableError("hash_mismatch");
+        }
+        let decoded;
+        try {
+            decoded = JSON.parse(bytes.toString("utf-8"));
+        }
+        catch {
+            throw new SnapshotUnavailableError("invalid");
+        }
+        const parsed = DashboardWorkflowSnapshotSchema.safeParse(decoded);
+        if (!parsed.success)
+            throw new SnapshotUnavailableError("invalid");
+        if (parsed.data.name !== admitted.state.workflowName ||
+            parsed.data.version !== admitted.state.workflowVersion) {
+            throw new SnapshotUnavailableError("invalid");
+        }
+        if (parsed.data.stages.length !== admitted.state.stages.length ||
+            parsed.data.stages.some((stage, stageIndex) => {
+                const stateStage = admitted.state.stages[stageIndex];
+                return stateStage === undefined ||
+                    stage.id !== stateStage.stageId ||
+                    stage.calls.length !== stateStage.calls.length ||
+                    stage.calls.some((call, callIndex) => call.id !== stateStage.calls[callIndex]?.callId);
+            })) {
+            throw new SnapshotUnavailableError("invalid");
+        }
+        return parsed.data;
+    }
+    async function bindOutput(runsRoot, admitted, stageId, callId, dependencies) {
+        const source = resolveOutputSource(admitted, stageId, callId);
+        if (source.kind === "unavailable")
+            return source;
+        if (source.value.kind === "inline") {
+            return contentResult(source.value.content, "text/plain; charset=utf-8");
+        }
+        try {
+            const read = await readBoundFile(runsRoot, admitted, source.value.relativePath, DASHBOARD_LAZY_CONTENT_MAX_BYTES, true, dependencies === undefined
+                ? undefined
+                : {
+                    role: "generic_output",
+                    collector: dependencies,
+                });
+            return contentResult(read.bytes.toString("utf-8"), "text/plain; charset=utf-8");
+        }
+        catch (error) {
+            if (error instanceof DashboardBodyIdentityChangedError)
+                throw error;
+            if (error instanceof ContainedFileTooLargeError) {
+                return { kind: "unavailable", reason: "content_too_large_for_dashboard" };
+            }
+            if (hasErrorCode(error, "ENOENT"))
+                return { kind: "unavailable", reason: "not_found" };
+            return { kind: "unavailable", reason: "invalid" };
+        }
+    }
+    function resolveOutputSource(admitted, stageId, callId) {
+        const call = callByEquality(admitted.state, stageId, callId);
+        if (call === undefined)
+            return { kind: "unavailable", reason: "not_found" };
+        const expectedPath = `${call.stageId}.${call.callId}.output.txt`;
+        if (call.outputInline !== undefined) {
+            if (call.outputPath !== undefined)
+                return { kind: "unavailable", reason: "invalid" };
+            const capped = capInline(call.outputInline);
+            return capped.kind === "value"
+                ? { kind: "value", value: { kind: "inline", content: capped.value } }
+                : capped;
+        }
+        if (call.outputPath === undefined)
+            return { kind: "unavailable", reason: "not_persisted" };
+        if (call.outputPath !== expectedPath)
+            return { kind: "unavailable", reason: "invalid" };
+        return { kind: "value", value: { kind: "file", relativePath: expectedPath } };
+    }
+    function resolveGenericTerminalCall(admitted, snapshot) {
+        const terminalStage = snapshot.stages.at(-1);
+        if (terminalStage === undefined || terminalStage.calls.length !== 1) {
+            return { kind: "unavailable", reason: "invalid" };
+        }
+        const terminalCall = terminalStage.calls[0];
+        if (callByEquality(admitted.state, terminalStage.id, terminalCall.id) === undefined) {
+            return { kind: "unavailable", reason: "invalid" };
+        }
+        return {
+            kind: "value",
+            value: {
+                stageId: terminalStage.id,
+                callId: terminalCall.id,
+                kind: terminalCall.validator_schema_id === undefined ? "text" : "json",
+            },
+        };
+    }
+    async function inspectGenericOutput(runsRoot, admitted, terminal, dependencies) {
+        const output = await bindOutput(runsRoot, admitted, terminal.stageId, terminal.callId, dependencies);
+        if (output.kind === "unavailable")
+            return output;
+        if (!isValidGenericOutput(output.value.content, terminal.kind)) {
+            return { kind: "unavailable", reason: "invalid" };
+        }
+        return { kind: "value", value: { kind: terminal.kind } };
+    }
+    function isValidGenericOutput(content, kind) {
+        if (kind === "text")
+            return true;
+        try {
+            JSON.parse(content);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async function readCallAction(request, admitted) {
+        const call = callByEquality(admitted.state, request.stageId, request.callId);
+        if (call === undefined)
+            return { kind: "unavailable", reason: "not_found" };
+        if (request.kind === "output") {
+            return await bindOutput(request.runsRoot, admitted, request.stageId, request.callId);
+        }
+        if (request.kind === "error") {
+            if (call.errorMessage === undefined)
+                return { kind: "unavailable", reason: "not_persisted" };
+            const capped = capInline(call.errorMessage);
+            return capped.kind === "value"
+                ? contentResult(capped.value, "text/plain; charset=utf-8")
+                : capped;
+        }
+        if (request.kind === "prompt") {
+            const expectedPath = `${call.stageId}.${call.callId}.input.json`;
+            if (call.materializedInputPath === undefined) {
+                return { kind: "unavailable", reason: "not_persisted" };
+            }
+            if (call.materializedInputPath !== expectedPath) {
+                return { kind: "unavailable", reason: "invalid" };
+            }
+            try {
+                const read = await readBoundFile(request.runsRoot, admitted, expectedPath, DASHBOARD_WORKFLOW_INPUT_MAX_BYTES);
+                const text = read.bytes.toString("utf-8");
+                const decoded = JSON.parse(text);
+                if (!DashboardWorkflowInputSchema.safeParse(decoded).success) {
+                    return { kind: "unavailable", reason: "invalid" };
+                }
+                return contentResult(text, "application/json; charset=utf-8");
+            }
+            catch (error) {
+                if (error instanceof DashboardBodyIdentityChangedError)
+                    throw error;
+                if (error instanceof ContainedFileTooLargeError) {
+                    return { kind: "unavailable", reason: "content_too_large_for_dashboard" };
+                }
+                if (hasErrorCode(error, "ENOENT"))
+                    return { kind: "unavailable", reason: "not_found" };
+                return { kind: "unavailable", reason: "invalid" };
+            }
+        }
+        let snapshot;
+        try {
+            snapshot = await loadSnapshot(request.runsRoot, admitted);
+        }
+        catch (error) {
+            if (error instanceof DashboardBodyIdentityChangedError)
+                throw error;
+            return { kind: "unavailable", reason: "invalid" };
+        }
+        const snapshotStage = snapshot.stages.find((stage) => stage.id === request.stageId);
+        const callOrdinal = snapshotStage?.calls.findIndex((entry) => entry.id === request.callId) ?? -1;
+        const snapshotCall = callOrdinal < 0 ? undefined : snapshotStage.calls[callOrdinal];
+        if (snapshotCall?.validator_schema_id === undefined) {
+            return { kind: "unavailable", reason: "invalid" };
+        }
+        const expectedPath = `artifacts/${snapshotStage.id}/${String(callOrdinal + 1).padStart(2, "0")}-${snapshotCall.id}.json`;
+        if (call.artifactPath !== expectedPath)
+            return { kind: "unavailable", reason: "invalid" };
+        try {
+            const read = await readBoundFile(request.runsRoot, admitted, expectedPath, DASHBOARD_LAZY_CONTENT_MAX_BYTES);
+            const text = read.bytes.toString("utf-8");
+            const decoded = JSON.parse(text);
+            const validator = validators.get(snapshotCall.validator_schema_id);
+            if (validator === undefined)
+                return { kind: "unavailable", reason: "invalid" };
+            const validated = validator.schema.safeParse(decoded);
+            if (!validated.success)
+                return { kind: "unavailable", reason: "invalid" };
+            const canonicalBytes = Buffer.byteLength(`${JSON.stringify(validated.data, null, 2)}\n`, "utf-8");
+            if (validator.maxBytes !== undefined && canonicalBytes > validator.maxBytes) {
+                return { kind: "unavailable", reason: "invalid" };
+            }
+            return {
+                kind: "value",
+                value: {
+                    content: text,
+                    mediaType: "application/json; charset=utf-8",
+                    validatorSchemaId: snapshotCall.validator_schema_id,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof DashboardBodyIdentityChangedError)
+                throw error;
+            if (error instanceof ContainedFileTooLargeError) {
+                return { kind: "unavailable", reason: "content_too_large_for_dashboard" };
+            }
+            if (hasErrorCode(error, "ENOENT"))
+                return { kind: "unavailable", reason: "not_found" };
+            return { kind: "unavailable", reason: "invalid" };
+        }
+    }
+    return {
+        async readCallContent(request) {
+            try {
+                validateRunId(request.runId);
+            }
+            catch {
+                return { kind: "unavailable", reason: "not_found" };
+            }
+            if (!validateRouteId(request.stageId) || !validateRouteId(request.callId)) {
+                return { kind: "unavailable", reason: "not_found" };
+            }
+            const result = await stableRead(request, async (admitted) => await readCallAction(request, admitted));
+            return result.kind === "available"
+                ? {
+                    kind: "available",
+                    ...result.value,
+                    runGeneration: result.admission.runGeneration,
+                    stateRevision: stateRevisionFor(request.runsRoot, result.admission),
+                }
+                : result;
+        },
+        async readResult(request) {
+            try {
+                validateRunId(request.runId);
+            }
+            catch {
+                return { kind: "unavailable", reason: "not_found" };
+            }
+            const result = await stableRead(request, async (admitted) => {
+                if (admitted.state.status !== "succeeded") {
+                    return { kind: "unavailable", reason: "not_persisted" };
+                }
+                if (isPlanReviewRunState(admitted.state)) {
+                    const publication = admitted.state.plan_review_state?.publication;
+                    if (publication?.committed !== true) {
+                        return { kind: "unavailable", reason: "not_persisted" };
+                    }
+                    if (publication.sidecar_relpath !== PLAN_REVIEW_RESULT_RELPATH) {
+                        return { kind: "unavailable", reason: "invalid" };
+                    }
+                    try {
+                        const read = await readBoundFile(request.runsRoot, admitted, PLAN_REVIEW_RESULT_RELPATH, MAX_RESULT_ENVELOPE_BYTES);
+                        const inspected = validatePlanReviewPublicationBytes(admitted.runId, "succeeded", publication, read.bytes);
+                        return inspected.result_available && inspected.result !== undefined
+                            ? contentResult(inspected.result, "application/json; charset=utf-8")
+                            : { kind: "unavailable", reason: "invalid" };
+                    }
+                    catch (error) {
+                        if (error instanceof DashboardBodyIdentityChangedError)
+                            throw error;
+                        if (error instanceof ContainedFileTooLargeError) {
+                            return { kind: "unavailable", reason: "content_too_large_for_dashboard" };
+                        }
+                        if (hasErrorCode(error, "ENOENT"))
+                            return { kind: "unavailable", reason: "not_found" };
+                        return { kind: "unavailable", reason: "invalid" };
+                    }
+                }
+                let snapshot;
+                try {
+                    snapshot = await loadSnapshot(request.runsRoot, admitted);
+                }
+                catch (error) {
+                    if (error instanceof DashboardBodyIdentityChangedError)
+                        throw error;
+                    return { kind: "unavailable", reason: "invalid" };
+                }
+                const terminal = resolveGenericTerminalCall(admitted, snapshot);
+                if (terminal.kind === "unavailable")
+                    return terminal;
+                const output = await bindOutput(request.runsRoot, admitted, terminal.value.stageId, terminal.value.callId);
+                if (output.kind === "unavailable" || terminal.value.kind === "text") {
+                    return output;
+                }
+                if (!isValidGenericOutput(output.value.content, terminal.value.kind)) {
+                    return { kind: "unavailable", reason: "invalid" };
+                }
+                return contentResult(output.value.content, "application/json; charset=utf-8");
+            });
+            return result.kind === "available"
+                ? {
+                    kind: "available",
+                    ...result.value,
+                    runGeneration: result.admission.runGeneration,
+                    stateRevision: stateRevisionFor(request.runsRoot, result.admission),
+                }
+                : result;
+        },
+        async readStructuredProjection(request) {
+            try {
+                validateRunId(request.runId);
+            }
+            catch {
+                return { kind: "unavailable" };
+            }
+            const result = await stableRead(request, async (admitted) => {
+                const dependencies = [];
+                let snapshotResult;
+                let snapshot;
+                try {
+                    snapshot = await loadSnapshot(request.runsRoot, admitted, dependencies);
+                    snapshotResult = {
+                        availability: "available",
+                        projection: {
+                            stages: snapshot.stages.map((stage) => ({
+                                stageId: stage.id,
+                                ...(stage.description === undefined ? {} : { label: stage.description }),
+                                dependsOn: dependencyStageIds(snapshot, stage),
+                                calls: stage.calls.map((call) => ({
+                                    callId: call.id,
+                                    adapter: call.cli_name,
+                                    role: call.role,
+                                    validatedJson: call.validator_schema_id !== undefined,
+                                })),
+                            })),
+                        },
+                    };
+                }
+                catch (error) {
+                    if (error instanceof DashboardBodyIdentityChangedError)
+                        throw error;
+                    snapshotResult = {
+                        availability: "unavailable",
+                        reason: error instanceof SnapshotUnavailableError ? error.reason : "unreadable",
+                    };
+                }
+                let genericResult;
+                if (!isPlanReviewRunState(admitted.state) &&
+                    admitted.state.status === "succeeded") {
+                    if (snapshot === undefined) {
+                        genericResult = { availability: "unavailable", reason: "invalid" };
+                    }
+                    else {
+                        const terminal = resolveGenericTerminalCall(admitted, snapshot);
+                        const inspected = terminal.kind === "unavailable"
+                            ? terminal
+                            : await inspectGenericOutput(request.runsRoot, admitted, terminal.value, dependencies);
+                        genericResult = inspected.kind === "value"
+                            ? { availability: "available", kind: inspected.value.kind }
+                            : {
+                                availability: "unavailable",
+                                reason: inspected.reason === "not_found"
+                                    ? "missing"
+                                    : inspected.reason === "content_too_large_for_dashboard"
+                                        ? "too_large"
+                                        : inspected.reason,
+                            };
+                    }
+                }
+                let planReviewCard;
+                if (isPlanReviewRunState(admitted.state)) {
+                    const publication = admitted.state.plan_review_state?.publication;
+                    if (publication?.committed === true &&
+                        publication.sidecar_relpath === PLAN_REVIEW_RESULT_RELPATH) {
+                        try {
+                            const read = await readBoundFile(request.runsRoot, admitted, PLAN_REVIEW_RESULT_RELPATH, MAX_RESULT_ENVELOPE_BYTES, true, {
+                                role: "plan_review_publication",
+                                contentCommitment: publication.sidecar_sha256,
+                                collector: dependencies,
+                            });
+                            const inspected = validatePlanReviewPublicationBytes(admitted.runId, admitted.state.status === "succeeded" ? "succeeded" : undefined, publication, read.bytes);
+                            if (inspected.result_available) {
+                                planReviewCard = extractCouncilPlanReviewCard({
+                                    envelopeText: inspected.result,
+                                    contextStatus: admitted.state.workflow_context?.context_builder.status ?? "absent",
+                                });
+                            }
+                        }
+                        catch (error) {
+                            if (error instanceof DashboardBodyIdentityChangedError)
+                                throw error;
+                            // Local publication unavailability degrades to the generic card.
+                        }
+                    }
+                }
+                const enrichmentComplete = snapshotResult.availability === "available" &&
+                    (genericResult === undefined ||
+                        genericResult.availability === "available") &&
+                    (!isPlanReviewRunState(admitted.state) ||
+                        admitted.state.status !== "succeeded" ||
+                        planReviewCard?.kind === "council-plan-review");
+                return {
+                    kind: "value",
+                    value: {
+                        snapshot: snapshotResult,
+                        ...(genericResult === undefined ? {} : { genericResult }),
+                        ...(planReviewCard === undefined ? {} : { planReviewCard }),
+                        ...(enrichmentComplete
+                            ? { enrichmentDependencies: dependencies }
+                            : {}),
+                    },
+                };
+            });
+            return result.kind === "available"
+                ? {
+                    kind: "available",
+                    admission: result.admission,
+                    ...result.value,
+                }
+                : result.kind === "unavailable"
+                    ? { kind: "unavailable" }
+                    : result;
+        },
+        async validateEnrichmentDependencies(request, admitted, dependencies) {
+            for (const dependency of dependencies) {
+                try {
+                    const read = await readBoundFile(request.runsRoot, admitted, dependency.relativePath, dependency.maxBytes, false);
+                    if (!containedFileFingerprintsEqual(read.fingerprint, dependency.fingerprint)) {
+                        return false;
+                    }
+                }
+                catch {
+                    return false;
+                }
+            }
+            return true;
+        },
+    };
+}
+//# sourceMappingURL=lazy-content.js.map