harnery 0.32.0 → 0.34.0

package/dist/core/events/v3/control.js

@@ -0,0 +1,419 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { buildEventV3 } from "./builder.js";
+import { canonicalJsonV3, sha256V3 } from "./canonical.js";
+import { EVENT_V3_SCHEMA_DIGEST } from "./generated.js";
+import { activationIdV3, eventIdV3, genesisIdV3 } from "./ids.js";
+import { readLedgerV3 } from "./reader.js";
+import { validateEventV3 } from "./validate.js";
+import { writeEventV3 } from "./writer.js";
+export const EVENT_V3_GENESIS_MANIFEST = ".harnery/ledgers/v3/genesis.json";
+export const EVENT_V3_ACTIVATION_MANIFEST = ".harnery/ledgers/v3/activation.json";
+/** Build a complete immutable candidate packet without writing it or opening a gate. */
+export function buildCandidateGenesisManifestV3(input) {
+    const profile = {
+        ...input.profile,
+        producer_build_ids: [...input.profile.producer_build_ids].sort(),
+        adapter_capability_profile_digests: [
+            ...input.profile.adapter_capability_profile_digests,
+        ].sort(),
+    };
+    const event = buildEventV3("ledger.genesis", {
+        event_id: input.event_id,
+        producer: { ...input.producer, component: "recovery" },
+        scope: { root_id: input.root_id, instance_id: input.instance_id },
+        links: { caused_by: [] },
+        provenance: controlProvenance("cutover.genesis", input.instance_id),
+        observed_at: profile.candidate_created_at,
+        recorded_at: profile.candidate_created_at,
+        payload: {
+            genesis_id: input.genesis_id ?? genesisIdV3(),
+            genesis_profile_digest: candidateProfileDigestV3(profile),
+            contract_digest: profile.contract_source_digest,
+            generated_schema_digest: profile.initial_schema_digest,
+            canonicalizer: profile.canonicalizer_version,
+            privacy_epoch_id: profile.privacy_key_epoch,
+            candidate_created_at: profile.candidate_created_at,
+        },
+    });
+    const manifest = {
+        manifest_version: 1,
+        kind: "candidate_genesis",
+        profile,
+        event,
+    };
+    const validated = validateCandidateGenesisManifestV3(manifest);
+    if (!validated.ok)
+        throw new Error(`candidate_genesis_invalid:${validated.reason}`);
+    return validated.value;
+}
+/** Build an approval-bound activation packet without writing it or opening a gate. */
+export function buildActivationManifestV3(input) {
+    const candidate = validateCandidateGenesisManifestV3(input.candidate);
+    if (!candidate.ok)
+        throw new Error(`candidate_genesis_invalid:${candidate.reason}`);
+    const eventId = input.event_id ?? eventIdV3();
+    const activationId = input.activation_id ?? activationIdV3();
+    const candidateDigest = candidateManifestDigestV3(candidate.value);
+    const genesisId = candidate.value.event.payload.genesis_id;
+    const scope = candidate.value.event.scope;
+    const event = buildEventV3("ledger.activated", {
+        event_id: eventId,
+        producer: { ...input.producer, component: "recovery" },
+        scope,
+        links: { caused_by: [candidate.value.event.event_id] },
+        provenance: controlProvenance("cutover.activation", scope.instance_id),
+        observed_at: input.activation_approved_at,
+        recorded_at: input.activation_approved_at,
+        payload: {
+            activation_id: activationId,
+            genesis_id: genesisId,
+            candidate_digest: candidateDigest,
+            approval_record_id: input.approval_record_id,
+            eligible_after_event_id: eventId,
+            activated_at: input.activation_approved_at,
+        },
+    });
+    const manifest = {
+        manifest_version: 1,
+        kind: "activation",
+        activation_id: activationId,
+        genesis_id: genesisId,
+        candidate_manifest_digest: candidateDigest,
+        approval_record_id: input.approval_record_id,
+        activation_approved_at: input.activation_approved_at,
+        event,
+    };
+    const validated = validateActivationManifestV3(manifest, candidate.value);
+    if (!validated.ok)
+        throw new Error(`activation_invalid:${validated.reason}`);
+    return validated.value;
+}
+/** Validate an in-memory candidate with the same strict rules as the live gate. */
+export function validateCandidateGenesisManifestV3(value) {
+    return parseGenesisManifestValue(value);
+}
+/** Validate an in-memory activation against one exact candidate packet. */
+export function validateActivationManifestV3(value, candidate) {
+    const validatedCandidate = validateCandidateGenesisManifestV3(candidate);
+    if (!validatedCandidate.ok)
+        return fail(`candidate_${validatedCandidate.reason}`);
+    return parseActivationManifestValue(value, validatedCandidate.value, candidateManifestDigestV3(validatedCandidate.value));
+}
+/**
+ * Resolve the session/evidence gate from exact control-file and ledger-event pairs.
+ * This function never repairs or creates state. Any ambiguity keeps the gate closed.
+ */
+export function readEventV3ControlState(coordRoot) {
+    const genesisPath = join(coordRoot, EVENT_V3_GENESIS_MANIFEST);
+    const activationPath = join(coordRoot, EVENT_V3_ACTIVATION_MANIFEST);
+    const hasGenesis = existsSync(genesisPath);
+    const hasActivation = existsSync(activationPath);
+    if (!hasGenesis && !hasActivation) {
+        const ledger = readControlLedger(coordRoot);
+        const hasUnboundControlEvent = ledger.events.some(({ event }) => event.event_type === "ledger.genesis" || event.event_type === "ledger.activated");
+        if (hasUnboundControlEvent) {
+            return { state: "invalid", reason: "control_event_without_manifest" };
+        }
+        return { state: "closed", reason: "no_candidate" };
+    }
+    if (!hasGenesis)
+        return { state: "invalid", reason: "activation_without_genesis_manifest" };
+    const genesisResult = readGenesisManifest(genesisPath);
+    if (!genesisResult.ok)
+        return { state: "invalid", reason: genesisResult.reason };
+    const genesis = genesisResult.value;
+    const candidateDigest = candidateManifestDigestV3(genesis);
+    const ledger = readControlLedger(coordRoot);
+    if (!ledger.complete) {
+        return { state: "invalid", reason: "ledger_integrity_failure" };
+    }
+    const genesisPair = exactEventPair(ledger.events.map((entry) => entry.event), genesis.event);
+    if (genesisPair === "conflict")
+        return { state: "invalid", reason: "genesis_event_mismatch" };
+    if (genesisPair === "missing") {
+        return hasActivation
+            ? { state: "invalid", reason: "activation_before_genesis_event" }
+            : { state: "repairable", reason: "genesis_event_missing", genesis };
+    }
+    if (!hasActivation) {
+        if (ledger.events.some(({ event }) => event.event_type === "ledger.activated")) {
+            return { state: "invalid", reason: "activation_event_without_manifest" };
+        }
+        return { state: "candidate", genesis, candidate_manifest_digest: candidateDigest };
+    }
+    const activationResult = readActivationManifest(activationPath, genesis, candidateDigest);
+    if (!activationResult.ok)
+        return { state: "invalid", reason: activationResult.reason };
+    const activation = activationResult.value;
+    const activationPair = exactEventPair(ledger.events.map((entry) => entry.event), activation.event);
+    if (activationPair === "conflict") {
+        return { state: "invalid", reason: "activation_event_mismatch" };
+    }
+    if (activationPair === "missing") {
+        return {
+            state: "repairable",
+            reason: "activation_event_missing",
+            genesis,
+            activation,
+        };
+    }
+    return {
+        state: "active",
+        genesis,
+        activation,
+        candidate_manifest_digest: candidateDigest,
+    };
+}
+export function eventV3WriteGateOpen(coordRoot, mode) {
+    const control = readEventV3ControlState(coordRoot);
+    return mode === "candidate" ? control.state === "candidate" : control.state === "active";
+}
+/** Repair only a manifest-first crash by appending the exact pre-minted event. */
+export function repairEventV3ControlPair(coordRoot) {
+    const control = readEventV3ControlState(coordRoot);
+    if (control.state !== "repairable")
+        return control;
+    const event = control.reason === "genesis_event_missing" ? control.genesis.event : control.activation?.event;
+    if (!event)
+        return { state: "invalid", reason: "repair_event_unavailable" };
+    const result = writeEventV3(coordRoot, event);
+    if (result.state !== "committed") {
+        return { state: "invalid", reason: "control_event_repair_not_committed" };
+    }
+    return readEventV3ControlState(coordRoot);
+}
+export function candidateProfileDigestV3(profile) {
+    return sha256V3(canonicalJsonV3(profile));
+}
+export function candidateManifestDigestV3(manifest) {
+    return sha256V3(canonicalJsonV3(manifest));
+}
+function readGenesisManifest(path) {
+    const parsed = readJsonObject(path);
+    if (!parsed.ok)
+        return parsed;
+    return parseGenesisManifestValue(parsed.value);
+}
+function parseGenesisManifestValue(value) {
+    if (!isObject(value))
+        return fail("genesis_manifest_not_object");
+    if (!exactKeys(value, ["event", "kind", "manifest_version", "profile"])) {
+        return fail("genesis_manifest_shape_invalid");
+    }
+    if (value.manifest_version !== 1 || value.kind !== "candidate_genesis") {
+        return fail("genesis_manifest_version_invalid");
+    }
+    const profile = parseCandidateProfile(value.profile);
+    if (!profile.ok)
+        return profile;
+    const validation = validateEventV3(value.event);
+    if (!validation.ok || validation.event?.event_type !== "ledger.genesis") {
+        return fail("genesis_event_invalid");
+    }
+    const event = validation.event;
+    if (event.producer.sequence !== 1) {
+        return fail("genesis_producer_sequence_invalid");
+    }
+    if (event.contract.schema_digest !== EVENT_V3_SCHEMA_DIGEST ||
+        event.payload.genesis_profile_digest !== candidateProfileDigestV3(profile.value) ||
+        event.payload.contract_digest !== profile.value.contract_source_digest ||
+        event.payload.generated_schema_digest !== profile.value.initial_schema_digest ||
+        event.payload.canonicalizer !== profile.value.canonicalizer_version ||
+        event.payload.privacy_epoch_id !== profile.value.privacy_key_epoch ||
+        event.payload.candidate_created_at !== profile.value.candidate_created_at) {
+        return fail("genesis_profile_binding_mismatch");
+    }
+    return {
+        ok: true,
+        value: { manifest_version: 1, kind: "candidate_genesis", profile: profile.value, event },
+    };
+}
+function readActivationManifest(path, genesis, candidateDigest) {
+    const parsed = readJsonObject(path);
+    if (!parsed.ok)
+        return parsed;
+    return parseActivationManifestValue(parsed.value, genesis, candidateDigest);
+}
+function parseActivationManifestValue(value, genesis, candidateDigest) {
+    if (!isObject(value))
+        return fail("activation_manifest_not_object");
+    if (!exactKeys(value, [
+        "activation_approved_at",
+        "activation_id",
+        "approval_record_id",
+        "candidate_manifest_digest",
+        "event",
+        "genesis_id",
+        "kind",
+        "manifest_version",
+    ])) {
+        return fail("activation_manifest_shape_invalid");
+    }
+    if (value.manifest_version !== 1 || value.kind !== "activation") {
+        return fail("activation_manifest_version_invalid");
+    }
+    const activationId = typeof value.activation_id === "string" && /^act_[0-9a-f-]{36}$/.test(value.activation_id)
+        ? value.activation_id
+        : undefined;
+    const genesisId = safeString(value.genesis_id, "gex_");
+    const approvalRecordId = safeToken(value.approval_record_id);
+    const approvedAt = safeTimestamp(value.activation_approved_at);
+    if (!activationId || !genesisId || !approvalRecordId || !approvedAt) {
+        return fail("activation_manifest_fields_invalid");
+    }
+    if (value.candidate_manifest_digest !== candidateDigest) {
+        return fail("activation_candidate_digest_mismatch");
+    }
+    const validation = validateEventV3(value.event);
+    if (!validation.ok || validation.event?.event_type !== "ledger.activated") {
+        return fail("activation_event_invalid");
+    }
+    const event = validation.event;
+    if (!activationProducerSequenceValid(genesis.event, event)) {
+        return fail("activation_producer_sequence_invalid");
+    }
+    if (genesisId !== genesis.event.payload.genesis_id ||
+        event.payload.activation_id !== activationId ||
+        event.payload.genesis_id !== genesisId ||
+        event.payload.candidate_digest !== candidateDigest ||
+        event.payload.approval_record_id !== approvalRecordId ||
+        event.payload.activated_at !== approvedAt) {
+        return fail("activation_profile_binding_mismatch");
+    }
+    return {
+        ok: true,
+        value: {
+            manifest_version: 1,
+            kind: "activation",
+            activation_id: activationId,
+            genesis_id: genesisId,
+            candidate_manifest_digest: candidateDigest,
+            approval_record_id: approvalRecordId,
+            activation_approved_at: approvedAt,
+            event,
+        },
+    };
+}
+/** Mirror the reader's sequence key: a continuing boot advances, while a new boot starts at one. */
+function activationProducerSequenceValid(genesis, activation) {
+    const sameBoot = activation.producer.producer_id === genesis.producer.producer_id &&
+        activation.producer.boot_id === genesis.producer.boot_id;
+    return sameBoot
+        ? activation.producer.sequence === genesis.producer.sequence + 1
+        : activation.producer.sequence === 1;
+}
+function parseCandidateProfile(value) {
+    if (!isObject(value))
+        return fail("genesis_profile_invalid");
+    const keys = [
+        "adapter_capability_profile_digests",
+        "candidate_created_at",
+        "canonicalizer_version",
+        "config_digest",
+        "contract_source_digest",
+        "fingerprint_version",
+        "harnery_commit",
+        "host_repository_commit",
+        "initial_schema_digest",
+        "privacy_key_epoch",
+        "producer_build_ids",
+    ];
+    if (!exactKeys(value, keys))
+        return fail("genesis_profile_shape_invalid");
+    if (isSha256(value.initial_schema_digest) &&
+        value.initial_schema_digest !== EVENT_V3_SCHEMA_DIGEST) {
+        return fail("genesis_schema_digest_incompatible");
+    }
+    if (!isSha256(value.initial_schema_digest) ||
+        !isSha256(value.contract_source_digest) ||
+        !isSha256(value.config_digest) ||
+        value.canonicalizer_version !== "harnery-jcs-nfc-v1" ||
+        !safeString(value.privacy_key_epoch, "pep_") ||
+        !safeToken(value.harnery_commit) ||
+        !safeToken(value.host_repository_commit) ||
+        !safeToken(value.fingerprint_version) ||
+        !safeTimestamp(value.candidate_created_at) ||
+        !sortedSafeTokenArray(value.producer_build_ids) ||
+        !sortedSha256Array(value.adapter_capability_profile_digests)) {
+        return fail("genesis_profile_fields_invalid");
+    }
+    return { ok: true, value: value };
+}
+function exactEventPair(events, expected) {
+    const matches = events.filter((event) => event.event_id === expected.event_id);
+    if (matches.length === 0)
+        return "missing";
+    const expectedRow = canonicalJsonV3(expected);
+    return matches.every((event) => canonicalJsonV3(event) === expectedRow) ? "exact" : "conflict";
+}
+function readControlLedger(coordRoot) {
+    const ledger = readLedgerV3(coordRoot);
+    // An immutable manifest is published before its pre-minted control event.
+    // During that repairable window an empty physical ledger necessarily reports
+    // missing_genesis; the control pair owns that one diagnostic and repairs it.
+    const diagnostics = ledger.diagnostics.filter(({ code }) => code !== "missing_genesis");
+    return { ...ledger, diagnostics, complete: diagnostics.length === 0 };
+}
+function controlProvenance(sourceEvent, subjectInstanceId) {
+    return {
+        source_event: sourceEvent,
+        attestation: "operator",
+        confidence: "exact",
+        attribution: {
+            method: "explicit_argument",
+            state: "verified",
+            subject_instance_id: subjectInstanceId,
+        },
+    };
+}
+function readJsonObject(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        return isObject(value) ? { ok: true, value } : fail("control_manifest_not_object");
+    }
+    catch {
+        return fail("control_manifest_unreadable");
+    }
+}
+function fail(reason) {
+    return { ok: false, reason };
+}
+function isObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function exactKeys(value, expected) {
+    return Object.keys(value).sort().join("\0") === [...expected].sort().join("\0");
+}
+function safeToken(value) {
+    return typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._:/+-]{0,127}$/.test(value)
+        ? value
+        : undefined;
+}
+function safeString(value, prefix) {
+    return typeof value === "string" && value.startsWith(prefix) && value.length <= 128
+        ? value
+        : undefined;
+}
+function safeTimestamp(value) {
+    return typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value)
+        ? value
+        : undefined;
+}
+function isSha256(value) {
+    return typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value);
+}
+function sortedSafeTokenArray(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.length <= 64 &&
+        value.every((item, index) => index === 0 || value[index - 1] < item) &&
+        value.every((item) => safeToken(item) !== undefined));
+}
+function sortedSha256Array(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.length <= 64 &&
+        value.every((item, index) => index === 0 || value[index - 1] < item) &&
+        value.every(isSha256));
+}

