harnery 0.33.0 → 0.34.1

package/dist/core/events/v3/producers/coordination-recorder.d.ts

@@ -0,0 +1,53 @@
+import type { Adapter } from "../../../adapter.js";
+import { type AuthorityReceiptV3, type AuthorityReconcilerV3 } from "../authority-outbox.js";
+import type { EventV3 } from "../contract.js";
+import { type EventV3WriteMode } from "../control.js";
+import { type CoordinationAuthoritySignalV3, type CoordinationObservationBySignalV3 } from "./coordination.js";
+export interface RecordCoordinationAuthorityV3Input<S extends CoordinationAuthoritySignalV3 = CoordinationAuthoritySignalV3> {
+    coordRoot: string;
+    mode: EventV3WriteMode;
+    signal: S;
+    observation: CoordinationObservationBySignalV3[S];
+    adapter: Adapter;
+    native_actor_session_id: string;
+    actor_instance_id: `inst_${string}`;
+    subject_instance_id: `inst_${string}`;
+    producer_id: `prd_${string}`;
+    build_id: `build_${string}`;
+    platform: "linux" | "windows" | "macos" | "unknown";
+    bridge?: "codex-wsl";
+    expected_prior_state_digest: `sha256:${string}`;
+    desired_state_digest: `sha256:${string}`;
+    monotonic_ns?: string;
+    observed_at?: string;
+    reconciler: AuthorityReconcilerV3;
+}
+export type RecordCoordinationAuthorityV3Result = {
+    state: "gate_closed";
+    reason: string;
+} | {
+    state: "generation_unavailable";
+    reason: string;
+} | {
+    state: "already_recorded";
+    event_id: string;
+    transaction_id: string;
+} | {
+    state: "pending_transaction";
+    transaction_id: string;
+    mutation_kind: string;
+} | {
+    state: "recorded";
+    event: EventV3;
+    receipt: AuthorityReceiptV3;
+    recovered: boolean;
+};
+/**
+ * Record and apply an authority-bearing coordination transition through the
+ * spool-first outbox. It is inert until an exact V3 gate is open. A stale
+ * pending transaction left by a crashed writer is completed when the
+ * idempotent outbox can still settle it; a pending mutation that cannot be
+ * settled is refused rather than guessed at.
+ */
+export declare function recordCoordinationAuthorityV3<S extends CoordinationAuthoritySignalV3>(input: RecordCoordinationAuthorityV3Input<S>): RecordCoordinationAuthorityV3Result;
+//# sourceMappingURL=coordination-recorder.d.ts.map

package/dist/core/events/v3/producers/coordination-recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordination-recorder.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/v3/producers/coordination-recorder.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAGnD,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAK3B,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,KAAK,gBAAgB,EAA2B,MAAM,eAAe,CAAC;AAK/E,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,iCAAiC,EAEvC,MAAM,mBAAmB,CAAC;AAyC3B,MAAM,WAAW,kCAAkC,CACjD,CAAC,SAAS,6BAA6B,GAAG,6BAA6B;IAEvE,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,CAAC,CAAC;IACV,WAAW,EAAE,iCAAiC,CAAC,CAAC,CAAC,CAAC;IAClD,OAAO,EAAE,OAAO,CAAC;IACjB,uBAAuB,EAAE,MAAM,CAAC;IAChC,iBAAiB,EAAE,QAAQ,MAAM,EAAE,CAAC;IACpC,mBAAmB,EAAE,QAAQ,MAAM,EAAE,CAAC;IACtC,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,2BAA2B,EAAE,UAAU,MAAM,EAAE,CAAC;IAChD,oBAAoB,EAAE,UAAU,MAAM,EAAE,CAAC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,qBAAqB,CAAC;CACnC;AAED,MAAM,MAAM,mCAAmC,GAC3C;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,KAAK,EAAE,wBAAwB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,KAAK,EAAE,kBAAkB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACvE;IAAE,KAAK,EAAE,qBAAqB,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC/E;IACE,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,kBAAkB,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEN;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,6BAA6B,EACnF,KAAK,EAAE,kCAAkC,CAAC,CAAC,CAAC,GAC3C,mCAAmC,CA4LrC"}

