engineering-behavior-observatory 0.2.1

package/dist/src/agent-sdk-normalizer.js

@@ -0,0 +1,995 @@
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { HOOK_EVENTS } from "@anthropic-ai/claude-agent-sdk";
+import { assertNoDuplicateJsonKeys, digestMetadata, readVerifiedArtifact, validateArtifact, } from "./artifacts.js";
+import { qualifyRunBundle, } from "./run-bundles.js";
+import { readBoundedFile } from "./scheduler.js";
+import { assertAdapterContract, } from "./uniform-events.js";
+export const CLAUDE_AGENT_SDK_NORMALIZATION_ADAPTER_ID = "claude-agent-sdk/v1";
+export const CLAUDE_AGENT_SDK_HARNESS = "claude-agent-sdk";
+export const CLAUDE_AGENT_SDK_NORMALIZATION_ADAPTER_VERSION = "1.0.0";
+const MAX_MANIFEST_BYTES = 16 * 1024 * 1024;
+const MAX_EVIDENCE_BYTES = 64 * 1024 * 1024;
+const HOOK_EVENT_SET = new Set(HOOK_EVENTS);
+const SESSION_NATIVE_TYPES = [
+    "assistant",
+    "auth_status",
+    "conversation_reset",
+    "prompt_suggestion",
+    "rate_limit_event",
+    "result",
+    "stream_event",
+    "system",
+    "tool_progress",
+    "tool_use_summary",
+    "user",
+];
+const ADAPTER_NATIVE_TYPES = [
+    ...SESSION_NATIVE_TYPES,
+    ...HOOK_EVENTS,
+    "agent-sdk-telemetry",
+    "workspace-outcome",
+    "verifier-result",
+    "assessment-mode",
+    "terminal-record",
+];
+const BASE_CAPABILITY_PROFILE = {
+    schemaVersion: "ebo.adapter-capability-profile/v1",
+    adapterId: CLAUDE_AGENT_SDK_NORMALIZATION_ADAPTER_ID,
+    harness: CLAUDE_AGENT_SDK_HARNESS,
+    nativeTypes: ADAPTER_NATIVE_TYPES,
+    families: {
+        message: { status: "available" },
+        "model-request": {
+            status: "unsupported",
+            detail: "Retained Agent SDK evidence does not expose inference-request lifecycle records.",
+        },
+        tool: { status: "available" },
+        context: { status: "available" },
+        permission: { status: "available" },
+        delegation: { status: "available" },
+        artifact: { status: "available" },
+        validation: { status: "available" },
+        runtime: { status: "available" },
+        outcome: { status: "available" },
+    },
+    evidence: {
+        nativeOrder: { status: "partial", detail: "Session and hook streams retain independent source-local sequences." },
+        nativeTime: { status: "partial", detail: "Origin timestamps are used when emitted; capture clocks are not substituted." },
+        parentage: { status: "partial", detail: "Relations require stable tool-use, task, agent, or workspace identifiers." },
+        content: { status: "partial", detail: "Raw content remains in native evidence and is represented only by references." },
+    },
+};
+export const claudeAgentSdkNormalizationAdapter = {
+    id: CLAUDE_AGENT_SDK_NORMALIZATION_ADAPTER_ID,
+    harness: CLAUDE_AGENT_SDK_HARNESS,
+    capabilityProfile: BASE_CAPABILITY_PROFILE,
+    async normalize(input) {
+        assertQualifiedInput(input);
+        const drafts = [];
+        const unmapped = [];
+        for (const captured of input.records) {
+            const mapped = mapRecord(input, captured);
+            drafts.push(...mapped);
+            if (mapped.length === 0) {
+                unmapped.push({
+                    reference: captured.reference,
+                    reason: unmappedReason(captured.record),
+                });
+            }
+        }
+        const capabilityProfile = capabilityProfileFor(input.records);
+        assertValidCapabilityProfile(capabilityProfile);
+        return {
+            events: resolveRelations(drafts),
+            unmapped,
+            capabilityProfile,
+        };
+    },
+};
+/** Read, structurally qualify, normalize, and reference-check one retained Agent SDK run bundle. */
+export async function normalizeClaudeAgentSdkRunBundle(bundleRoot) {
+    const input = await readQualifiedClaudeAgentSdkCapture(bundleRoot);
+    const resolver = createAgentSdkNativeEvidenceResolver(input);
+    const adapter = {
+        capture: {
+            id: CLAUDE_AGENT_SDK_NORMALIZATION_ADAPTER_ID,
+            harness: CLAUDE_AGENT_SDK_HARNESS,
+            capture: async () => input,
+        },
+        normalization: claudeAgentSdkNormalizationAdapter,
+    };
+    return await assertAdapterContract(adapter, null, resolver);
+}
+export async function readQualifiedClaudeAgentSdkCapture(bundleRoot) {
+    const manifest = readManifest(resolve(bundleRoot));
+    if (!manifest.run.runtime.some(({ source, name }) => source === "anthropic" && ["agent-sdk", CLAUDE_AGENT_SDK_HARNESS].includes(name))) {
+        throw new Error("Run bundle is not an Agent SDK capture.");
+    }
+    const capture = await readQualifiedRunCapture(bundleRoot);
+    assertQualifiedInput(capture);
+    return capture;
+}
+/** Verified retained artifact envelopes; native session documents remain source-specific. */
+export async function readQualifiedRunCapture(bundleRoot) {
+    const root = resolve(bundleRoot);
+    const manifest = readManifest(root);
+    await assertPersistedStructuralQualification(root, manifest);
+    const qualification = await qualifyRunBundle(root);
+    if (!qualification.semanticAnalysisUsable
+        || !["qualified", "qualified-with-gaps"].includes(qualification.status)) {
+        const reasons = qualification.reasons.map(({ code }) => code).join(", ") || "unknown qualification failure";
+        throw new Error(`Agent SDK normalization requires capture-qualified evidence: ${reasons}.`);
+    }
+    const records = [];
+    for (const [evidenceIndex, descriptor] of manifest.evidence.entries()) {
+        if (descriptor.sanitizedFrom !== undefined || descriptor.kind === "export-manifest")
+            continue;
+        if (descriptor.kind === "workspace" || descriptor.kind === "diagnostic") {
+            records.push({
+                reference: { artifactId: "manifest", recordLocator: `#/evidence/${evidenceIndex}` },
+                record: { kind: descriptor.kind, document: structuredClone(descriptor) },
+            });
+            continue;
+        }
+        const bytes = await readVerifiedArtifact(root, descriptor.relativePath, digestFrom(descriptor.digest), MAX_EVIDENCE_BYTES);
+        if ((descriptor.kind === "session" || descriptor.kind === "hook")
+            && descriptor.mediaType === "application/x-ndjson") {
+            for (const { line, document } of parseJsonl(bytes)) {
+                records.push({
+                    reference: { artifactId: descriptor.id, recordLocator: `line:${line}` },
+                    record: { kind: descriptor.kind, document },
+                });
+            }
+        }
+        else if ((descriptor.kind === "session" || descriptor.kind === "hook")
+            && descriptor.mediaType === "application/json") {
+            records.push({
+                reference: { artifactId: descriptor.id, recordLocator: "#" },
+                record: { kind: descriptor.kind, document: parseJson(bytes) },
+            });
+        }
+        else if (["telemetry", "verifier", "capture-report"].includes(descriptor.kind)) {
+            records.push({
+                reference: { artifactId: descriptor.id, recordLocator: "#" },
+                record: { kind: descriptor.kind, document: parseJson(bytes) },
+            });
+        }
+    }
+    if (manifest.run.assessmentMode !== undefined) {
+        records.push({
+            reference: { artifactId: "manifest", recordLocator: "#/run/assessmentMode" },
+            record: { kind: "assessment-mode", document: manifest.run.assessmentMode },
+        });
+    }
+    records.push({
+        reference: { artifactId: "manifest", recordLocator: "#/terminal" },
+        record: {
+            kind: "manifest",
+            document: structuredClone(manifest.terminal),
+        },
+    });
+    const input = {
+        runId: manifest.run.id,
+        attemptId: manifest.attempt.id,
+        qualification: qualification.status === "qualified" ? "qualified" : "qualified-with-gaps",
+        records,
+    };
+    return input;
+}
+export function createAgentSdkNativeEvidenceResolver(input) {
+    const resolved = (digest) => ({
+        runId: input.runId,
+        attemptId: input.attemptId,
+        digest,
+    });
+    const records = new Map(input.records.map((captured) => [referenceKey(captured.reference), {
+            captured,
+            resolution: resolved(`sha256:${digestMetadata(captured.record).value}`),
+        }]));
+    const manifestArtifacts = new Map(input.records.flatMap(({ record, reference }) => {
+        if (record.kind !== "workspace" && record.kind !== "diagnostic")
+            return [];
+        if (reference.artifactId !== "manifest" || !/^#\/evidence\/(0|[1-9][0-9]*)$/u.test(reference.recordLocator))
+            return [];
+        const descriptor = asRecord(record.document);
+        const id = text(descriptor?.id);
+        const digest = text(descriptor?.digest);
+        return id === undefined || digest === undefined || !/^sha256:[a-f0-9]{64}$/u.test(digest)
+            ? []
+            : [[referenceKey({ artifactId: id, recordLocator: "#" }), resolved(digest)]];
+    }));
+    return {
+        resolve(reference) {
+            const exact = records.get(referenceKey(reference))?.resolution ?? manifestArtifacts.get(referenceKey(reference));
+            if (exact !== undefined)
+                return exact;
+            const derived = splitDerivedLocator(reference.recordLocator);
+            if (derived === undefined)
+                return false;
+            const record = records.get(referenceKey({ artifactId: reference.artifactId, recordLocator: derived.base }));
+            return record !== undefined && resolvesJsonPointer(record.captured.record.document, derived.pointer)
+                ? record.resolution
+                : false;
+        },
+    };
+}
+function mapRecord(input, captured) {
+    switch (captured.record.kind) {
+        case "session": return mapSessionRecord(input, captured);
+        case "hook": return mapHookRecord(input, captured);
+        case "telemetry": return mapTelemetryRecord(input, captured);
+        case "workspace": return mapWorkspaceRecord(input, captured);
+        case "verifier": return mapVerifierRecord(input, captured);
+        case "assessment-mode": return mapAssessmentModeRecord(input, captured);
+        case "manifest": return mapManifestRecord(input, captured);
+        case "diagnostic":
+        case "capture-report": return [];
+    }
+}
+function mapSessionRecord(input, captured) {
+    const wrapper = asRecord(captured.record.document);
+    const nativeType = text(wrapper?.nativeType);
+    const message = asRecord(wrapper?.message);
+    if (wrapper === undefined || message === undefined || nativeType === undefined)
+        return [];
+    const drafts = [];
+    const subtype = text(wrapper.nativeSubtype) ?? text(message.subtype);
+    const sessionId = text(wrapper.sessionId) ?? text(message.session_id);
+    const nativeOrder = sourceOrder(wrapper, orderDomain("session", captured.reference.artifactId));
+    const nativeTime = originTime(message.timestamp, "Agent SDK message has no originating timestamp");
+    const common = { input, captured, nativeType, nativeOrder, nativeTime, sessionId };
+    const base = sessionEventShape(nativeType, subtype, message);
+    if (base !== undefined) {
+        const stableToolId = text(message.tool_use_id);
+        const stableTaskId = text(message.task_id);
+        drafts.push(draftEvent({
+            ...common,
+            discriminator: "record",
+            family: base.family,
+            phase: base.phase,
+            actor: base.actor,
+            scope: base.scope ?? (sessionId === undefined ? { kind: "attempt", id: input.attemptId } : { kind: "session", id: sessionId }),
+            attributes: sessionAttributes(nativeType, subtype, message),
+            content: sessionContent(captured.reference, nativeType, subtype, message),
+            relationKeys: [
+                ...(stableToolId === undefined ? [] : [`tool:${stableToolId}`]),
+                ...(stableTaskId === undefined ? [] : [`task:${stableTaskId}`]),
+            ],
+            anchors: nativeType === "system" && subtype === "task_started" && stableTaskId !== undefined
+                ? [{ key: `task:${stableTaskId}`, rank: 1 }]
+                : [],
+            parentKey: parentToolKey(message),
+        }));
+    }
+    if (nativeType === "result")
+        drafts.push(...mapResultResources(common, message));
+    if (nativeType === "assistant" || nativeType === "user") {
+        drafts.push(...mapToolBlocks(common, message));
+    }
+    return drafts;
+}
+function mapResultResources(common, message) {
+    const modelUsage = asRecord(message.modelUsage);
+    if (modelUsage === undefined && typeof message.total_cost_usd !== "number")
+        return [];
+    return [draftEvent({
+            ...common,
+            discriminator: "resources",
+            family: "runtime",
+            phase: "after",
+            actor: { kind: "harness" },
+            scope: common.sessionId === undefined
+                ? { kind: "attempt", id: common.input.attemptId }
+                : { kind: "session", id: common.sessionId },
+            attributes: compactAttributes({
+                inputTokens: summedModelUsage(modelUsage, "inputTokens"),
+                outputTokens: summedModelUsage(modelUsage, "outputTokens"),
+                cacheReadInputTokens: summedModelUsage(modelUsage, "cacheReadInputTokens"),
+                cacheCreationInputTokens: summedModelUsage(modelUsage, "cacheCreationInputTokens"),
+                totalCostUsd: scalar(message.total_cost_usd),
+                resourceSemantics: "cumulative-final",
+            }),
+            content: { status: "unknown", reason: "Native resource details remain in the Agent SDK result record" },
+        })];
+}
+function summedModelUsage(modelUsage, field) {
+    const records = Object.values(modelUsage ?? {}).map(asRecord);
+    const values = records.map((record) => record?.[field]);
+    return records.length > 0 && values.every((value) => typeof value === "number" && Number.isFinite(value) && value >= 0)
+        ? values.reduce((total, value) => total + value, 0)
+        : undefined;
+}
+function sessionEventShape(nativeType, subtype, message) {
+    switch (nativeType) {
+        case "assistant": return { family: "message", phase: "instant", actor: { kind: "model" } };
+        case "user": return { family: "message", phase: "instant", actor: { kind: message.isSynthetic === true ? "harness" : "user" } };
+        case "result": return { family: "outcome", phase: "after", actor: { kind: "harness" } };
+        case "stream_event": return { family: "message", phase: "during", actor: { kind: "model" } };
+        case "tool_progress": return { family: "tool", phase: "during", actor: { kind: "tool", ...(text(message.tool_name) === undefined ? {} : { id: text(message.tool_name) }) } };
+        case "tool_use_summary": return { family: "tool", phase: "after", actor: { kind: "harness" } };
+        case "auth_status":
+        case "rate_limit_event": return { family: "runtime", phase: "instant", actor: { kind: "harness" } };
+        case "conversation_reset": return { family: "context", phase: "after", actor: { kind: "harness" } };
+        case "prompt_suggestion": return { family: "message", phase: "after", actor: { kind: "harness" } };
+        case "system": return systemEventShape(subtype);
+        default: return undefined;
+    }
+}
+function systemEventShape(subtype) {
+    if (subtype === "compact_boundary")
+        return { family: "context", phase: "after", actor: { kind: "harness" } };
+    if (["task_started", "task_progress", "task_updated", "task_notification", "worker_shutting_down"].includes(subtype ?? "")) {
+        return { family: "delegation", phase: subtype === "task_started" ? "before" : "during", actor: { kind: "agent" } };
+    }
+    if (subtype === "files_persisted")
+        return { family: "artifact", phase: "after", actor: { kind: "harness" } };
+    if (subtype === "permission_denied")
+        return { family: "permission", phase: "after", actor: { kind: "harness" } };
+    if ([
+        "init", "status", "hook_started", "hook_progress", "hook_response", "background_tasks_changed",
+        "thinking_tokens", "session_state_changed", "commands_changed", "notification", "informational",
+        "local_command_output", "memory_recall", "elicitation_complete",
+    ].includes(subtype ?? ""))
+        return { family: "runtime", phase: "instant", actor: { kind: "harness" } };
+    return undefined;
+}
+function mapToolBlocks(common, message) {
+    const payload = asRecord(message.message);
+    const content = Array.isArray(payload?.content) ? payload.content : [];
+    return content.flatMap((value, index) => {
+        const block = asRecord(value);
+        if (block?.type === "tool_use") {
+            const toolUseId = text(block.id);
+            const toolName = text(block.name);
+            if (toolUseId === undefined || toolName === undefined)
+                return [];
+            return [draftEvent({
+                    ...common,
+                    discriminator: `tool-use:${index}`,
+                    family: "tool",
+                    phase: "before",
+                    actor: { kind: "model" },
+                    scope: { kind: "operation", id: toolUseId },
+                    attributes: {
+                        toolName,
+                        toolUseId,
+                        ...(block.input === undefined ? {} : { inputDigest: digestAttribute(block.input) }),
+                    },
+                    content: knownContent(contentReference(common.captured.reference, `/message/message/content/${index}`, "tool-input")),
+                    anchors: [{ key: `tool:${toolUseId}`, rank: 0 }],
+                })];
+        }
+        if (block?.type === "tool_result") {
+            const toolUseId = text(block.tool_use_id);
+            if (toolUseId === undefined)
+                return [];
+            return [draftEvent({
+                    ...common,
+                    discriminator: `tool-result:${index}`,
+                    family: "tool",
+                    phase: "after",
+                    actor: { kind: "tool" },
+                    scope: { kind: "operation", id: toolUseId },
+                    attributes: { toolUseId, ...(typeof block.is_error === "boolean" ? { isError: block.is_error } : {}) },
+                    content: knownContent(contentReference(common.captured.reference, `/message/message/content/${index}`, "tool-result")),
+                    relationKeys: [`tool:${toolUseId}`],
+                })];
+        }
+        return [];
+    });
+}
+function mapHookRecord(input, captured) {
+    const wrapper = asRecord(captured.record.document);
+    const hook = text(wrapper?.hook);
+    const payload = asRecord(wrapper?.nativePayload);
+    if (wrapper === undefined || payload === undefined || hook === undefined || !HOOK_EVENT_SET.has(hook))
+        return [];
+    const shape = hookEventShape(hook);
+    if (shape === undefined)
+        return [];
+    const toolUseId = text(wrapper.toolUseId) ?? text(payload.tool_use_id);
+    const agentId = text(wrapper.agentId) ?? text(payload.agent_id);
+    const taskId = text(payload.task_id);
+    const stable = toolUseId === undefined ? taskId === undefined ? agentId === undefined ? undefined : `agent:${agentId}` : `task:${taskId}` : `tool:${toolUseId}`;
+    const anchorRank = hook === "PreToolUse" ? 1
+        : hook === "SubagentStart" || hook === "TaskCreated" ? 0
+            : undefined;
+    return [draftEvent({
+            input,
+            captured,
+            discriminator: "record",
+            nativeType: hook,
+            nativeOrder: sourceOrder(wrapper, orderDomain("hooks", captured.reference.artifactId)),
+            nativeTime: { status: "unknown", reason: "Hook callback record has no native occurrence timestamp" },
+            family: shape.family,
+            phase: shape.phase,
+            actor: hookActor(shape.family, hook, payload),
+            scope: hookScope(shape.family, input.attemptId, wrapper, payload, toolUseId, agentId, taskId),
+            attributes: hookAttributes(hook, payload, toolUseId, agentId, taskId),
+            content: hookContent(captured.reference, hook, payload),
+            anchors: stable === undefined || anchorRank === undefined ? [] : [{ key: stable, rank: anchorRank }],
+            relationKeys: stable === undefined ? [] : [stable],
+        })];
+}
+function hookEventShape(hook) {
+    if (["PreToolUse"].includes(hook))
+        return { family: "tool", phase: "before" };
+    if (["PostToolUse", "PostToolUseFailure", "PostToolBatch"].includes(hook))
+        return { family: "tool", phase: "after" };
+    if (["UserPromptSubmit", "UserPromptExpansion"].includes(hook))
+        return { family: "message", phase: "before" };
+    if (hook === "MessageDisplay")
+        return { family: "message", phase: "after" };
+    if (hook === "PreCompact")
+        return { family: "context", phase: "before" };
+    if (["PostCompact", "InstructionsLoaded"].includes(hook))
+        return { family: "context", phase: "after" };
+    if (hook === "PreModelSwitch")
+        return { family: "runtime", phase: "before" };
+    if (hook === "PostModelSwitch")
+        return { family: "runtime", phase: "after" };
+    if (["PermissionRequest", "Elicitation"].includes(hook))
+        return { family: "permission", phase: "before" };
+    if (["PermissionDenied", "ElicitationResult"].includes(hook))
+        return { family: "permission", phase: "after" };
+    if (["SubagentStart", "TaskCreated"].includes(hook))
+        return { family: "delegation", phase: "before" };
+    if (["SubagentStop", "TaskCompleted"].includes(hook))
+        return { family: "delegation", phase: "after" };
+    if (hook === "TeammateIdle")
+        return { family: "delegation", phase: "instant" };
+    if (["WorktreeCreate"].includes(hook))
+        return { family: "artifact", phase: "before" };
+    if (["WorktreeRemove"].includes(hook))
+        return { family: "artifact", phase: "after" };
+    if (["FileChanged", "DirectoryAdded"].includes(hook))
+        return { family: "artifact", phase: "instant" };
+    if (["SessionStart", "Setup"].includes(hook))
+        return { family: "runtime", phase: "before" };
+    if (["SessionEnd", "Stop", "StopFailure"].includes(hook))
+        return { family: "runtime", phase: "after" };
+    if (["Notification", "ConfigChange", "CwdChanged"].includes(hook))
+        return { family: "runtime", phase: "instant" };
+    return undefined;
+}
+function mapTelemetryRecord(input, captured) {
+    const document = asRecord(captured.record.document);
+    if (document?.schemaVersion !== "ebo.agent-sdk-telemetry/v1")
+        return [];
+    const telemetry = asRecord(document.telemetry);
+    const receipt = asRecord(telemetry?.receipt);
+    const usage = asRecord(document.usage);
+    return [draftEvent({
+            input,
+            captured,
+            discriminator: "record",
+            nativeType: "agent-sdk-telemetry",
+            nativeOrder: { status: "unknown", reason: "Telemetry artifact has no cross-signal native order" },
+            nativeTime: { status: "unknown", reason: "Telemetry summary has no native occurrence timestamp" },
+            family: "runtime",
+            phase: "during",
+            actor: { kind: "system", id: "otlp" },
+            scope: { kind: "attempt", id: input.attemptId },
+            attributes: compactAttributes({
+                receiptStatus: scalar(receipt?.status),
+                receivedSignals: scalarList(receipt?.signals),
+                totalCostUsd: scalar(usage?.totalCostUsd),
+                numTurns: scalar(usage?.numTurns),
+            }),
+            content: { status: "unknown", reason: "Telemetry payload remains in native evidence" },
+        })];
+}
+function mapWorkspaceRecord(input, captured) {
+    const descriptor = asRecord(captured.record.document);
+    if (descriptor?.kind !== "workspace" || captured.reference.artifactId !== "manifest"
+        || !/^#\/evidence\/(0|[1-9][0-9]*)$/u.test(captured.reference.recordLocator))
+        return [];
+    const mediaType = text(descriptor.mediaType);
+    return [draftEvent({
+            input,
+            captured,
+            discriminator: "record",
+            nativeType: "workspace-outcome",
+            nativeOrder: { status: "unknown", reason: "Workspace artifact has no native event order" },
+            nativeTime: { status: "unknown", reason: "Workspace artifact has no native occurrence timestamp" },
+            family: "artifact",
+            phase: "after",
+            actor: { kind: "system", id: "ebo-workspace" },
+            scope: { kind: "workspace", id: descriptor.id },
+            attributes: compactAttributes({ mediaType: descriptor.mediaType, fingerprint: descriptor.fingerprint }),
+            content: knownContent({
+                nativeReference: { artifactId: descriptor.id, recordLocator: "#" },
+                ...(mediaType === undefined ? {} : { mediaType }),
+                role: "workspace-outcome",
+            }),
+            anchors: [{ key: `artifact:${descriptor.id}`, rank: 0 }],
+        })];
+}
+function mapVerifierRecord(input, captured) {
+    const document = asRecord(captured.record.document);
+    if (!isVerifierRecord(captured) || document === undefined)
+        return [];
+    return [draftEvent({
+            input,
+            captured,
+            discriminator: "record",
+            nativeType: "verifier-result",
+            nativeOrder: { status: "unknown", reason: "Verifier artifact has no native event order" },
+            nativeTime: { status: "unknown", reason: "Verifier result has no native occurrence timestamp" },
+            family: "validation",
+            phase: "after",
+            actor: { kind: "system", id: "ebo-verifier" },
+            scope: { kind: "attempt", id: input.attemptId },
+            attributes: compactAttributes({
+                status: scalar(document.status),
+                exitCode: scalar(document.exitCode),
+                assertionCount: Array.isArray(document.assertions) ? document.assertions.length : undefined,
+            }),
+            content: Array.isArray(document.assertions)
+                ? knownContent(contentReference(captured.reference, "/assertions", "assertions"))
+                : { status: "unknown", reason: "Verifier assertions were not retained" },
+        })];
+}
+function mapManifestRecord(input, captured) {
+    const terminal = asRecord(captured.record.document);
+    if (terminal === undefined || typeof terminal.state !== "string"
+        || captured.reference.artifactId !== "manifest" || captured.reference.recordLocator !== "#/terminal")
+        return [];
+    const workspaceId = text(terminal.workspaceArtifactId);
+    return [draftEvent({
+            input,
+            captured,
+            discriminator: "record",
+            nativeType: "terminal-record",
+            nativeOrder: { status: "unknown", reason: "Run manifest has no native event order" },
+            nativeTime: { status: "unknown", reason: "Terminal record has no native occurrence timestamp" },
+            family: "outcome",
+            phase: "after",
+            actor: { kind: "system", id: "ebo" },
+            scope: { kind: "attempt", id: input.attemptId },
+            attributes: compactAttributes({
+                state: scalar(terminal.state),
+                failureClass: scalar(terminal.failureClass),
+                stopReason: scalar(terminal.stopReason),
+            }),
+            content: workspaceId === undefined
+                ? { status: "unknown", reason: "Terminal record does not identify a workspace artifact" }
+                : knownContent({ nativeReference: { artifactId: workspaceId, recordLocator: "#" }, role: "final-workspace" }),
+            relationKeys: workspaceId === undefined ? [] : [`artifact:${workspaceId}`],
+        })];
+}
+function mapAssessmentModeRecord(input, captured) {
+    const assessmentMode = assessmentModeOf(captured);
+    if (assessmentMode === undefined)
+        return [];
+    return [draftEvent({
+            input,
+            captured,
+            discriminator: "record",
+            nativeType: "assessment-mode",
+            nativeOrder: { status: "unknown", reason: "Run assessment mode has no native event order" },
+            nativeTime: { status: "unknown", reason: "Run assessment mode has no native occurrence timestamp" },
+            family: "outcome",
+            phase: "instant",
+            actor: { kind: "system", id: "ebo" },
+            scope: { kind: "attempt", id: input.attemptId },
+            attributes: { assessmentMode },
+            content: { status: "known", value: [] },
+        })];
+}
+function draftEvent(input) {
+    return {
+        event: {
+            schemaVersion: "ebo.uniform-event/v1",
+            id: stableEventId(input.input, input.captured.reference, input.discriminator),
+            runId: input.input.runId,
+            attemptId: input.input.attemptId,
+            source: {
+                harness: CLAUDE_AGENT_SDK_HARNESS,
+                nativeType: input.nativeType,
+                nativeReference: input.captured.reference,
+            },
+            nativeOrder: input.nativeOrder,
+            nativeTime: input.nativeTime,
+            actor: input.actor,
+            family: input.family,
+            phase: input.phase,
+            scope: input.scope,
+            relations: { parent: { status: "unknown", reason: "Native record does not establish an emitted parent" }, known: [] },
+            attributes: input.attributes,
+            content: input.content,
+        },
+        anchors: input.anchors ?? [],
+        relationKeys: input.relationKeys ?? [],
+        ...(input.parentKey === undefined ? {} : { parentKey: input.parentKey }),
+    };
+}
+function resolveRelations(drafts) {
+    const candidates = new Map();
+    for (const draft of drafts) {
+        for (const anchor of draft.anchors) {
+            const entries = candidates.get(anchor.key) ?? [];
+            entries.push({ id: draft.event.id, rank: anchor.rank });
+            candidates.set(anchor.key, entries);
+        }
+    }
+    const anchors = new Map();
+    for (const [key, entries] of candidates) {
+        const minimum = Math.min(...entries.map(({ rank }) => rank));
+        const preferred = entries.filter(({ rank }) => rank === minimum);
+        if (preferred.length === 1)
+            anchors.set(key, preferred[0].id);
+    }
+    return drafts.map((draft) => {
+        const known = [...new Set(draft.relationKeys.map((key) => anchors.get(key)))]
+            .filter((id) => id !== undefined && id !== draft.event.id)
+            .map((eventId) => ({ kind: "correlates-with", eventId }));
+        const parent = draft.parentKey === undefined ? draft.event.relations.parent
+            : anchors.has(draft.parentKey)
+                ? { status: "known", value: anchors.get(draft.parentKey) }
+                : { status: "unknown", reason: "Stable parent tool ID has no uniquely mapped tool-call event" };
+        return { ...draft.event, relations: { parent, known } };
+    });
+}
+function capabilityProfileFor(records) {
+    const retainedCapabilities = records.flatMap(({ record }) => {
+        if (record.kind !== "capture-report")
+            return [];
+        const agentSdk = asRecord(asRecord(record.document)?.agentSdk);
+        const capabilities = asRecord(agentSdk?.capabilities);
+        return capabilities === undefined ? [] : [capabilities];
+    })[0];
+    const sdkVersion = text(retainedCapabilities?.sdkVersion);
+    const detailedBetaConfigured = records.some(({ record }) => {
+        if (record.kind !== "telemetry")
+            return false;
+        const telemetry = asRecord(asRecord(record.document)?.telemetry);
+        return asRecord(telemetry?.hookSpans)?.status === "enabled";
+    });
+    return {
+        ...structuredClone(BASE_CAPABILITY_PROFILE),
+        families: {
+            ...structuredClone(BASE_CAPABILITY_PROFILE.families),
+            "model-request": {
+                status: "unsupported",
+                detail: sdkVersion === undefined
+                    ? "Retained Agent SDK evidence does not establish inference-request lifecycle coverage."
+                    : `Retained Agent SDK ${sdkVersion} exposes model-switch callbacks, not inference-request lifecycle records.`,
+            },
+        },
+        evidence: {
+            ...structuredClone(BASE_CAPABILITY_PROFILE.evidence),
+            nativeTime: {
+                status: "partial",
+                detail: detailedBetaConfigured
+                    ? "Origin timestamps are used when emitted; detailed-beta hook spans are configured but are not substituted for native semantic events."
+                    : "Origin timestamps are used when emitted; detailed-beta hook span timing is unavailable and semantic hook history is unchanged.",
+            },
+        },
+    };
+}
+function assertQualifiedInput(input) {
+    if (!["qualified", "qualified-with-gaps"].includes(input.qualification)) {
+        throw new Error("Agent SDK normalization requires capture-qualified evidence.");
+    }
+    if (text(input.runId) === undefined || text(input.attemptId) === undefined || !Array.isArray(input.records)) {
+        throw new Error("Agent SDK normalization input identity is invalid.");
+    }
+    const kinds = new Set(input.records.map(({ record }) => record.kind));
+    for (const required of ["session", "hook", "workspace", "manifest"]) {
+        if (!kinds.has(required))
+            throw new Error(`Capture-qualified Agent SDK input is missing required ${required} evidence.`);
+    }
+    const assessmentMode = input.records.map(assessmentModeOf).find((value) => value !== undefined);
+    if (assessmentMode !== "observational" && !input.records.some(isVerifierRecord)) {
+        throw new Error("Capture-qualified verified input is missing required verifier evidence.");
+    }
+}
+function assessmentModeOf(captured) {
+    return captured.record.kind === "assessment-mode"
+        && captured.reference.artifactId === "manifest"
+        && captured.reference.recordLocator === "#/run/assessmentMode"
+        && (captured.record.document === "observational" || captured.record.document === "verified")
+        ? captured.record.document
+        : undefined;
+}
+function isVerifierRecord(captured) {
+    return captured.record.kind === "verifier"
+        && captured.reference.recordLocator === "#"
+        && asRecord(captured.record.document)?.schemaVersion === "verifier-result/v1";
+}
+function assertValidCapabilityProfile(profile) {
+    const errors = validateArtifact("Agent SDK adapter capability profile", profile);
+    if (errors.length > 0)
+        throw new Error(errors.map(({ field, message }) => `${field}: ${message}`).join("\n"));
+}
+function readManifest(root) {
+    const bytes = readBoundedFile(resolve(root, "manifest.json"), "Run manifest", undefined, MAX_MANIFEST_BYTES);
+    const textValue = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    assertNoDuplicateJsonKeys(textValue);
+    const document = JSON.parse(textValue);
+    const errors = validateArtifact("manifest.json", document);
+    if (errors.length > 0)
+        throw new Error(errors.map(({ field, message }) => `${field}: ${message}`).join("\n"));
+    return document;
+}
+async function assertPersistedStructuralQualification(root, manifest) {
+    const descriptor = manifest.evidence.find(({ kind, sanitizedFrom }) => kind === "capture-report" && sanitizedFrom === undefined);
+    if (descriptor === undefined)
+        return;
+    const report = asRecord(parseJson(await readVerifiedArtifact(root, descriptor.relativePath, digestFrom(descriptor.digest), MAX_EVIDENCE_BYTES)));
+    const structural = asRecord(report?.structuralQualification);
+    if (structural?.status === "unqualified" || structural?.semanticAnalysisUsable === false) {
+        throw new Error("Agent SDK normalization rejects the persisted unqualified structural capture report.");
+    }
+}
+function parseJsonl(bytes) {
+    const textValue = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return textValue.split(/\r?\n/u).map((value, index) => ({ value, line: index + 1 }))
+        .filter(({ value }) => value.trim() !== "")
+        .map(({ value, line }) => {
+        assertNoDuplicateJsonKeys(value);
+        return { line, document: JSON.parse(value) };
+    });
+}
+function parseJson(bytes) {
+    const textValue = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    assertNoDuplicateJsonKeys(textValue);
+    return JSON.parse(textValue);
+}
+function digestFrom(value) {
+    return { algorithm: "sha256", value: value.replace(/^sha256:/u, "") };
+}
+function sourceOrder(document, domain) {
+    const sequence = document.sequence;
+    return Number.isSafeInteger(sequence) && Number(sequence) >= 0
+        ? { status: "known", value: Number(sequence), domain }
+        : { status: "unknown", reason: `${domain} record has no valid source-local sequence` };
+}
+function orderDomain(kind, artifactId) {
+    const readable = `${kind}:${artifactId}`;
+    return [...readable].length <= 256
+        ? readable
+        : `${kind}:sha256:${createHash("sha256").update(artifactId).digest("hex")}`;
+}
+function originTime(value, reason) {
+    if (typeof value === "string" && isRfc3339DateTime(value))
+        return { status: "known", value };
+    return { status: "unknown", reason };
+}
+function isRfc3339DateTime(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|[+-](\d{2}):(\d{2}))$/iu.exec(value);
+    if (match === null)
+        return false;
+    const [, yearText, monthText, dayText, hourText, minuteText, secondText, offsetHourText, offsetMinuteText] = match;
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    const hour = Number(hourText);
+    const minute = Number(minuteText);
+    const second = Number(secondText);
+    const offsetHour = offsetHourText === undefined ? 0 : Number(offsetHourText);
+    const offsetMinute = offsetMinuteText === undefined ? 0 : Number(offsetMinuteText);
+    const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const monthDays = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return month >= 1 && month <= 12
+        && day >= 1 && day <= monthDays[month - 1]
+        && hour <= 23 && minute <= 59 && second <= 59
+        && offsetHour <= 23 && offsetMinute <= 59;
+}
+function sessionAttributes(nativeType, subtype, message) {
+    const rateLimit = asRecord(message.rate_limit_info);
+    return compactAttributes({
+        subtype,
+        messageId: scalar(message.uuid),
+        model: scalar(asRecord(message.message)?.model),
+        isSynthetic: scalar(message.isSynthetic),
+        isError: scalar(message.is_error),
+        stopReason: scalar(message.stop_reason),
+        numTurns: scalar(message.num_turns),
+        toolName: scalar(message.tool_name),
+        elapsedSeconds: scalar(message.elapsed_time_seconds),
+        durationMs: scalar(message.duration_ms),
+        apiDurationMs: scalar(message.duration_api_ms),
+        unprojectedToolBlockCount: unprojectedToolBlockCount(message),
+        resourceSemantics: nativeType === "result" && typeof message.duration_ms === "number" ? "cumulative-final" : undefined,
+        rateLimitStatus: nativeType === "rate_limit_event" ? scalar(rateLimit?.status) : undefined,
+        rateLimitType: nativeType === "rate_limit_event" ? scalar(rateLimit?.rateLimitType) : undefined,
+        utilization: nativeType === "rate_limit_event" ? scalar(rateLimit?.utilization) : undefined,
+    });
+}
+function unprojectedToolBlockCount(message) {
+    const content = asRecord(message.message)?.content;
+    if (!Array.isArray(content))
+        return undefined;
+    const count = content.filter((value) => {
+        const block = asRecord(value);
+        return block?.type === "tool_use" && (text(block.id) === undefined || text(block.name) === undefined)
+            || block?.type === "tool_result" && text(block.tool_use_id) === undefined;
+    }).length;
+    return count === 0 ? undefined : count;
+}
+function sessionContent(reference, nativeType, subtype, message) {
+    const inner = asRecord(message.message);
+    if ((nativeType === "assistant" || nativeType === "user") && inner?.content !== undefined) {
+        return knownContent(contentReference(reference, "/message/message/content", `${nativeType}-message`));
+    }
+    if (nativeType === "result" && (message.result !== undefined || message.errors !== undefined)) {
+        return knownContent(contentReference(reference, message.result !== undefined ? "/message/result" : "/message/errors", "result"));
+    }
+    if (nativeType === "prompt_suggestion" && message.suggestion !== undefined) {
+        return knownContent(contentReference(reference, "/message/suggestion", "suggestion"));
+    }
+    if (nativeType === "system" && ["local_command_output", "informational"].includes(subtype ?? "") && message.content !== undefined) {
+        return knownContent(contentReference(reference, "/message/content", "system-message"));
+    }
+    return { status: "unknown", reason: "Native message content remains in the source record" };
+}
+function hookActor(family, hook, payload) {
+    if (family === "tool")
+        return { kind: "tool", ...(text(payload.tool_name) === undefined ? {} : { id: text(payload.tool_name) }) };
+    if (family === "delegation")
+        return { kind: "agent", ...(text(payload.agent_id) === undefined ? {} : { id: text(payload.agent_id) }) };
+    if (hook === "UserPromptSubmit" || hook === "UserPromptExpansion")
+        return { kind: "user" };
+    if (hook === "MessageDisplay")
+        return { kind: "model" };
+    if (family === "artifact")
+        return { kind: "agent" };
+    return { kind: "harness" };
+}
+function hookScope(family, attemptId, wrapper, payload, toolUseId, agentId, taskId) {
+    if ((family === "tool" || family === "permission") && toolUseId !== undefined)
+        return { kind: "operation", id: toolUseId };
+    if (family === "delegation" && (taskId ?? agentId) !== undefined)
+        return { kind: "operation", id: taskId ?? agentId };
+    if (family === "artifact")
+        return { kind: "workspace" };
+    const turnId = text(payload.turn_id);
+    if (family === "message" && turnId !== undefined)
+        return { kind: "turn", id: turnId };
+    const sessionId = text(wrapper.sessionId) ?? text(payload.session_id);
+    return sessionId === undefined ? { kind: "attempt", id: attemptId } : { kind: "session", id: sessionId };
+}
+function hookAttributes(hook, payload, toolUseId, agentId, taskId) {
+    return compactAttributes({
+        hook,
+        mutation: hook === "FileChanged" ? true : undefined,
+        toolUseId,
+        toolName: scalar(payload.tool_name),
+        inputDigest: hook === "PreToolUse" && payload.tool_input !== undefined
+            ? digestAttribute(payload.tool_input)
+            : undefined,
+        agentId,
+        agentType: scalar(payload.agent_type),
+        taskId,
+        trigger: scalar(payload.trigger),
+        source: scalar(payload.source),
+        fromModel: scalar(payload.from_model),
+        toModel: scalar(payload.to_model),
+        requestedModel: scalar(payload.requested_model),
+        decision: hook === "PermissionDenied" ? "denied" : scalar(payload.action),
+        event: scalar(payload.event),
+        notificationType: scalar(payload.notification_type),
+        mcpServerName: scalar(payload.mcp_server_name),
+    });
+}
+function hookContent(reference, hook, payload) {
+    const fields = {
+        UserPromptSubmit: { field: "prompt", role: "user-prompt" },
+        UserPromptExpansion: { field: "prompt", role: "expanded-prompt" },
+        MessageDisplay: { field: "delta", role: "display-message" },
+        Notification: { field: "message", role: "notification" },
+        PreCompact: { field: "custom_instructions", role: "compaction-instructions" },
+        PostCompact: { field: "compact_summary", role: "compaction-summary" },
+        Elicitation: { field: "message", role: "elicitation" },
+        PreToolUse: { field: "tool_input", role: "tool-input" },
+        PostToolUse: { field: "tool_response", role: "tool-result" },
+        PostToolUseFailure: { field: "error", role: "tool-error" },
+        PostToolBatch: { field: "tool_calls", role: "tool-batch" },
+    };
+    const selected = fields[hook];
+    return selected !== undefined && payload[selected.field] !== undefined
+        ? knownContent(contentReference(reference, `/nativePayload/${selected.field}`, selected.role))
+        : { status: "unknown", reason: "Hook payload content remains in the source record" };
+}
+function parentToolKey(message) {
+    const parent = text(message.parent_tool_use_id);
+    return parent === undefined ? undefined : `tool:${parent}`;
+}
+function stableEventId(input, reference, discriminator) {
+    const digest = createHash("sha256").update(JSON.stringify([
+        input.runId,
+        input.attemptId,
+        reference.artifactId,
+        reference.recordLocator,
+        discriminator,
+    ])).digest("hex");
+    return `agent-sdk-${digest.slice(0, 32)}`;
+}
+function contentReference(reference, pointer, role) {
+    return {
+        nativeReference: {
+            artifactId: reference.artifactId,
+            recordLocator: reference.recordLocator === "#"
+                ? `#${pointer}`
+                : `${reference.recordLocator}#${pointer}`,
+        },
+        role,
+    };
+}
+function knownContent(...content) {
+    return { status: "known", value: content };
+}
+function compactAttributes(values) {
+    return Object.fromEntries(Object.entries(values).filter((entry) => entry[1] !== undefined && validAttributeValue(entry[1])));
+}
+function scalar(value) {
+    return validAttributeScalar(value) ? value : undefined;
+}
+function scalarList(value) {
+    return Array.isArray(value) && value.length <= 16 && value.every(validAttributeScalar)
+        ? value
+        : undefined;
+}
+function digestAttribute(value) {
+    return `sha256:${digestMetadata(value).value}`;
+}
+function validAttributeValue(value) {
+    return Array.isArray(value) ? value.length <= 16 && value.every(validAttributeScalar) : validAttributeScalar(value);
+}
+function validAttributeScalar(value) {
+    return value === null || typeof value === "boolean"
+        || typeof value === "number" && Number.isFinite(value)
+        || typeof value === "string" && [...value].length <= 512;
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function text(value) {
+    return typeof value === "string" && value.trim() !== "" && [...value].length <= 256 ? value : undefined;
+}
+function unmappedReason(record) {
+    if (record.kind === "capture-report")
+        return "Capture qualification metadata informs the capability report and is not a semantic event";
+    if (record.kind === "diagnostic")
+        return "Diagnostic sidecar remains native outcome evidence";
+    if (record.kind === "session")
+        return "Unrecognized Agent SDK message type remains in the native session artifact";
+    if (record.kind === "hook")
+        return "Unrecognized Agent SDK hook record remains in the native hook artifact";
+    return `Unrecognized ${record.kind} record remains in native evidence`;
+}
+function referenceKey(reference) {
+    return JSON.stringify([reference.artifactId, reference.recordLocator]);
+}
+function splitDerivedLocator(locator) {
+    if (locator.startsWith("#/"))
+        return { base: "#", pointer: locator.slice(1) };
+    const marker = locator.indexOf("#/");
+    return marker === -1 ? undefined : { base: locator.slice(0, marker), pointer: locator.slice(marker + 1) };
+}
+function resolvesJsonPointer(document, pointer) {
+    if (pointer === "")
+        return true;
+    if (!pointer.startsWith("/"))
+        return false;
+    let current = document;
+    for (const encoded of pointer.slice(1).split("/")) {
+        const segment = encoded.replace(/~1/gu, "/").replace(/~0/gu, "~");
+        if (Array.isArray(current)) {
+            if (!/^(0|[1-9][0-9]*)$/u.test(segment) || Number(segment) >= current.length)
+                return false;
+            current = current.at(Number(segment));
+        }
+        else {
+            const record = asRecord(current);
+            const property = record === undefined ? undefined : Object.getOwnPropertyDescriptor(record, segment);
+            if (property === undefined || !("value" in property))
+                return false;
+            current = property.value;
+        }
+    }
+    return true;
+}