niceeval 0.12.2-canary.31 → 0.13.0

package/dist/report/built-in/execution.cjs

@@ -3,764 +3,57 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTimingEvidenceReport = exports.defaultExecutionEvidenceReport = void 0;
 exports.executionEvidenceReport = executionEvidenceReport;
 exports.timingEvidenceReport = timingEvidenceReport;
-const effect_1 = require("effect");
-const index_ts_1 = require("../../projection/index.cjs");
-const family_projectors_ts_1 = require("../../o11y/record/family-projectors.cjs");
-const index_ts_2 = require("../author/index.cjs");
-const index_ts_3 = require("../semantic/index.cjs");
-const executionInputs = (0, index_ts_2.reportInputs)({
-    conversation: (0, index_ts_1.attemptSlotProjection)(family_projectors_ts_1.attemptConversationProjector),
-    commands: (0, index_ts_1.attemptSlotProjection)(family_projectors_ts_1.attemptCommandsProjector),
-    usage: (0, index_ts_1.attemptSlotProjection)(family_projectors_ts_1.attemptUsageProjector),
-    timing: (0, index_ts_1.attemptSlotProjection)(family_projectors_ts_1.attemptTimingProjector),
-    diagnostics: (0, index_ts_1.attemptSlotProjection)(family_projectors_ts_1.attemptDiagnosticsProjector),
-});
-const timingEvidenceInputs = (0, index_ts_2.reportInputs)({
-    timing: (0, index_ts_1.attemptSlotProjection)(family_projectors_ts_1.attemptTimingProjector),
-});
-/**
- * An ordinary, capability-free Report over the public Attempt observability
- * projectors. All Record reads are declared statically above; the renderer
- * receives only completed projected values.
- */
+const jsx_runtime_1 = require("react/jsx-runtime");
+const primitives_tsx_1 = require("../definition/primitives.cjs");
+const index_tsx_1 = require("../components/site-components/index.cjs");
+const conversions_ts_1 = require("../model/conversions.cjs");
+const result_components_tsx_1 = require("./result-components.cjs");
+const machine_ts_1 = require("./machine.cjs");
+function heroData(snapshot) {
+    const latest = snapshot.runs.reduce((current, run) => current === null || Number(run.startedAt) > current ? Number(run.startedAt) : current, null);
+    return Object.freeze({
+        latestStartedAt: latest === null ? null : new Date(latest).toISOString(),
+        runs: snapshot.runs.length,
+    });
+}
+function observabilityPage(id, title, trace) {
+    return {
+        id,
+        path: "/",
+        title,
+        load: async (sample) => Object.freeze({
+            hero: heroData(sample.snapshot),
+            observability: await (0, conversions_ts_1.toAttemptObservability)(sample),
+        }),
+        render: (input) => (0, jsx_runtime_1.jsxs)(primitives_tsx_1.Col, {
+            children: [
+                (0, jsx_runtime_1.jsx)(index_tsx_1.Hero, { data: input.hero }),
+                (0, jsx_runtime_1.jsx)(result_components_tsx_1.AttemptTrace, { view: input.observability, ...trace }),
+            ],
+        }),
+    };
+}
+/** A focused execution page over closed trace data; no component reopens the Sample. */
 function executionEvidenceReport(input = {}) {
     if (input.grep !== undefined)
         new RegExp(input.grep);
     const options = Object.freeze({
         ...(input.grep === undefined ? {} : { grep: input.grep }),
     });
-    const page = (0, index_ts_2.definePage)({
-        id: effect_1.Either.getOrThrow((0, index_ts_2.reportComponentId)("execution-evidence")),
-        route: effect_1.Either.getOrThrow((0, index_ts_2.reportRoute)("/")),
-        inputs: executionInputs,
-        completeness: "allow-partial",
-        render: ({ inputs }) => executionEvidenceDocument(inputs, options),
-    });
-    return (0, index_ts_2.defineReport)({
-        id: effect_1.Either.getOrThrow((0, index_ts_2.reportId)("execution-evidence")),
-        pages: [page],
+    return (0, machine_ts_1.defineBuiltInReport)(machine_ts_1.builtInMachineProducerIds.executionEvidence, {
+        title: "Attempt execution",
+        pages: [observabilityPage("execution-evidence", "Attempt execution", { mode: "execution", ...options })],
     });
 }
-/** The built-in execution evidence Report with no private reader capability. */
+/** The built-in execution report token target. */
 exports.defaultExecutionEvidenceReport = executionEvidenceReport();
-/**
- * The dedicated Attempt timing Report. It deliberately declares only the
- * timing projection, so `show --timing` cannot accidentally depend on the
- * broader execution-evidence surface.
- */
+/** A focused timing Page over the same closed observability DomainView. */
 function timingEvidenceReport(input = {}) {
-    const mode = input.mode ?? "summary";
-    const page = (0, index_ts_2.definePage)({
-        id: effect_1.Either.getOrThrow((0, index_ts_2.reportComponentId)("timing-evidence")),
-        route: effect_1.Either.getOrThrow((0, index_ts_2.reportRoute)("/")),
-        inputs: timingEvidenceInputs,
-        completeness: "allow-partial",
-        render: ({ inputs }) => timingEvidenceDocument(inputs.timing, mode),
-    });
-    return (0, index_ts_2.defineReport)({
-        id: effect_1.Either.getOrThrow((0, index_ts_2.reportId)("timing-evidence")),
-        pages: [page],
-    });
-}
-exports.defaultTimingEvidenceReport = timingEvidenceReport();
-function timingEvidenceDocument(timing, mode) {
-    const timingBySlot = entriesBySlot(timing);
-    const slots = timing.sample.slots;
-    return (0, index_ts_3.reportDocument)({
+    const options = Object.freeze({ mode: input.mode ?? "summary" });
+    return (0, machine_ts_1.defineBuiltInReport)(machine_ts_1.builtInMachineProducerIds.timingEvidence, {
         title: "Attempt timing",
-        children: slots.length === 0
-            ? [(0, index_ts_3.reportStatus)({
-                    tone: "warning",
-                    label: "The selected sample has no Slots to display",
-                })]
-            : slots.map((slot) => (0, index_ts_3.reportSection)({
-                heading: `Slot ${slot.runId}/${slot.slotId}`,
-                children: [
-                    slotStateBlock(slot),
-                    ...projectionBlocks("Timing", timingBySlot.get(slotKey(slot)), (view) => timingBlocks(view, mode)),
-                ],
-            })),
-    });
-}
-function executionEvidenceDocument(inputs, options) {
-    const grep = options.grep === undefined ? undefined : new RegExp(options.grep);
-    const conversationBySlot = entriesBySlot(inputs.conversation);
-    const commandsBySlot = entriesBySlot(inputs.commands);
-    const usageBySlot = entriesBySlot(inputs.usage);
-    const timingBySlot = entriesBySlot(inputs.timing);
-    const diagnosticsBySlot = entriesBySlot(inputs.diagnostics);
-    const slots = inputs.conversation.sample.slots;
-    return (0, index_ts_3.reportDocument)({
-        title: "Attempt execution",
-        children: slots.length === 0
-            ? [(0, index_ts_3.reportStatus)({
-                    tone: "warning",
-                    label: "The selected sample has no Slots to display",
-                })]
-            : [
-                ...(grep === undefined ? [] : [grepStatusBlock(inputs, grep)]),
-                ...slots.map((slot) => {
-                    const key = slotKey(slot);
-                    return (0, index_ts_3.reportSection)({
-                        heading: `Slot ${slot.runId}/${slot.slotId}`,
-                        children: [
-                            slotStateBlock(slot),
-                            ...projectionBlocks("Conversation", conversationBySlot.get(key), (view) => conversationBlocks(view, grep)),
-                            ...projectionBlocks("Commands", commandsBySlot.get(key), (view) => commandsBlocks(view, grep)),
-                            ...(grep === undefined
-                                ? [
-                                    ...projectionBlocks("Usage", usageBySlot.get(key), usageBlocks),
-                                    ...projectionBlocks("Timing", timingBySlot.get(key), timingBlocks),
-                                    ...projectionBlocks("Diagnostics", diagnosticsBySlot.get(key), diagnosticsBlocks),
-                                ]
-                                : []),
-                        ],
-                    });
-                }),
-            ],
-    });
-}
-function grepStatusBlock(inputs, grep) {
-    const matches = grepMatchCount(inputs, grep);
-    return (0, index_ts_3.reportStatus)({
-        tone: matches === 0 ? "warning" : "neutral",
-        label: `Grep /${grep.source}/: ${matches} matching evidence card${matches === 1 ? "" : "s"}`,
-    });
-}
-function grepMatchCount(inputs, grep) {
-    return availableProjectionValues(inputs.conversation)
-        .reduce((total, view) => total + view.items.filter((item) => grepMatches(grep, conversationItemSearchText(item))).length, 0)
-        + availableProjectionValues(inputs.commands)
-            .reduce((total, view) => total + view.commands.filter((command) => grepMatches(grep, commandSearchText(command))).length, 0);
-}
-function availableProjectionValues(projection) {
-    const values = [];
-    for (const entry of projection.entries) {
-        if (entry.state === "attachment-result" && entry.attachment.state === "available") {
-            values.push(entry.attachment.value);
-        }
-    }
-    return values;
-}
-function entriesBySlot(projection) {
-    const entries = new Map();
-    for (const entry of projection.entries) {
-        entries.set(slotKey(entry.slot), entry);
-    }
-    return entries;
-}
-function slotKey(slot) {
-    return `${slot.runId}\u0000${slot.slotId}`;
-}
-function slotStateBlock(slot) {
-    switch (slot.state) {
-        case "included":
-            return (0, index_ts_3.reportStatus)({ tone: "positive", label: "Slot: included" });
-        case "not-recorded":
-            return (0, index_ts_3.reportStatus)({
-                tone: "warning",
-                label: "Slot: not recorded",
-                detail: [(0, index_ts_3.reportText)("No Member was published for this expected Slot.")],
-            });
-        case "core-invalid":
-            return (0, index_ts_3.reportStatus)({
-                tone: "negative",
-                label: "Slot: Record Core invalid",
-                detail: [(0, index_ts_3.reportText)(issueCodes(slot.issues))],
-            });
-        case "excluded":
-            return (0, index_ts_3.reportStatus)({
-                tone: "neutral",
-                label: "Slot: excluded from the selected denominator",
-                detail: [(0, index_ts_3.reportText)(excludedSlotDetail(slot))],
-            });
-        default:
-            return unreachable(slot);
-    }
-}
-function excludedSlotDetail(slot) {
-    return slot.base.state === "core-invalid"
-        ? `Underlying state is core-invalid: ${issueCodes(slot.base.issues)}`
-        : `Underlying state is ${slot.base.state}.`;
-}
-function projectionBlocks(name, entry, availableBlocks) {
-    if (entry === undefined) {
-        return [(0, index_ts_3.reportStatus)({
-                tone: "warning",
-                label: `${name}: no projected entry was supplied for this Slot`,
-            })];
-    }
-    switch (entry.state) {
-        case "excluded":
-            return [(0, index_ts_3.reportStatus)({
-                    tone: "neutral",
-                    label: `${name}: excluded with this Slot`,
-                })];
-        case "not-recorded":
-            return [(0, index_ts_3.reportStatus)({
-                    tone: "warning",
-                    label: `${name}: not recorded because this Slot has no Member`,
-                })];
-        case "core-invalid":
-            return [(0, index_ts_3.reportStatus)({
-                    tone: "negative",
-                    label: `${name}: unavailable because Record Core is invalid`,
-                    detail: [(0, index_ts_3.reportText)(issueCodes(entry.slot.issues))],
-                })];
-        case "attachment-result":
-            return attachmentBlocks(name, entry.attachment, availableBlocks);
-        default:
-            return unreachable(entry);
-    }
-}
-function attachmentBlocks(name, attachment, availableBlocks) {
-    switch (attachment.state) {
-        case "available":
-            return [(0, index_ts_3.reportStatus)({ tone: "positive", label: `${name}: available` }), ...availableBlocks(attachment.value)];
-        case "unavailable":
-            return [(0, index_ts_3.reportStatus)({ tone: "warning", label: `${name}: attachment unavailable` })];
-        case "migration-required":
-            return [(0, index_ts_3.reportStatus)({
-                    tone: "warning",
-                    label: `${name}: migration required`,
-                    detail: [(0, index_ts_3.reportText)(`${attachment.from} → ${attachment.to}; ${attachment.command}`)],
-                })];
-        case "migration-unavailable":
-            return [(0, index_ts_3.reportStatus)({
-                    tone: "warning",
-                    label: `${name}: migration unavailable`,
-                    detail: [(0, index_ts_3.reportText)(`${attachment.from} → ${attachment.to}; ${attachment.reason}`)],
-                })];
-        case "unsupported":
-            return [(0, index_ts_3.reportStatus)({
-                    tone: "warning",
-                    label: `${name}: unsupported attachment`,
-                    detail: [(0, index_ts_3.reportText)(attachment.schemaId)],
-                })];
-        case "invalid":
-            return [(0, index_ts_3.reportStatus)({
-                    tone: "negative",
-                    label: `${name}: invalid attachment`,
-                    detail: [(0, index_ts_3.reportText)(issueCodes(attachment.issues))],
-                })];
-        default:
-            return unreachable(attachment);
-    }
-}
-function conversationBlocks(view, grep) {
-    const turns = [...view.turns].sort((left, right) => left.sequence - right.sequence);
-    const itemsByTurn = new Map();
-    for (const item of view.items) {
-        const current = itemsByTurn.get(item.turnId) ?? [];
-        itemsByTurn.set(item.turnId, [...current, item]);
-    }
-    return [(0, index_ts_3.reportSection)({
-            heading: "Conversation",
-            children: [
-                collectionStatus("Conversation", view.collection),
-                ...(turns.length === 0
-                    ? [(0, index_ts_3.reportStatus)({
-                            tone: "warning",
-                            label: "No recorded conversation turns or items",
-                        })]
-                    : matchedConversationTurns(turns, itemsByTurn, grep)),
-            ],
-        })];
-}
-function matchedConversationTurns(turns, itemsByTurn, grep) {
-    const sections = turns.flatMap((turn) => {
-        const items = (itemsByTurn.get(turn.turnId) ?? [])
-            .slice()
-            .sort((left, right) => left.sequence - right.sequence)
-            .filter((item) => grep === undefined || grepMatches(grep, conversationItemSearchText(item)));
-        if (grep !== undefined && items.length === 0)
-            return [];
-        return [(0, index_ts_3.reportSection)({
-                heading: `Turn ${turn.sequence} · ${turn.outcome}`,
-                children: items.map(conversationItemBlock),
-            })];
-    });
-    if (sections.length > 0 || grep === undefined)
-        return sections;
-    return [(0, index_ts_3.reportStatus)({
-            tone: "warning",
-            label: `No recorded conversation items match /${grep.source}/`,
-        })];
-}
-function conversationItemBlock(item) {
-    switch (item.kind) {
-        case "message":
-            return (0, index_ts_3.reportSection)({
-                heading: `${item.sequence} · ${item.role} message`,
-                children: [(0, index_ts_3.reportCodeBlock)({ value: item.text })],
-            });
-        case "tool-call":
-            return (0, index_ts_3.reportSection)({
-                // `item.tool` is the source-native name supplied by the public
-                // Conversation projector, not a Report-owned canonical fallback.
-                heading: `${item.sequence} · TOOL · ${item.tool}`,
-                children: [
-                    (0, index_ts_3.reportStatus)({ tone: "neutral", label: `Call: ${item.callId}` }),
-                    (0, index_ts_3.reportSection)({
-                        heading: "Input",
-                        children: [(0, index_ts_3.reportCodeBlock)({ value: item.inputSummary })],
-                    }),
-                ],
-            });
-        case "tool-result":
-            return (0, index_ts_3.reportSection)({
-                heading: `${item.sequence} · TOOL RESULT · ${item.outcome}`,
-                children: [
-                    (0, index_ts_3.reportStatus)({ tone: "neutral", label: `Call: ${item.callId}` }),
-                    (0, index_ts_3.reportSection)({
-                        heading: "Output",
-                        children: [(0, index_ts_3.reportCodeBlock)({ value: item.outputSummary })],
-                    }),
-                ],
-            });
-        case "thinking-summary":
-            return (0, index_ts_3.reportSection)({
-                heading: `${item.sequence} · thinking summary`,
-                children: [(0, index_ts_3.reportCodeBlock)({ value: item.summary })],
-            });
-        case "subagent":
-            return (0, index_ts_3.reportSection)({
-                heading: `${item.sequence} · subagent ${item.label} · ${item.state}`,
-                children: [(0, index_ts_3.reportCodeBlock)({ value: item.summary })],
-            });
-        case "input-request":
-            return (0, index_ts_3.reportSection)({
-                heading: `${item.sequence} · input request · ${item.state}`,
-                children: [
-                    (0, index_ts_3.reportSection)({
-                        heading: "Prompt",
-                        children: [(0, index_ts_3.reportCodeBlock)({ value: item.promptSummary })],
-                    }),
-                    ...(item.responseSummary === null
-                        ? [(0, index_ts_3.reportStatus)({ tone: "neutral", label: "Response: none recorded" })]
-                        : [(0, index_ts_3.reportSection)({
-                                heading: "Response",
-                                children: [(0, index_ts_3.reportCodeBlock)({ value: item.responseSummary })],
-                            })]),
-                ],
-            });
-        case "skill-load":
-            return (0, index_ts_3.reportStatus)({
-                tone: item.outcome === "loaded" ? "positive" : "negative",
-                label: `${item.sequence} · skill ${item.skill}: ${item.outcome}`,
-            });
-        case "context-injection":
-            return (0, index_ts_3.reportSection)({
-                heading: `${item.sequence} · ${item.source} context injection`,
-                children: [(0, index_ts_3.reportCodeBlock)({ value: item.summary })],
-            });
-        case "compaction":
-            return (0, index_ts_3.reportSection)({
-                heading: `${item.sequence} · compaction (${item.compactedItemCount} item(s))`,
-                children: [(0, index_ts_3.reportCodeBlock)({ value: item.summary })],
-            });
-        case "conversation-error":
-            return (0, index_ts_3.reportSection)({
-                heading: `${item.sequence} · conversation error ${item.code}`,
-                children: [(0, index_ts_3.reportCodeBlock)({ value: item.summary })],
-            });
-        default:
-            return unreachable(item);
-    }
-}
-function commandsBlocks(view, grep) {
-    const commands = grep === undefined
-        ? view.commands
-        : view.commands.filter((command) => grepMatches(grep, commandSearchText(command)));
-    return [(0, index_ts_3.reportSection)({
-            heading: "Commands",
-            children: [
-                collectionStatus("Commands", view.collection),
-                ...(commands.length === 0
-                    ? [(0, index_ts_3.reportStatus)({
-                            tone: "warning",
-                            label: grep === undefined ? "No recorded commands" : `No recorded commands match /${grep.source}/`,
-                        })]
-                    : commands.map((command) => (0, index_ts_3.reportSection)({
-                        heading: `Command ${command.commandId}`,
-                        children: [
-                            (0, index_ts_3.reportStatus)({ tone: "neutral", label: `Phase: ${command.manifest.phase}` }),
-                            commandInvocationBlock(command.manifest.invocation),
-                            (0, index_ts_3.reportStatus)({
-                                tone: "neutral",
-                                label: `Working directory: ${workingDirectoryText(command.manifest.workingDirectory)}`,
-                            }),
-                            commandOutcomeBlock(command.result.outcome),
-                            commandStreamBlock("stdout", command.result.stdout),
-                            commandStreamBlock("stderr", command.result.stderr),
-                        ],
-                    }))),
-            ],
-        })];
-}
-function conversationItemSearchText(item) {
-    switch (item.kind) {
-        case "message":
-            return `${item.role}\n${item.text}`;
-        case "tool-call":
-            return `${item.tool}\n${item.callId}\n${item.inputSummary}`;
-        case "tool-result":
-            return `${item.callId}\n${item.outcome}\n${item.outputSummary}`;
-        case "thinking-summary":
-            return item.summary;
-        case "subagent":
-            return `${item.label}\n${item.state}\n${item.summary}`;
-        case "input-request":
-            return [item.state, item.promptSummary, item.responseSummary ?? ""].join("\n");
-        case "skill-load":
-            return `${item.skill}\n${item.outcome}`;
-        case "context-injection":
-            return `${item.source}\n${item.summary}`;
-        case "compaction":
-            return `${item.compactedItemCount}\n${item.summary}`;
-        case "conversation-error":
-            return `${item.code}\n${item.summary}`;
-        default:
-            return unreachable(item);
-    }
-}
-function commandSearchText(command) {
-    const invocation = command.manifest.invocation.kind === "argv"
-        ? [command.manifest.invocation.executable, ...command.manifest.invocation.arguments].join("\n")
-        : command.manifest.invocation.command;
-    return [
-        command.commandId,
-        command.manifest.phase,
-        invocation,
-        workingDirectoryText(command.manifest.workingDirectory),
-        commandOutcomeSearchText(command.result.outcome),
-        command.result.stdout.text,
-        command.result.stderr.text,
-    ].join("\n");
-}
-function commandOutcomeSearchText(outcome) {
-    switch (outcome.kind) {
-        case "exited":
-            return `exited ${outcome.exitCode}`;
-        case "terminated":
-            return `terminated ${outcome.reason}`;
-        case "not-started":
-            return `not started ${outcome.reason}`;
-        default:
-            return unreachable(outcome);
-    }
-}
-function grepMatches(grep, text) {
-    grep.lastIndex = 0;
-    return grep.test(text);
-}
-function commandInvocationBlock(invocation) {
-    switch (invocation.kind) {
-        case "argv":
-            return (0, index_ts_3.reportSection)({
-                heading: "Invocation · argv",
-                children: [
-                    (0, index_ts_3.reportSection)({
-                        heading: "Executable",
-                        children: [(0, index_ts_3.reportCodeBlock)({ value: invocation.executable })],
-                    }),
-                    (0, index_ts_3.reportSection)({
-                        heading: "Arguments",
-                        children: invocation.arguments.length === 0
-                            ? [(0, index_ts_3.reportStatus)({ tone: "neutral", label: "No arguments" })]
-                            : [(0, index_ts_3.reportCodeBlock)({ value: JSON.stringify(invocation.arguments) })],
-                    }),
-                ],
-            });
-        case "shell":
-            return (0, index_ts_3.reportSection)({
-                heading: "Invocation · shell",
-                children: [(0, index_ts_3.reportCodeBlock)({ value: invocation.command, language: "shell" })],
-            });
-        default:
-            return unreachable(invocation);
-    }
-}
-function workingDirectoryText(directory) {
-    switch (directory.kind) {
-        case "sandbox-default":
-            return "sandbox default";
-        case "project-relative":
-            return directory.path;
-        case "redacted":
-            return "redacted";
-        default:
-            return unreachable(directory);
-    }
-}
-function commandOutcomeBlock(outcome) {
-    switch (outcome.kind) {
-        case "exited":
-            return (0, index_ts_3.reportStatus)({
-                tone: outcome.exitCode === 0 ? "positive" : "negative",
-                label: `Outcome: exited (${outcome.exitCode})`,
-            });
-        case "terminated":
-            return (0, index_ts_3.reportStatus)({ tone: "warning", label: `Outcome: terminated (${outcome.reason})` });
-        case "not-started":
-            return (0, index_ts_3.reportStatus)({ tone: "warning", label: `Outcome: not started (${outcome.reason})` });
-        default:
-            return unreachable(outcome);
-    }
-}
-function commandStreamBlock(name, stream) {
-    const count = `${stream.retainedBytes}/${stream.totalSafeUtf8Bytes} byte(s)`;
-    return (0, index_ts_3.reportSection)({
-        heading: `${name} · ${count}`,
-        children: stream.text.length === 0
-            ? [(0, index_ts_3.reportStatus)({ tone: "neutral", label: `${name} is empty` })]
-            : [(0, index_ts_3.reportCodeBlock)({ value: stream.text })],
-    });
-}
-function usageBlocks(view) {
-    return [(0, index_ts_3.reportSection)({
-            heading: "Usage",
-            children: [
-                collectionStatus("Usage", view.collection),
-                ...(view.observations.length === 0
-                    ? [(0, index_ts_3.reportStatus)({ tone: "warning", label: "No recorded usage observations" })]
-                    : [(0, index_ts_3.reportTable)({
-                            caption: "Usage observations (record order)",
-                            columns: [
-                                { key: "provider", label: "Provider" },
-                                { key: "kind", label: "Kind" },
-                                { key: "value", label: "Value" },
-                            ],
-                            rows: view.observations.map((observation) => ({
-                                provider: observation.provider,
-                                kind: observation.kind,
-                                value: usageObservationText(observation),
-                            })),
-                        })]),
-            ],
-        })];
-}
-function usageObservationText(observation) {
-    switch (observation.kind) {
-        case "token-bucket":
-            return `${observation.bucket}: ${observation.tokens} token(s)`;
-        case "request":
-            return `${observation.requestKind} request`;
-        case "provider-cost":
-            return `${observation.amount} ${observation.currency}`;
-        default:
-            return unreachable(observation);
-    }
-}
-function timingBlocks(view, mode = "full") {
-    const depths = timingDepths(view.intervals);
-    return [(0, index_ts_3.reportSection)({
-            heading: "Timing tree",
-            children: [
-                collectionStatus("Timing", view.collection),
-                ...(view.intervals.length === 0
-                    ? [(0, index_ts_3.reportStatus)({ tone: "warning", label: "No recorded timing intervals" })]
-                    : [mode === "summary" ? (0, index_ts_3.reportTable)({
-                            caption: "Timing tree summary (record order)",
-                            columns: [
-                                { key: "depth", label: "Depth", align: "end" },
-                                { key: "phase", label: "Phase" },
-                                { key: "label", label: "Label" },
-                                { key: "duration", label: "Duration (ms)", align: "end" },
-                                { key: "outcome", label: "Outcome" },
-                            ],
-                            rows: view.intervals.map((interval) => ({
-                                depth: depths.get(interval.intervalId) ?? 0,
-                                phase: interval.phase,
-                                label: timingIntervalLabel(interval),
-                                duration: interval.durationMs,
-                                outcome: interval.outcome,
-                            })),
-                        }) : (0, index_ts_3.reportTable)({
-                            caption: "Timing tree (record order)",
-                            columns: [
-                                { key: "interval", label: "Interval" },
-                                { key: "parent", label: "Parent" },
-                                { key: "depth", label: "Depth", align: "end" },
-                                { key: "phase", label: "Phase" },
-                                { key: "label", label: "Label" },
-                                { key: "start", label: "Start (ms)", align: "end" },
-                                { key: "duration", label: "Duration (ms)", align: "end" },
-                                { key: "outcome", label: "Outcome" },
-                            ],
-                            rows: view.intervals.map((interval) => ({
-                                interval: interval.intervalId,
-                                parent: interval.parentIntervalId ?? "root",
-                                depth: depths.get(interval.intervalId) ?? 0,
-                                phase: interval.phase,
-                                label: timingIntervalLabel(interval),
-                                start: interval.startOffsetMs,
-                                duration: interval.durationMs,
-                                outcome: interval.outcome,
-                            })),
-                        })]),
-            ],
-        })];
-}
-function timingIntervalLabel(interval) {
-    return interval.phase === "agent.send" ? `turn ${interval.label}` : interval.label;
-}
-function timingDepths(intervals) {
-    const parentById = new Map();
-    for (const interval of intervals) {
-        parentById.set(interval.intervalId, interval.parentIntervalId);
-    }
-    const depthById = new Map();
-    const resolving = new Set();
-    const depthOf = (intervalId) => {
-        const known = depthById.get(intervalId);
-        if (known !== undefined)
-            return known;
-        if (resolving.has(intervalId))
-            return 0;
-        resolving.add(intervalId);
-        const parent = parentById.get(intervalId);
-        const depth = parent === undefined || parent === null ? 0 : depthOf(parent) + 1;
-        resolving.delete(intervalId);
-        depthById.set(intervalId, depth);
-        return depth;
-    };
-    for (const interval of intervals) {
-        depthOf(interval.intervalId);
-    }
-    return depthById;
-}
-function diagnosticsBlocks(view) {
-    return [(0, index_ts_3.reportSection)({
-            heading: "Diagnostics",
-            children: [
-                collectionStatus("Diagnostics", view.collection),
-                ...(view.diagnostics.length === 0
-                    ? [(0, index_ts_3.reportStatus)({ tone: "warning", label: "No recorded diagnostics" })]
-                    : view.diagnostics.map((diagnostic) => (0, index_ts_3.reportSection)({
-                        heading: `Diagnostic ${diagnostic.diagnosticId} · ${diagnostic.kind} · ${diagnostic.code}`,
-                        children: [
-                            (0, index_ts_3.reportStatus)({ tone: diagnostic.kind === "execution-error" ? "negative" : "warning", label: `Phase: ${diagnostic.phase}` }),
-                            (0, index_ts_3.reportSection)({
-                                heading: "Summary",
-                                children: [(0, index_ts_3.reportCodeBlock)({ value: diagnostic.summary })],
-                            }),
-                            diagnosticCausesBlock(diagnostic.causes),
-                            diagnosticContextBlock(diagnostic.context),
-                            diagnosticRedactionBlock(diagnostic.redaction),
-                            diagnosticSourceFrameBlock(diagnostic.sourceFrame),
-                        ],
-                    }))),
-            ],
-        })];
-}
-function diagnosticCausesBlock(causes) {
-    return (0, index_ts_3.reportSection)({
-        heading: "Causes",
-        children: causes.length === 0
-            ? [(0, index_ts_3.reportStatus)({ tone: "neutral", label: "No recorded causes" })]
-            : [(0, index_ts_3.reportList)({
-                    ordered: false,
-                    items: causes.map((cause) => [(0, index_ts_3.reportStatus)({
-                            tone: "neutral",
-                            label: cause.code,
-                            detail: [(0, index_ts_3.reportText)(cause.summary)],
-                        })]),
-                })],
-    });
-}
-function diagnosticContextBlock(context) {
-    return (0, index_ts_3.reportSection)({
-        heading: "Context",
-        children: context.length === 0
-            ? [(0, index_ts_3.reportStatus)({ tone: "neutral", label: "No recorded context" })]
-            : [(0, index_ts_3.reportList)({
-                    ordered: false,
-                    items: context.map((item) => [(0, index_ts_3.reportStatus)({
-                            tone: "neutral",
-                            label: diagnosticContextText(item),
-                        })]),
-                })],
+        pages: [observabilityPage("timing-evidence", "Attempt timing", { mode: "timing", timingMode: options.mode })],
     });
 }
-function diagnosticContextText(context) {
-    switch (context.kind) {
-        case "entity":
-            return `Entity: ${context.target.family}/${context.target.kind}/${context.target.id}`;
-        case "limit":
-            return `Limit ${context.limit}: maximum ${context.maximum}, observed at least ${context.observedAtLeast}`;
-        case "provider":
-            return `Provider: ${context.provider}`;
-        default:
-            return unreachable(context);
-    }
-}
-function diagnosticRedactionBlock(redaction) {
-    switch (redaction.state) {
-        case "none":
-            return (0, index_ts_3.reportStatus)({ tone: "neutral", label: "Redaction: none" });
-        case "applied":
-            return (0, index_ts_3.reportStatus)({
-                tone: "warning",
-                label: "Redaction: applied",
-                detail: [(0, index_ts_3.reportText)(`summary ${redaction.summaryReplacements}, causes ${redaction.causeReplacements}, context ${redaction.contextReplacements}`)],
-            });
-        default:
-            return unreachable(redaction);
-    }
-}
-function diagnosticSourceFrameBlock(sourceFrame) {
-    if (sourceFrame === null) {
-        return (0, index_ts_3.reportStatus)({ tone: "neutral", label: "Source frame: none" });
-    }
-    return (0, index_ts_3.reportStatus)({
-        tone: "neutral",
-        label: `Source frame: ${sourceFrame.sourceItemId}`,
-        detail: [(0, index_ts_3.reportText)(`${sourceFrame.start.line}:${sourceFrame.start.column}–${sourceFrame.end.line}:${sourceFrame.end.column}`)],
-    });
-}
-function collectionStatus(name, collection) {
-    switch (collection.state) {
-        case "complete":
-            return (0, index_ts_3.reportStatus)({ tone: "positive", label: `${name} collection: complete` });
-        case "partial":
-            return (0, index_ts_3.reportStatus)({
-                tone: "warning",
-                label: `${name} collection: partial`,
-                detail: [(0, index_ts_3.reportText)(collection.limitations.map(limitationText).join("; "))],
-            });
-        default:
-            return unreachable(collection);
-    }
-}
-function limitationText(limitation) {
-    switch (limitation.code) {
-        case "capture-failed":
-            return `${limitation.target}: capture failed at ${limitation.stage}`;
-        case "capture-interrupted":
-            return `${limitation.target}: capture interrupted at ${limitation.stage}`;
-        case "collection-cap-reached":
-            return `${limitation.target}: retained ${limitation.retained}, omitted at least ${limitation.omittedAtLeast}`;
-        case "unsupported-input":
-            return `${limitation.target}: unsupported input, omitted at least ${limitation.omittedAtLeast}`;
-        case "text-truncated":
-            return `${limitation.target}: text truncated, retained ${limitation.retainedBytes} byte(s), omitted ${limitation.omittedBytes} byte(s)`;
-        case "stream-truncated":
-            return `${limitation.stream}: truncated, retained ${limitation.retainedBytes} byte(s), omitted ${limitation.omittedBytes} byte(s)`;
-        case "invalid-utf8-replaced":
-            return `${limitation.stream}: replaced ${limitation.replacementCount} invalid UTF-8 sequence(s)`;
-        case "unsafe-control-stripped":
-            return `${limitation.stream}: stripped ${limitation.strippedCount} unsafe control character(s)`;
-        case "redacted":
-            return `${limitation.target}: redacted ${limitation.replacementCount} value(s)`;
-        default:
-            return unreachable(limitation);
-    }
-}
-function issueCodes(issues) {
-    return issues.map((issue) => issue.code).join(", ");
-}
-function unreachable(value) {
-    throw new Error(`Unexpected execution evidence value: ${String(value)}`);
-}
+exports.defaultTimingEvidenceReport = timingEvidenceReport();
 //# sourceMappingURL=execution.cjs.map