package/dist/core/events/v3/producers/coordination-recorder.js

@@ -0,0 +1,376 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { hostname } from "node:os";
+import { join, resolve } from "node:path";
+import { fsyncParentDirectory } from "../../../workflow/durable-record.js";
+import { acquireNoClobberLease } from "../../../workflow/workspaces/leases.js";
+import { buildAuthorityTransactionV3, publishAuthorityTransactionV3, reconcileAuthorityTransactionV3, } from "../authority-outbox.js";
+import { canonicalJsonV3, normalizeNativeIdV3 } from "../canonical.js";
+import { markObservedClockRegressionV3 } from "../clock-order.js";
+import { readEventV3ControlState } from "../control.js";
+import { fingerprintContextV3 } from "../fingerprint-keys.js";
+import { clockIdV3, spanIdV3 } from "../ids.js";
+import { closeSpanStateV3, openSpanStateV3 } from "../span-state.js";
+import { EVENT_V3_LEDGER_RELATIVE_ROOT } from "../writer.js";
+import { normalizeCoordinationAuthorityV3, } from "./coordination.js";
+import { readHookProducerStateV3 } from "./recorder.js";
+const COORDINATION_STATE_FORMAT = "harnery-v3-coordination-producer";
+const COORDINATION_STATE_VERSION = 2;
+const MAX_OBSERVATIONS = 512;
+/**
+ * Record and apply an authority-bearing coordination transition through the
+ * spool-first outbox. It is inert until an exact V3 gate is open. A stale
+ * pending transaction left by a crashed writer is completed when the
+ * idempotent outbox can still settle it; a pending mutation that cannot be
+ * settled is refused rather than guessed at.
+ */
+export function recordCoordinationAuthorityV3(input) {
+    const control = readEventV3ControlState(input.coordRoot);
+    if (control.state !== input.mode)
+        return { state: "gate_closed", reason: control.state };
+    const hook = readHookProducerStateV3(input.coordRoot, input.adapter, input.native_actor_session_id);
+    if (!hook ||
+        hook.terminal ||
+        hook.instance_id !== input.actor_instance_id ||
+        !hook.last_event_id) {
+        return { state: "generation_unavailable", reason: "hook_generation_not_joinable" };
+    }
+    const rootId = control.genesis.event.scope.root_id;
+    const epochId = control.genesis.profile.privacy_key_epoch;
+    const rootContext = fingerprintContextV3(input.coordRoot, rootId, undefined, epochId);
+    const producerSource = normalizeNativeIdV3(rootContext, "agent-coord.producer", `${input.adapter}\0${input.native_actor_session_id}\0${hook.generation_id}`);
+    const sourceId = normalizeNativeIdV3(rootContext, "agent-coord.observation", input.observation.native_observation_id);
+    const path = coordinationStatePath(input.coordRoot, producerSource);
+    const lease = acquireCoordinationLease(input.coordRoot, path);
+    try {
+        let state = existsSync(path) ? readCoordinationState(path) : undefined;
+        if (state && !matchesHookState(state, hook, input, epochId)) {
+            throw new Error("V3 coordination producer state does not match the joined hook generation");
+        }
+        if (state?.pending) {
+            if (state.pending.source_id !== sourceId) {
+                // A writer that died mid-commit leaves `pending` owned by an
+                // observation that will never retry (hook observations are one-shot).
+                // When the stale transaction can still be settled through the
+                // idempotent outbox — its receipt already exists, or its ready record
+                // reconciles cleanly — nothing is guessed: complete the bookkeeping
+                // and continue with the current observation. Anything short of that
+                // still refuses rather than guessing at a conflicting mutation.
+                const stale = state.pending;
+                try {
+                    publishAuthorityTransactionV3(input.coordRoot, stale.transaction);
+                    reconcileAuthorityTransactionV3(input.coordRoot, stale.transaction.transaction_id, input.reconciler);
+                }
+                catch {
+                    return {
+                        state: "pending_transaction",
+                        transaction_id: stale.transaction.transaction_id,
+                        mutation_kind: stale.transaction.mutation.kind,
+                    };
+                }
+                applyCoordinationEvent(state, stale.source_id, stale.transaction, eventFromTransaction(stale.transaction));
+                state.pending = undefined;
+                publishCoordinationState(path, state);
+            }
+            else {
+                const pending = state.pending;
+                publishAuthorityTransactionV3(input.coordRoot, pending.transaction);
+                const receipt = reconcileAuthorityTransactionV3(input.coordRoot, pending.transaction.transaction_id, input.reconciler);
+                const event = eventFromTransaction(pending.transaction);
+                applyCoordinationEvent(state, pending.source_id, pending.transaction, event);
+                state.pending = undefined;
+                publishCoordinationState(path, state);
+                return { state: "recorded", event, receipt, recovered: true };
+            }
+        }
+        const already = state?.observations.find((observation) => observation.source_id === sourceId);
+        if (already) {
+            return {
+                state: "already_recorded",
+                event_id: already.event_id,
+                transaction_id: already.transaction_id,
+            };
+        }
+        if (!state)
+            state = newCoordinationState(input, hook, epochId);
+        const transactionId = `txn_${randomUUID()}`;
+        const fingerprintContext = fingerprintContextV3(input.coordRoot, rootId, state.generation_id, state.privacy_epoch_id);
+        const waitId = (input.signal === "wait-started" || input.signal === "wait-ended") &&
+            "wait_id" in input.observation
+            ? input.observation.wait_id
+            : undefined;
+        let waitSpan = waitId ? state.open_waits[waitId] : undefined;
+        if (input.signal === "wait-started" && waitId && !waitSpan) {
+            waitSpan = openSpanStateV3({
+                span_id: spanIdV3(),
+                parent_span_id: hook.current_turn_span?.span_id ?? hook.session_span.span_id,
+                boot_id: state.boot_id,
+                clock: {
+                    observed_at: input.observed_at ?? new Date().toISOString(),
+                    ...(input.monotonic_ns ? { monotonic_ns: input.monotonic_ns } : {}),
+                },
+            });
+            state.open_waits[waitId] = waitSpan;
+        }
+        if (input.signal === "wait-ended" && !waitSpan) {
+            return { state: "generation_unavailable", reason: "wait_span_not_started" };
+        }
+        const normalized = normalizeCoordinationAuthorityV3(input.signal, input.observation, {
+            coordRoot: input.coordRoot,
+            root_id: rootId,
+            instance_id: state.actor_instance_id,
+            session_id: state.session_id,
+            generation_id: state.generation_id,
+            attestation_id: state.attestation_id,
+            producer_id: state.producer_id,
+            boot_id: state.boot_id,
+            sequence: state.next_sequence,
+            build_id: state.build_id,
+            platform: state.platform,
+            bridge: state.bridge,
+            actor_instance_id: state.actor_instance_id,
+            subject_instance_id: input.subject_instance_id,
+            transaction_id: transactionId,
+            caused_by: [
+                state.last_event_id,
+                ...(input.signal === "wait-ended" && waitSpan?.open_event_id
+                    ? [waitSpan.open_event_id]
+                    : []),
+            ].filter((value, index, values) => values.indexOf(value) === index),
+            observed_at: input.observed_at,
+            monotonic_ns: input.monotonic_ns,
+            clock_id: state.clock_id,
+            span_id: waitSpan?.span_id,
+            parent_span_id: waitSpan?.parent_span_id,
+            terminal_span: input.signal === "wait-ended" && waitSpan
+                ? closeSpanStateV3(waitSpan, {
+                    boot_id: state.boot_id,
+                    clock: {
+                        observed_at: input.observed_at ?? new Date().toISOString(),
+                        ...(input.monotonic_ns ? { monotonic_ns: input.monotonic_ns } : {}),
+                    },
+                })
+                : undefined,
+            fingerprintContext,
+            attribution_method: "session_env",
+        });
+        markObservedClockRegressionV3(normalized.event, state.last_observed_at);
+        const transaction = buildAuthorityTransactionV3({
+            transaction_id: transactionId,
+            expected_prior_state_digest: input.expected_prior_state_digest,
+            desired_state_digest: input.desired_state_digest,
+            actor_instance_id: state.actor_instance_id,
+            subject_instance_id: input.subject_instance_id,
+            mutation: normalized.mutation,
+            event: normalized.event,
+        });
+        if (input.signal === "wait-ended" && waitId)
+            delete state.open_waits[waitId];
+        state.pending = { source_id: sourceId, transaction };
+        publishCoordinationState(path, state);
+        publishAuthorityTransactionV3(input.coordRoot, transaction);
+        const receipt = reconcileAuthorityTransactionV3(input.coordRoot, transaction.transaction_id, input.reconciler);
+        applyCoordinationEvent(state, sourceId, transaction, normalized.event);
+        state.pending = undefined;
+        publishCoordinationState(path, state);
+        return { state: "recorded", event: normalized.event, receipt, recovered: false };
+    }
+    finally {
+        lease.release();
+    }
+}
+function newCoordinationState(input, hook, epochId) {
+    return {
+        format: COORDINATION_STATE_FORMAT,
+        format_version: COORDINATION_STATE_VERSION,
+        adapter: input.adapter,
+        actor_instance_id: input.actor_instance_id,
+        session_id: hook.session_id,
+        generation_id: hook.generation_id,
+        attestation_id: hook.attestation_id,
+        privacy_epoch_id: epochId,
+        producer_id: input.producer_id,
+        boot_id: `boot_${randomUUID()}`,
+        build_id: input.build_id,
+        platform: input.platform,
+        bridge: input.bridge,
+        clock_id: clockIdV3(),
+        next_sequence: 1,
+        last_event_id: hook.last_event_id,
+        observations: [],
+        open_waits: {},
+    };
+}
+function matchesHookState(state, hook, input, epochId) {
+    return (state.adapter === input.adapter &&
+        state.actor_instance_id === input.actor_instance_id &&
+        state.session_id === hook.session_id &&
+        state.generation_id === hook.generation_id &&
+        state.attestation_id === hook.attestation_id &&
+        state.privacy_epoch_id === epochId &&
+        state.producer_id === input.producer_id &&
+        state.build_id === input.build_id &&
+        state.platform === input.platform &&
+        state.bridge === input.bridge);
+}
+function applyCoordinationEvent(state, sourceId, transaction, event) {
+    state.next_sequence += 1;
+    state.last_event_id = event.event_id;
+    state.last_observed_at = event.time.observed_at;
+    state.observations.push({
+        source_id: sourceId,
+        event_id: event.event_id,
+        transaction_id: transaction.transaction_id,
+    });
+    if (state.observations.length > MAX_OBSERVATIONS)
+        state.observations.shift();
+}
+function eventFromTransaction(transaction) {
+    return JSON.parse(transaction.event_row);
+}
+function coordinationStatePath(coordRoot, producerSource) {
+    return join(resolve(coordRoot), EVENT_V3_LEDGER_RELATIVE_ROOT, "private-producers/agent-coord", `${producerSource}.json`);
+}
+function acquireCoordinationLease(coordRoot, statePath) {
+    const directory = join(statePath, "..");
+    const producerRoot = join(resolve(coordRoot), EVENT_V3_LEDGER_RELATIVE_ROOT, "private-producers");
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    chmodSync(producerRoot, 0o700);
+    chmodSync(directory, 0o700);
+    return acquireNoClobberLease({
+        path: `${statePath}.lease`,
+        scope: "event-v3-coordination-producer",
+        authoritySha256: createHash("sha256")
+            .update(resolve(coordRoot))
+            .update("\0")
+            .update(statePath)
+            .digest("hex"),
+        staleAfterMs: 5_000,
+        validateStaleOwner: (owner) => owner.host === hostname() && !pidIsAlive(owner.pid),
+    });
+}
+function publishCoordinationState(path, state) {
+    const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
+    let fd;
+    try {
+        fd = openSync(temporary, "wx", 0o600);
+        writeFileSync(fd, `${JSON.stringify(state)}\n`, "utf8");
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = undefined;
+        renameSync(temporary, path);
+        chmodSync(path, 0o600);
+        fsyncParentDirectory(path);
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
+}
+function readCoordinationState(path) {
+    if ((statSync(path).mode & 0o077) !== 0) {
+        throw new Error("V3 coordination state is not owner-only");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new Error("V3 coordination state is unreadable");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("V3 coordination state is invalid");
+    }
+    const state = parsed;
+    const allowed = new Set([
+        "actor_instance_id",
+        "adapter",
+        "attestation_id",
+        "boot_id",
+        "bridge",
+        "build_id",
+        "clock_id",
+        "format",
+        "format_version",
+        "generation_id",
+        "last_event_id",
+        "last_observed_at",
+        "next_sequence",
+        "observations",
+        "open_waits",
+        "pending",
+        "platform",
+        "privacy_epoch_id",
+        "producer_id",
+        "session_id",
+    ]);
+    if (Object.keys(state).some((key) => !allowed.has(key)) ||
+        state.format !== COORDINATION_STATE_FORMAT ||
+        state.format_version !== COORDINATION_STATE_VERSION ||
+        !["claude-code", "codex", "cursor"].includes(state.adapter) ||
+        !/^inst_[a-zA-Z0-9._-]{1,128}$/.test(state.actor_instance_id) ||
+        !/^sid_[a-f0-9]{64}$/.test(state.session_id) ||
+        !/^gen_[0-9a-f-]{36}$/.test(state.generation_id) ||
+        !/^att_[0-9a-f-]{36}$/.test(state.attestation_id) ||
+        !/^pep_[a-zA-Z0-9._-]+$/.test(state.privacy_epoch_id) ||
+        !/^prd_[a-zA-Z0-9._-]+$/.test(state.producer_id) ||
+        !/^boot_[a-zA-Z0-9._-]+$/.test(state.boot_id) ||
+        !/^build_[a-zA-Z0-9._-]+$/.test(state.build_id) ||
+        !["linux", "windows", "macos", "unknown"].includes(state.platform) ||
+        (state.bridge !== undefined && state.bridge !== "codex-wsl") ||
+        !/^clk_[0-9a-f-]{36}$/.test(state.clock_id) ||
+        !/^evt_[0-9a-f-]{36}$/.test(state.last_event_id) ||
+        (state.last_observed_at !== undefined &&
+            !Number.isFinite(Date.parse(state.last_observed_at))) ||
+        !Array.isArray(state.observations) ||
+        !state.open_waits ||
+        typeof state.open_waits !== "object" ||
+        Array.isArray(state.open_waits) ||
+        Object.entries(state.open_waits).some(([waitId, span]) => !/^[a-zA-Z0-9][a-zA-Z0-9._:/+-]{0,127}$/.test(waitId) ||
+            !/^span_[0-9a-f-]{36}$/.test(span.span_id) ||
+            !Number.isFinite(Date.parse(span.opened_at)) ||
+            !/^boot_[a-zA-Z0-9._-]+$/.test(span.boot_id)) ||
+        state.observations.length > MAX_OBSERVATIONS ||
+        state.observations.some((observation) => !/^hid_[a-f0-9]{64}$/.test(observation.source_id) ||
+            !/^evt_[0-9a-f-]{36}$/.test(observation.event_id) ||
+            !/^txn_[0-9a-f-]{36}$/.test(observation.transaction_id)) ||
+        !Number.isSafeInteger(state.next_sequence) ||
+        state.next_sequence < 1 ||
+        (state.pending !== undefined &&
+            (!/^hid_[a-f0-9]{64}$/.test(state.pending.source_id) ||
+                !validStoredTransaction(state.pending.transaction)))) {
+        throw new Error("V3 coordination state is invalid");
+    }
+    return state;
+}
+function validStoredTransaction(transaction) {
+    try {
+        const event = eventFromTransaction(transaction);
+        const rebuilt = buildAuthorityTransactionV3({
+            transaction_id: transaction.transaction_id,
+            expected_prior_state_digest: transaction.expected_prior_state_digest,
+            desired_state_digest: transaction.desired_state_digest,
+            actor_instance_id: transaction.actor_instance_id,
+            subject_instance_id: transaction.subject_instance_id,
+            mutation: transaction.mutation,
+            event,
+        });
+        return canonicalJsonV3(rebuilt) === canonicalJsonV3(transaction);
+    }
+    catch {
+        return false;
+    }
+}
+function pidIsAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid < 1)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}

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

