harnery 0.33.0 → 0.34.0

package/dist/core/events/v3/producers/hook-base.js

@@ -0,0 +1,424 @@
+import { buildEventV3Base } from "../base-builder.js";
+import { fingerprintV3, normalizeNativeIdV3 } from "../canonical.js";
+import { adapterSignalSupportV3, adapterTurnWaitCountSupportV3 } from "../capabilities.js";
+import { eventIdV3 } from "../ids.js";
+import { exactToolInputFingerprintV3, extractTargetsV3 } from "../targets.js";
+/** Normalize one already-parsed hook payload directly into V3Base without retaining its raw fields. */
+export function normalizeHookEventV3Base(signal, payload, context) {
+    const eventId = context.event_id ?? eventIdV3();
+    const sessionNative = payload.session_id ?? payload.conversation_id ?? payload.agent_id ?? context.instance_id;
+    const sessionId = asSessionId(normalizeNativeIdV3(context.fingerprintContext, `${context.adapter}.session`, sessionNative));
+    const turnNative = payload.turn_id ?? context.turn_native_id ?? `${sessionNative}:${context.sequence}`;
+    // A native payload turn id normally outranks the producer-state stamp: a
+    // lost or late user-prompt-submit hook must not mis-attribute this event to
+    // a stale turn (ADR 0078 turn attribution). Turn terminals are different:
+    // Cursor can mint a new generation_id for Stop, so the producer's open turn
+    // is the authoritative correlation target when one exists.
+    const terminalTurnId = signal === "stop" || signal === "stop-failure" ? context.turn_id : undefined;
+    const turnId = terminalTurnId
+        ? terminalTurnId
+        : payload.turn_id
+            ? asTurnId(normalizeNativeIdV3(context.fingerprintContext, `${context.adapter}.turn`, payload.turn_id))
+            : (context.turn_id ??
+                asTurnId(normalizeNativeIdV3(context.fingerprintContext, `${context.adapter}.turn`, turnNative)));
+    const generationScope = {
+        root_id: context.root_id,
+        instance_id: context.instance_id,
+        session_id: sessionId,
+        generation_id: context.generation_id,
+        ...(context.run_id ? { run_id: context.run_id } : {}),
+        ...(context.workflow_id ? { workflow_id: context.workflow_id } : {}),
+        ...(context.workflow_agent_id ? { workflow_agent_id: context.workflow_agent_id } : {}),
+    };
+    const turnScope = { ...generationScope, turn_id: turnId };
+    const producer = {
+        producer_id: context.producer_id,
+        boot_id: context.boot_id,
+        sequence: context.sequence,
+        component: "agent-hook",
+        build_id: context.build_id,
+        platform: context.platform,
+        ...(context.bridge ? { bridge: context.bridge } : {}),
+    };
+    const provenance = {
+        source_event: `${context.adapter}.${signal}`,
+        attestation: "native",
+        confidence: "exact",
+        ...(payload.tool_use_id
+            ? {
+                source_record_id: asSourceId(normalizeNativeIdV3(context.fingerprintContext, `${context.adapter}.source-record`, payload.tool_use_id)),
+            }
+            : {}),
+        attribution: {
+            method: "native_payload",
+            state: "verified",
+            subject_instance_id: context.instance_id,
+        },
+    };
+    const common = {
+        event_id: eventId,
+        producer,
+        attestation_id: context.attestation_id,
+        provenance,
+        observed_at: context.observed_at,
+        recorded_at: context.recorded_at,
+        monotonic_ns: context.monotonic_ns,
+        clock_id: context.clock_id,
+    };
+    const causedBy = context.caused_by ?? [];
+    switch (signal) {
+        case "session-start": {
+            const runtimeAttestation = {
+                attestation_id: context.attestation_id,
+                generation_id: context.generation_id,
+                adapter: observedIdentity(context.adapter, context.adapterVersion),
+                harness: observedIdentity(context.adapter, context.harnessVersion),
+                model: payload.model
+                    ? {
+                        state: "observed",
+                        value: { provider: providerFor(context.adapter), id: safeModelId(payload.model) },
+                        attestation: "native",
+                        confidence: "exact",
+                    }
+                    : { state: "expected_but_missing", capability: "model_identity", reason: "not_reported" },
+                capability_profile: context.capability_profile,
+                declared_by_event_id: eventId,
+            };
+            return buildEventV3Base("session.started", {
+                ...common,
+                scope: generationScope,
+                links: { caused_by: causedBy },
+                payload: {
+                    runtime_attestation: runtimeAttestation,
+                    resume: payload.source === "resume"
+                        ? { state: "unknown", reason: "prior_generation_not_bound" }
+                        : { state: "not_applicable" },
+                },
+            });
+        }
+        case "session-end":
+            return buildEventV3Base("session.ended", {
+                ...common,
+                scope: generationScope,
+                links: { caused_by: causedBy },
+                payload: {
+                    outcome: payload.clean_exit === true
+                        ? "succeeded"
+                        : payload.clean_exit === false
+                            ? "failed"
+                            : "unknown",
+                    authority: "native",
+                    reason: payload.clean_exit === true
+                        ? "native_clean_exit"
+                        : payload.clean_exit === false
+                            ? "native_unclean_exit"
+                            : "native_exit_outcome_unknown",
+                    completeness: { state: "unknown", reason: "terminal_signal_coverage_unmeasured" },
+                },
+            });
+        case "user-prompt-submit": {
+            const prompt = payload.prompt ?? "";
+            return buildEventV3Base("turn.started", {
+                ...common,
+                scope: turnScope,
+                links: { caused_by: causedBy },
+                payload: {
+                    input: {
+                        storage: "omitted",
+                        media_type: "text/plain",
+                        bytes: Buffer.byteLength(prompt, "utf8"),
+                        fingerprint: fingerprintV3(context.fingerprintContext, "user-prompt", prompt),
+                    },
+                    intent_kind: "unknown",
+                    ...(context.stop_remediation ? { stop_remediation: true } : {}),
+                },
+            });
+        }
+        case "stop":
+        case "stop-failure":
+            return buildEventV3Base("turn.completed", {
+                ...common,
+                scope: turnScope,
+                links: { caused_by: causedBy },
+                payload: {
+                    outcome: signal === "stop" ? "succeeded" : "failed",
+                    duration_ms: measuredOrMissing(context.duration_ms, "turn_duration", "turn_timing_not_supplied"),
+                    tool_call_count: context.tool_call_count_support === "unsupported"
+                        ? { state: "unsupported", capability: "turn_tool_call_count" }
+                        : measuredOrMissing(context.tool_call_count, "turn_tool_call_count", context.tool_call_count_missing_reason ?? "turn_aggregate_not_supplied"),
+                    wait_count: adapterTurnWaitCountSupportV3(context.adapter) === "unsupported"
+                        ? { state: "unsupported", capability: "turn_wait_count" }
+                        : measuredOrMissing(undefined, "turn_wait_count", "turn_wait_aggregate_not_supplied"),
+                    response: context.response_bytes === undefined
+                        ? { state: "unsupported", capability: "turn_response_descriptor" }
+                        : {
+                            state: "observed",
+                            value: {
+                                storage: "omitted",
+                                media_type: "text/plain",
+                                bytes: context.response_bytes,
+                            },
+                            attestation: "derived",
+                            confidence: "exact",
+                        },
+                    ...(context.turn_ritual
+                        ? { ritual: turnRitualObservation(context.adapter, context.turn_ritual) }
+                        : {}),
+                },
+            });
+        case "pre-tool-use": {
+            if (!payload.tool_name || !context.span_id)
+                return null;
+            const toolInput = payload.tool_input ?? null;
+            return buildEventV3Base("tool.requested", {
+                ...common,
+                scope: turnScope,
+                links: { caused_by: causedBy, span_id: context.span_id },
+                payload: {
+                    tool: { namespace: context.adapter, name: safeToolName(payload.tool_name) },
+                    input: {
+                        storage: "omitted",
+                        media_type: "application/json",
+                        bytes: byteLengthOfUnknown(toolInput),
+                    },
+                    exact_input: exactToolInputFingerprintV3(context.fingerprintContext, context.adapter, payload.tool_name, toolInput),
+                    targets: extractTargetsV3({
+                        coordRoot: context.coordRoot,
+                        toolNamespace: context.adapter,
+                        toolName: payload.tool_name,
+                        toolInput,
+                        fingerprintContext: context.fingerprintContext,
+                    }),
+                },
+            });
+        }
+        case "post-tool-use":
+        case "post-tool-use-failure": {
+            if (!payload.tool_name || !context.span_id)
+                return null;
+            return buildEventV3Base("tool.completed", {
+                ...common,
+                scope: turnScope,
+                links: { caused_by: causedBy, span_id: context.span_id },
+                payload: {
+                    tool: { namespace: context.adapter, name: safeToolName(payload.tool_name) },
+                    outcome: signal === "post-tool-use" ? "succeeded" : "failed",
+                    duration_ms: measuredOrMissing(context.duration_ms, "tool_duration", "span_timing_not_supplied"),
+                    result: {
+                        storage: "omitted",
+                        media_type: typeof payload.tool_response === "string" ? "text/plain" : "application/json",
+                        bytes: byteLengthOfUnknown(payload.tool_response ?? null),
+                    },
+                    ...(signal === "post-tool-use-failure"
+                        ? { error: { class: "adapter_tool_failure" } }
+                        : {}),
+                },
+            });
+        }
+        case "permission-request": {
+            const waitNative = payload.tool_use_id ?? `${sessionNative}:${context.sequence}`;
+            const waitId = normalizeNativeIdV3(context.fingerprintContext, `${context.adapter}.wait`, waitNative);
+            return buildEventV3Base("wait.started", {
+                ...common,
+                scope: turnScope,
+                links: { caused_by: causedBy },
+                payload: { wait_id: waitId, kind: "permission" },
+            });
+        }
+        case "sub-agent-start": {
+            if (!context.delegation_id || !context.child_generation_id)
+                return null;
+            return buildEventV3Base("agent.started", {
+                ...common,
+                scope: generationScope,
+                links: {
+                    caused_by: causedBy,
+                    delegation_id: context.delegation_id,
+                    parent_generation_id: context.generation_id,
+                },
+                payload: {
+                    delegation_id: context.delegation_id,
+                    child_generation_id: context.child_generation_id,
+                    role: safeToken(context.agent_role ?? "agent", "agent"),
+                },
+            });
+        }
+        case "sub-agent-stop": {
+            if (!context.delegation_id || !context.child_generation_id)
+                return null;
+            return buildEventV3Base("agent.completed", {
+                ...common,
+                scope: generationScope,
+                links: {
+                    caused_by: causedBy,
+                    delegation_id: context.delegation_id,
+                    parent_generation_id: context.generation_id,
+                },
+                payload: {
+                    delegation_id: context.delegation_id,
+                    child_generation_id: context.child_generation_id,
+                    outcome: payload.exit_status === "ok"
+                        ? "succeeded"
+                        : payload.exit_status === "interrupted"
+                            ? "interrupted"
+                            : payload.exit_status
+                                ? "failed"
+                                : "unknown",
+                },
+            });
+        }
+        case "pre-compact":
+            return buildEventV3Base("context.compaction_started", {
+                ...common,
+                scope: generationScope,
+                links: { caused_by: causedBy },
+                payload: {
+                    before: contextMeasurement(inputContextMeasurement(payload, "before"), context, "pre_compaction"),
+                    method: `${context.adapter.replaceAll("-", "_")}_hook`,
+                },
+            });
+        case "post-compact":
+            return buildEventV3Base("context.compaction_completed", {
+                ...common,
+                scope: generationScope,
+                links: { caused_by: causedBy },
+                payload: {
+                    outcome: "succeeded",
+                    before: contextMeasurement(inputContextMeasurement(payload, "before"), context, "pre_compaction"),
+                    after: contextMeasurement(inputContextMeasurement(payload, "after"), context, "post_compaction"),
+                },
+            });
+    }
+}
+function turnRitualObservation(adapter, evidence) {
+    if (adapter === "cursor") {
+        const unsupported = { state: "unsupported", capability: "assistant_reply_text" };
+        return {
+            status_box_present: unsupported,
+            status_box_present_strict: unsupported,
+            session_name: unsupported,
+        };
+    }
+    const observed = (value) => ({
+        state: "observed",
+        value,
+        attestation: "derived",
+        confidence: "exact",
+    });
+    return {
+        status_box_present: observed(evidence.status_box_present),
+        status_box_present_strict: observed(evidence.status_box_present_strict),
+        session_name: observed({
+            required: evidence.session_name_required,
+            present: evidence.session_name_present,
+        }),
+    };
+}
+function inputContextMeasurement(payload, phase) {
+    const metadata = plainRecord(payload.raw.compact_metadata);
+    const usedKeys = phase === "before"
+        ? ["pre_tokens", "pre_compact_tokens", "used_tokens"]
+        : ["post_tokens", "post_compact_tokens", "used_tokens"];
+    const limitKeys = [
+        "context_window_size",
+        "context_window_tokens",
+        "window_tokens",
+        "limit_tokens",
+    ];
+    return {
+        used: firstNumber(payload.raw, metadata, usedKeys),
+        limit: firstNumber(payload.raw, metadata, limitKeys),
+    };
+}
+function contextMeasurement(measurement, context, capability) {
+    if (adapterSignalSupportV3(context.adapter, capability) === "unsupported") {
+        return { state: "unsupported", capability };
+    }
+    if (measurement.used === undefined || measurement.limit === undefined || measurement.limit < 1) {
+        return {
+            state: "expected_but_missing",
+            capability,
+            reason: "context_measurement_incomplete",
+        };
+    }
+    return {
+        state: "observed",
+        value: {
+            used_tokens: Math.floor(measurement.used),
+            limit_tokens: Math.floor(measurement.limit),
+            remaining_tokens: Math.max(0, Math.floor(measurement.limit - measurement.used)),
+            measured_at: context.observed_at ?? context.recorded_at ?? new Date().toISOString(),
+            method: `${context.adapter.replaceAll("-", "_")}_hook`,
+        },
+        attestation: "native",
+        confidence: "exact",
+    };
+}
+function firstNumber(primary, secondary, keys) {
+    for (const key of keys) {
+        for (const source of [primary, secondary]) {
+            const value = source?.[key];
+            if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+                return value;
+        }
+    }
+    return undefined;
+}
+function plainRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null
+        ? value
+        : undefined;
+}
+function observedIdentity(id, version) {
+    return {
+        state: "observed",
+        value: { id, ...(version ? { version } : {}) },
+        attestation: "native",
+        confidence: "exact",
+    };
+}
+function providerFor(adapter) {
+    if (adapter === "claude-code")
+        return "anthropic";
+    if (adapter === "codex")
+        return "openai";
+    return "cursor";
+}
+function safeModelId(value) {
+    return safeToken(value, "unknown-model");
+}
+function safeToolName(value) {
+    return safeToken(value, "unknown-tool");
+}
+function safeToken(value, fallback) {
+    const normalized = value
+        .normalize("NFC")
+        .replace(/[^a-zA-Z0-9._:/+-]/g, "_")
+        .slice(0, 128);
+    return /^[a-zA-Z0-9]/.test(normalized) ? normalized : fallback;
+}
+function byteLengthOfUnknown(value) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value) ?? "null", "utf8");
+    }
+    catch {
+        return 0;
+    }
+}
+function measuredOrMissing(value, capability, reason) {
+    return value === undefined
+        ? { state: "expected_but_missing", capability, reason }
+        : { state: "observed", value, attestation: "derived", confidence: "exact" };
+}
+function asSessionId(value) {
+    return `sid_${value.slice(4)}`;
+}
+function asTurnId(value) {
+    return `tid_${value.slice(4)}`;
+}
+function asSourceId(value) {
+    return value;
+}