package/dist/core/events/v3/coordination-view.d.ts

@@ -0,0 +1,69 @@
+import type { RuntimeAttestationV3 } from "./contract.js";
+import { EVENT_V3_SAFETY_REDUCER_BUILD, type GenerationSafetyStateV3, type SafetyProjectionDiagnosticV3, type SafetyProjectionV3, type WaitProjectionV3 } from "./projection.js";
+import { type ReadLedgerV3Result } from "./reader.js";
+export declare const EVENT_V3_COORDINATION_VIEW_VERSION: 1;
+export interface CoordinationGenerationViewV3 {
+    contract_major: 2;
+    instance_id: string;
+    session_id: string;
+    generation_id: string;
+    root_id: string;
+    run_id?: string;
+    workflow_id?: string;
+    workflow_agent_id?: string;
+    identity_id?: string;
+    runtime_attestation: RuntimeAttestationV3;
+    parent_generation_id?: string;
+    delegation_id?: string;
+    delegation_role?: string;
+    phase: "live" | "terminal";
+    activity: "working" | "needs_input" | "idle" | "terminal";
+    task_state?: string;
+    task_state_updated_at?: string;
+    lifecycle_state?: string;
+    lifecycle_state_updated_at?: string;
+    presence_state?: string;
+    presence_state_updated_at?: string;
+    started_at: string;
+    last_observed_at: string;
+    last_event_id: string;
+    source_position: {
+        segment_ordinal: number;
+        byte_offset: number;
+    };
+    waits: WaitProjectionV3[];
+    files_touched: string[];
+    progress_count: number;
+    last_context_event_id?: string;
+    provisional_termination?: GenerationSafetyStateV3["provisional_termination"];
+    terminal?: GenerationSafetyStateV3["terminal"];
+    evidence_complete: boolean;
+    authority_eligible: boolean;
+}
+export interface CoordinationViewV3 {
+    projection_version: typeof EVENT_V3_COORDINATION_VIEW_VERSION;
+    contract_major: 2;
+    reducer_build_id: typeof EVENT_V3_SAFETY_REDUCER_BUILD;
+    source_complete: boolean;
+    authority_safe: boolean;
+    diagnostics: SafetyProjectionDiagnosticV3[];
+    instances: Record<string, CoordinationGenerationViewV3>;
+    terminal_generations: Record<string, CoordinationGenerationViewV3>;
+    delegations: SafetyProjectionV3["delegations"];
+    decisions: SafetyProjectionV3["decisions"];
+    health: SafetyProjectionV3["health"];
+}
+export declare class CoordinationViewV3Error extends Error {
+    readonly diagnostics: SafetyProjectionDiagnosticV3[];
+    constructor(diagnostics: SafetyProjectionDiagnosticV3[]);
+}
+/** Read the complete V3 catalog and derive the disposable coordination view. */
+export declare function readCoordinationViewV3(coordRoot: string): CoordinationViewV3;
+/**
+ * Build the one privacy-safe lifecycle view shared by heartbeat, status,
+ * finalization, web, and Codec adapters. This function performs no writes.
+ */
+export declare function projectCoordinationViewV3(read: ReadLedgerV3Result): CoordinationViewV3;
+/** Refuse authority decisions while still allowing callers to render diagnostics. */
+export declare function requireAuthoritySafeCoordinationViewV3(view: CoordinationViewV3): CoordinationViewV3;
+//# sourceMappingURL=coordination-view.d.ts.map

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

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