@@ -0,0 +1,90 @@
+import type { AuthorityMutationV3 } from "../authority-outbox.js";
+import { type FingerprintContextV3 } from "../canonical.js";
+import type { EventV3, SpanSummaryV3 } from "../contract.js";
+export type CoordinationAuthoritySignalV3 = "task-changed" | "lifecycle-changed" | "claim-changed" | "identity-attested" | "decision-state-changed" | "wait-started" | "wait-ended";
+export interface CoordinationProducerContextV3 {
+    coordRoot: string;
+    root_id: `root_${string}`;
+    instance_id: `inst_${string}`;
+    session_id: `sid_${string}`;
+    generation_id: `gen_${string}`;
+    attestation_id: `att_${string}`;
+    producer_id: `prd_${string}`;
+    boot_id: `boot_${string}`;
+    sequence: number;
+    build_id: `build_${string}`;
+    platform: "linux" | "windows" | "macos" | "unknown";
+    bridge?: "codex-wsl";
+    actor_instance_id: `inst_${string}`;
+    subject_instance_id: `inst_${string}`;
+    transaction_id: `txn_${string}`;
+    caused_by?: `evt_${string}`[];
+    event_id?: `evt_${string}`;
+    observed_at?: string;
+    recorded_at?: string;
+    monotonic_ns?: string;
+    clock_id?: `clk_${string}`;
+    fingerprintContext: FingerprintContextV3;
+    attribution_method: "session_env" | "heartbeat_match" | "explicit_argument";
+    span_id?: `span_${string}`;
+    parent_span_id?: `span_${string}`;
+    terminal_span?: SpanSummaryV3;
+}
+interface CoordinationObservationBaseV3 {
+    native_observation_id: string;
+}
+export interface TaskChangedObservationV3 extends CoordinationObservationBaseV3 {
+    state: "set" | "cleared";
+    prior_state?: string;
+    task?: string;
+}
+export interface LifecycleChangedObservationV3 extends CoordinationObservationBaseV3 {
+    state: "active" | "blocked" | "done";
+    prior_state?: string;
+    reason_code?: string;
+}
+export interface ClaimChangedObservationV3 extends CoordinationObservationBaseV3 {
+    operation: "acquired" | "released";
+    target: unknown;
+    access: "read" | "write";
+}
+export interface IdentityAttestedObservationV3 extends CoordinationObservationBaseV3 {
+    identity_id: string;
+    method: string;
+}
+export interface DecisionStateChangedObservationV3 extends CoordinationObservationBaseV3 {
+    decision_id: string;
+    prior_state?: string;
+    outcome: "approved" | "denied" | "deferred";
+    record_digest: `sha256:${string}`;
+}
+export interface WaitStartedObservationV3 extends CoordinationObservationBaseV3 {
+    wait_id: string;
+    kind: "permission" | "approval" | "decision" | "operator_input" | "dependency" | "scheduled";
+    wake_at?: string;
+}
+export interface WaitEndedObservationV3 extends CoordinationObservationBaseV3 {
+    wait_id: string;
+    outcome: "succeeded" | "failed" | "cancelled" | "timed_out" | "denied" | "interrupted" | "unknown";
+}
+export interface CoordinationObservationBySignalV3 {
+    "task-changed": TaskChangedObservationV3;
+    "lifecycle-changed": LifecycleChangedObservationV3;
+    "claim-changed": ClaimChangedObservationV3;
+    "identity-attested": IdentityAttestedObservationV3;
+    "decision-state-changed": DecisionStateChangedObservationV3;
+    "wait-started": WaitStartedObservationV3;
+    "wait-ended": WaitEndedObservationV3;
+}
+export interface NormalizedCoordinationAuthorityV3 {
+    event: EventV3;
+    mutation: AuthorityMutationV3;
+}
+/**
+ * Translate one authority-bearing coordination observation without retaining
+ * raw task text or claim targets. The event and mutation are returned as one
+ * unit so callers cannot independently construct contradictory records.
+ */
+export declare function normalizeCoordinationAuthorityV3<S extends CoordinationAuthoritySignalV3>(signal: S, observation: CoordinationObservationBySignalV3[S], context: CoordinationProducerContextV3): NormalizedCoordinationAuthorityV3;
+export {};
+//# sourceMappingURL=coordination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coordination.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/v3/producers/coordination.ts"],"names":[],"mappings":"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"}