package/dist/core/events/v3/producers/hook.d.ts

@@ -0,0 +1,29 @@
+import type { ParsedPayload } from "../../../hooks/adapter/parse.js";
+import type { EventV3Base } from "../base-contract.js";
+import type { EventOfTypeV3, EventTypeV3, SpanSummaryV3 } from "../contract.js";
+import { type HarnessTimingAccumulatorV3, type TurnTelemetryV3 } from "../turn-telemetry.js";
+import { type HookProducerContextV3Base, type HookSignalV3Base } from "./hook-base.js";
+export interface HookProducerContextV3 extends HookProducerContextV3Base {
+    /** Required for terminal events; captured when the corresponding span opens. */
+    terminal_span?: SpanSummaryV3;
+    /** Required by V3 delegation starts so the child span is anchored in its parent tree. */
+    parent_span_id?: `span_${string}`;
+    /** Optional recorder aggregate. An empty aggregate remains explicit missing evidence. */
+    harness_timing?: HarnessTimingAccumulatorV3;
+    /** Test/replay override for already-extracted telemetry. */
+    turn_telemetry?: TurnTelemetryV3;
+}
+export type HookSignalV3 = HookSignalV3Base;
+export type HookEventV3 = EventOfTypeV3<EventTypeV3>;
+/**
+ * Normalize one hook payload to the V3 contract.
+ *
+ * The V3 base normalizer owns privacy and scope. This adapter adds contract
+ * identity, self-contained terminal spans, and economics. Returning null for an incomplete terminal prevents a producer
+ * from writing a structurally valid-looking event without its load-bearing
+ * self-contained span.
+ */
+export declare function normalizeHookEventV3(signal: HookSignalV3Base, payload: ParsedPayload, context: HookProducerContextV3): HookEventV3 | null;
+/** Upgrade recorder-synthesized hook events, including resolving wait terminals. */
+export declare function upgradeHookEventV3(base: EventV3Base, source: ParsedPayload, context: HookProducerContextV3): HookEventV3 | null;
+//# sourceMappingURL=hook.d.ts.map