package/dist/core/events/v3/coordination-view.js

@@ -0,0 +1,119 @@
+import { EVENT_V3_SAFETY_REDUCER_BUILD, reduceSafetyProjectionV3, } from "./projection.js";
+import { readLedgerV3 } from "./reader.js";
+export const EVENT_V3_COORDINATION_VIEW_VERSION = 1;
+export class CoordinationViewV3Error extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        super("event_v3_coordination_view:authority_unsafe");
+        this.diagnostics = diagnostics;
+        this.name = "CoordinationViewV3Error";
+    }
+}
+/** Read the complete V3 catalog and derive the disposable coordination view. */
+export function readCoordinationViewV3(coordRoot) {
+    return projectCoordinationViewV3(readLedgerV3(coordRoot));
+}
+/**
+ * Build the one privacy-safe lifecycle view shared by heartbeat, status,
+ * finalization, web, and Codec adapters. This function performs no writes.
+ */
+export function projectCoordinationViewV3(read) {
+    const safety = reduceSafetyProjectionV3(read);
+    const starts = new Map();
+    const eventGeneration = new Map();
+    for (const { event } of read.events) {
+        const generationId = "generation_id" in event.scope ? event.scope.generation_id : undefined;
+        if (generationId !== undefined) {
+            eventGeneration.set(event.event_id, generationId);
+        }
+        if (event.event_type === "session.started" && generationId !== undefined) {
+            starts.set(generationId, event);
+        }
+    }
+    const instances = {};
+    const terminalGenerations = {};
+    const states = Object.values(safety.generations).sort((left, right) => left.generation_id.localeCompare(right.generation_id));
+    for (const state of states) {
+        const started = starts.get(state.generation_id);
+        if (!started)
+            continue;
+        const diagnostics = safety.diagnostics.filter((diagnostic) => diagnostic.generation_id === state.generation_id ||
+            diagnostic.subject_instance_id === state.instance_id ||
+            (diagnostic.event_id !== undefined &&
+                eventGeneration.get(diagnostic.event_id) === state.generation_id) ||
+            diagnostic.code === "ledger_incomplete");
+        const delegation = Object.values(safety.delegations).find((candidate) => candidate.child_generation_id === state.generation_id);
+        const filesTouched = Object.values(safety.claims)
+            .filter((claim) => claim.subject_instance_id === state.instance_id &&
+            claim.access === "write" &&
+            claim.target_kind === "workspace_path" &&
+            claim.target_display !== undefined)
+            .map((claim) => claim.target_display)
+            .filter((path, index, all) => all.indexOf(path) === index)
+            .sort();
+        const view = {
+            contract_major: 2,
+            instance_id: state.instance_id,
+            session_id: state.session_id,
+            generation_id: state.generation_id,
+            root_id: started.scope.root_id,
+            run_id: started.scope.run_id,
+            workflow_id: started.scope.workflow_id,
+            workflow_agent_id: started.scope.workflow_agent_id,
+            identity_id: safety.identities[state.instance_id],
+            runtime_attestation: started.payload.runtime_attestation,
+            parent_generation_id: started.links
+                .parent_generation_id,
+            delegation_id: delegation?.delegation_id,
+            delegation_role: delegation?.role,
+            phase: state.phase,
+            activity: state.activity,
+            task_state: state.task_state,
+            task_state_updated_at: state.task_state_updated_at,
+            lifecycle_state: state.lifecycle_state,
+            lifecycle_state_updated_at: state.lifecycle_state_updated_at,
+            presence_state: state.presence_state,
+            presence_state_updated_at: state.presence_state_updated_at,
+            started_at: state.started_at,
+            last_observed_at: state.last_observed_at,
+            last_event_id: state.last_event_id,
+            source_position: {
+                segment_ordinal: state.last_segment_ordinal,
+                byte_offset: state.last_byte_offset,
+            },
+            waits: Object.values(state.waits).sort((left, right) => left.started_event_id.localeCompare(right.started_event_id)),
+            files_touched: state.phase === "live" ? filesTouched : [],
+            progress_count: state.progress_event_ids.length,
+            last_context_event_id: state.last_context_event_id,
+            provisional_termination: state.provisional_termination,
+            terminal: state.terminal,
+            evidence_complete: safety.evidence_complete && diagnostics.length === 0,
+            authority_eligible: safety.authority_safe && state.phase === "live",
+        };
+        if (state.phase === "terminal") {
+            terminalGenerations[state.generation_id] = view;
+        }
+        else if (safety.current_generation_by_instance[state.instance_id] === state.generation_id) {
+            instances[state.instance_id] = view;
+        }
+    }
+    return {
+        projection_version: EVENT_V3_COORDINATION_VIEW_VERSION,
+        contract_major: 2,
+        reducer_build_id: EVENT_V3_SAFETY_REDUCER_BUILD,
+        source_complete: read.complete,
+        authority_safe: safety.authority_safe,
+        diagnostics: safety.diagnostics,
+        instances,
+        terminal_generations: terminalGenerations,
+        delegations: safety.delegations,
+        decisions: safety.decisions,
+        health: safety.health,
+    };
+}
+/** Refuse authority decisions while still allowing callers to render diagnostics. */
+export function requireAuthoritySafeCoordinationViewV3(view) {
+    if (!view.authority_safe)
+        throw new CoordinationViewV3Error(view.diagnostics);
+    return view;
+}