package/dist/core/events/v3/producers/hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/v3/producers/hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGhF,OAAO,EAGL,KAAK,0BAA0B,EAE/B,KAAK,eAAe,EACrB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,gBAAgB,EAEtB,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,qBAAsB,SAAQ,yBAAyB;IACtE,gFAAgF;IAChF,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,yFAAyF;IACzF,cAAc,CAAC,EAAE,QAAQ,MAAM,EAAE,CAAC;IAClC,yFAAyF;IACzF,cAAc,CAAC,EAAE,0BAA0B,CAAC;IAC5C,4DAA4D;IAC5D,cAAc,CAAC,EAAE,eAAe,CAAC;CAClC;AAED,MAAM,MAAM,YAAY,GAAG,gBAAgB,CAAC;AAU5C,MAAM,MAAM,WAAW,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,qBAAqB,GAC7B,WAAW,GAAG,IAAI,CAIpB;AAED,oFAAoF;AACpF,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,qBAAqB,GAC7B,WAAW,GAAG,IAAI,CAuBpB"}

package/dist/core/events/v3/producers/hook.js

@@ -0,0 +1,71 @@
+import { EVENT_V3_CONTRACT_MAJOR, EVENT_V3_CONTRACT_NAME } from "../contract.js";
+import { EVENT_V3_SCHEMA_DIGEST } from "../generated.js";
+import { emptyHarnessTimingV3, extractTurnTelemetryV3, harnessObservationV3, } from "../turn-telemetry.js";
+import { assertEventV3 } from "../validate.js";
+import { normalizeHookEventV3Base, } from "./hook-base.js";
+const TERMINAL_EVENT_TYPES = new Set([
+    "session.ended",
+    "turn.completed",
+    "tool.completed",
+    "agent.completed",
+    "wait.ended",
+]);
+/**
+ * Normalize one hook payload to the V3 contract.
+ *
+ * The V3 base normalizer owns privacy and scope. This adapter adds contract
+ * identity, self-contained terminal spans, and economics. Returning null for an incomplete terminal prevents a producer
+ * from writing a structurally valid-looking event without its load-bearing
+ * self-contained span.
+ */
+export function normalizeHookEventV3(signal, payload, context) {
+    const base = normalizeHookEventV3Base(signal, payload, context);
+    if (!base)
+        return null;
+    return upgradeHookEventV3(base, payload, context);
+}
+/** Upgrade recorder-synthesized hook events, including resolving wait terminals. */
+export function upgradeHookEventV3(base, source, context) {
+    if (TERMINAL_EVENT_TYPES.has(base.event_type) && !context.terminal_span)
+        return null;
+    if (base.event_type === "agent.started" && (!context.span_id || !context.parent_span_id)) {
+        return null;
+    }
+    const event = {
+        ...base,
+        contract: {
+            name: EVENT_V3_CONTRACT_NAME,
+            major: EVENT_V3_CONTRACT_MAJOR,
+            schema_digest: EVENT_V3_SCHEMA_DIGEST,
+        },
+        event_type: base.event_type,
+        links: {
+            ...base.links,
+            ...(context.span_id ? { span_id: context.span_id } : {}),
+            ...(context.parent_span_id ? { parent_span_id: context.parent_span_id } : {}),
+        },
+        payload: terminalPayload(base.event_type, base.payload, source, context),
+    };
+    assertEventV3(event);
+    return event;
+}
+function terminalPayload(eventType, basePayload, source, context) {
+    if (!TERMINAL_EVENT_TYPES.has(eventType))
+        return basePayload;
+    const span = context.terminal_span;
+    if (eventType === "tool.completed") {
+        return { ...basePayload, duration_ms: span.duration_ms, span };
+    }
+    if (eventType !== "turn.completed")
+        return { ...basePayload, span };
+    const telemetry = context.turn_telemetry ??
+        extractTurnTelemetryV3(context.adapter, source.raw, context.observed_at ?? context.recorded_at ?? new Date().toISOString());
+    return {
+        ...basePayload,
+        duration_ms: span.duration_ms,
+        span,
+        usage: telemetry.usage,
+        inference: telemetry.inference,
+        harness: harnessObservationV3(context.harness_timing ?? emptyHarnessTimingV3()),
+    };
+}

package/dist/core/events/v3/producers/intake.d.ts

@@ -0,0 +1,65 @@
+import type { Adapter } from "../../../adapter.js";
+import type { ParsedPayload } from "../../../hooks/adapter/parse.js";
+import type { EventV3WriteMode } from "../control.js";
+import type { HookSignalV3 } from "./hook.js";
+import type { TurnRitualEvidenceV3 } from "./hook-base.js";
+/**
+ * Durable intake spool for hook signals, plus the producer diagnostics spool.
+ *
+ * A hook process appends its parsed signal here BEFORE reading or validating
+ * any producer state, so a lost lease, a crash, or a state-format mismatch can
+ * never destroy a delivered signal. Whichever process holds that session's
+ * producer-state lease drains the spool in append order and deletes each
+ * record only after its outcome is durably published. Intake records hold raw
+ * payloads transiently under owner-only permissions; anything that cannot
+ * become a ledger event is preserved in the diagnostics spool with raw content
+ * fields reduced to byte counts and digests.
+ */
+declare const INTAKE_FORMAT: "harnery-v3-hook-intake";
+declare const INTAKE_VERSION: 1;
+export interface HookIntakeRecordV3 {
+    format: typeof INTAKE_FORMAT;
+    format_version: typeof INTAKE_VERSION;
+    mode: EventV3WriteMode;
+    signal: HookSignalV3;
+    payload: ParsedPayload;
+    adapter: Adapter;
+    instance_id: `inst_${string}`;
+    producer_id: `prd_${string}`;
+    build_id: `build_${string}`;
+    platform: "linux" | "windows" | "macos" | "unknown";
+    bridge?: "codex-wsl";
+    adapterVersion?: string;
+    harnessVersion?: string;
+    monotonic_ns?: string;
+    observed_at?: string;
+    hook_name?: string;
+    hook_duration_ms?: number;
+    stop_remediation?: boolean;
+    turn_ritual?: TurnRitualEvidenceV3;
+}
+export interface HookIntakeGroupV3 {
+    adapter: Adapter;
+    session_hash: `hid_${string}`;
+    directory: string;
+}
+export interface HookIntakeEntryV3 {
+    path: string;
+    name: string;
+    /** Undefined when the file is unreadable or fails shape validation. */
+    record: HookIntakeRecordV3 | undefined;
+}
+export declare function hookIntakeGroupDirV3(coordRoot: string, adapter: Adapter, sessionHash: `hid_${string}`): string;
+export declare function appendHookIntakeRecordV3(coordRoot: string, sessionHash: `hid_${string}`, record: HookIntakeRecordV3): string;
+export declare function listHookIntakeGroupsV3(coordRoot: string): HookIntakeGroupV3[];
+export declare function listHookIntakeRecordsV3(directory: string): HookIntakeEntryV3[];
+export declare function removeIntakeRecordV3(path: string): void;
+/**
+ * Preserve a signal that could not become a ledger event. Raw content fields
+ * are reduced to byte counts and digests so the diagnostics spool never holds
+ * prompt, tool input, or tool output bodies (invariant: delivered evidence is
+ * never silently destroyed, and never re-exposed either).
+ */
+export declare function writeProducerDiagnosticV3(coordRoot: string, category: string, record: Record<string, unknown>): string | undefined;
+export {};
+//# sourceMappingURL=intake.d.ts.map

package/dist/core/events/v3/producers/intake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intake.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/v3/producers/intake.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D;;;;;;;;;;;GAWG;AAEH,QAAA,MAAM,aAAa,EAAG,wBAAiC,CAAC;AACxD,QAAA,MAAM,cAAc,EAAG,CAAU,CAAC;AAwClC,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,aAAa,CAAC;IAC7B,cAAc,EAAE,OAAO,cAAc,CAAC;IACtC,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,QAAQ,MAAM,EAAE,CAAC;IAC9B,WAAW,EAAE,OAAO,MAAM,EAAE,CAAC;IAC7B,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IACpD,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACpC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,OAAO,MAAM,EAAE,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,MAAM,EAAE,kBAAkB,GAAG,SAAS,CAAC;CACxC;AAUD,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,OAAO,MAAM,EAAE,GAC3B,MAAM,CAER;AA+BD,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO,MAAM,EAAE,EAC5B,MAAM,EAAE,kBAAkB,GACzB,MAAM,CAOR;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAsB7E;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAc9E;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAGvD;AAsDD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,GAAG,SAAS,CAiBpB"}