project-tiny-context-harness 0.8.12 → 0.8.13

package/dist/lib/design-resource-recovery-writeback-shape.js

@@ -0,0 +1,155 @@
+import { DESIGN_RESOURCE_PATCH_SCHEMA } from "./design-resource-recovery-schema.js";
+import { arrayOf, digest, integer, literal, multilineText, object, oneOf, optionalArrayOf, stringSet, text, } from "./design-resource-recovery-codec-primitives.js";
+const ENCODINGS = ["utf8", "utf8-bom", "utf16le", "utf16be"];
+export function parseProviderReferences(value, label) {
+    const row = object(value, label, ["project", "run", "resources"]);
+    return {
+        project: parseProviderIdentity(row.project, `${label}.project`),
+        run: parseProviderIdentity(row.run, `${label}.run`),
+        resources: optionalArrayOf(row.resources, `${label}.resources`, parseProviderResourceIdentity),
+    };
+}
+export function parsePatch(value, label) {
+    const row = object(value, label, ["schema_version", "operations"]);
+    literal(row.schema_version, DESIGN_RESOURCE_PATCH_SCHEMA, `${label}.schema_version`);
+    return {
+        schema_version: DESIGN_RESOURCE_PATCH_SCHEMA,
+        operations: arrayOf(row.operations, `${label}.operations`, (item, itemLabel) => {
+            const operation = object(item, itemLabel, [
+                "operation_id",
+                "operation",
+                "target_key",
+                "delta_id",
+                "before_text",
+                "after_text",
+                "before_text_sha256",
+                "after_text_sha256",
+                "source_span",
+                "semantic_binding",
+                "expected_occurrences",
+            ]);
+            literal(operation.expected_occurrences, 1, `${itemLabel}.expected_occurrences`);
+            return {
+                operation_id: text(operation.operation_id, `${itemLabel}.operation_id`),
+                operation: oneOf(operation.operation, ["add", "replace", "remove"], `${itemLabel}.operation`),
+                target_key: text(operation.target_key, `${itemLabel}.target_key`),
+                delta_id: text(operation.delta_id, `${itemLabel}.delta_id`),
+                before_text: multilineText(operation.before_text, `${itemLabel}.before_text`),
+                after_text: multilineText(operation.after_text, `${itemLabel}.after_text`, { allowEmpty: true }),
+                before_text_sha256: digest(operation.before_text_sha256, `${itemLabel}.before_text_sha256`),
+                after_text_sha256: digest(operation.after_text_sha256, `${itemLabel}.after_text_sha256`),
+                source_span: parsePatchSourceSpan(operation.source_span, `${itemLabel}.source_span`),
+                semantic_binding: parsePatchSemanticBinding(operation.semantic_binding, `${itemLabel}.semantic_binding`),
+                expected_occurrences: 1,
+            };
+        }),
+    };
+}
+function parsePatchSourceSpan(value, label) {
+    const row = object(value, label, [
+        "coordinate_system",
+        "start_offset",
+        "end_offset",
+        "before_text_sha256",
+    ]);
+    literal(row.coordinate_system, "utf16-code-unit-v1", `${label}.coordinate_system`);
+    return {
+        coordinate_system: "utf16-code-unit-v1",
+        start_offset: integer(row.start_offset, `${label}.start_offset`),
+        end_offset: integer(row.end_offset, `${label}.end_offset`),
+        before_text_sha256: digest(row.before_text_sha256, `${label}.before_text_sha256`),
+    };
+}
+function parsePatchSemanticBinding(value, label) {
+    const row = object(value, label, [
+        "delta_id",
+        "target_key",
+        "before_semantics_sha256",
+        "after_semantics_sha256",
+        "before_text_projection",
+        "after_text_projection",
+    ]);
+    return {
+        delta_id: text(row.delta_id, `${label}.delta_id`),
+        target_key: text(row.target_key, `${label}.target_key`),
+        before_semantics_sha256: digest(row.before_semantics_sha256, `${label}.before_semantics_sha256`),
+        after_semantics_sha256: digest(row.after_semantics_sha256, `${label}.after_semantics_sha256`),
+        before_text_projection: parseTextProjection(row.before_text_projection, `${label}.before_text_projection`),
+        after_text_projection: parseTextProjection(row.after_text_projection, `${label}.after_text_projection`),
+    };
+}
+function parseTextProjection(value, label) {
+    if (value === null)
+        return null;
+    const row = object(value, label, [
+        "semantic_path",
+        "start_offset",
+        "end_offset",
+    ]);
+    return {
+        semantic_path: arrayOf(row.semantic_path, `${label}.semantic_path`, (item, itemLabel) => text(item, itemLabel), { allowEmpty: true }),
+        start_offset: integer(row.start_offset, `${label}.start_offset`),
+        end_offset: integer(row.end_offset, `${label}.end_offset`),
+    };
+}
+export function parseWritebackInput(value, label, complete) {
+    const fields = [
+        "target_locator",
+        "pre_write_raw_byte_digest",
+        "patch",
+        "patch_identity",
+        "expected_post_write_raw_byte_digest",
+        "resource_identities",
+        "proposal_written_delta_ids",
+    ];
+    if (complete)
+        fields.push("target_encoding", "target_eol_policy");
+    const row = object(value, label, fields);
+    const base = {
+        target_locator: text(row.target_locator, `${label}.target_locator`),
+        pre_write_raw_byte_digest: digest(row.pre_write_raw_byte_digest, `${label}.pre_write_raw_byte_digest`),
+        patch: parsePatch(row.patch, `${label}.patch`),
+        patch_identity: digest(row.patch_identity, `${label}.patch_identity`),
+        expected_post_write_raw_byte_digest: digest(row.expected_post_write_raw_byte_digest, `${label}.expected_post_write_raw_byte_digest`),
+        resource_identities: optionalArrayOf(row.resource_identities, `${label}.resource_identities`, parseResourceDigestIdentity),
+        proposal_written_delta_ids: stringSet(row.proposal_written_delta_ids, `${label}.proposal_written_delta_ids`, { allowEmpty: true }),
+    };
+    if (!complete)
+        return base;
+    return {
+        ...base,
+        target_encoding: oneOf(row.target_encoding, ENCODINGS, `${label}.target_encoding`),
+        target_eol_policy: oneOf(row.target_eol_policy, ["none", "lf", "crlf", "cr"], `${label}.target_eol_policy`),
+    };
+}
+function parseProviderIdentity(value, label) {
+    const row = object(value, label, ["key", "locator", "immutable_identity"]);
+    return {
+        key: text(row.key, `${label}.key`),
+        locator: text(row.locator, `${label}.locator`),
+        immutable_identity: text(row.immutable_identity, `${label}.immutable_identity`),
+    };
+}
+function parseProviderResourceIdentity(value, label) {
+    const row = object(value, label, [
+        "key",
+        "locator",
+        "immutable_identity",
+        "raw_byte_digest",
+    ]);
+    return {
+        ...parseProviderIdentity({
+            key: row.key,
+            locator: row.locator,
+            immutable_identity: row.immutable_identity,
+        }, label),
+        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
+    };
+}
+function parseResourceDigestIdentity(value, label) {
+    const row = object(value, label, ["key", "raw_byte_digest"]);
+    return {
+        key: text(row.key, `${label}.key`),
+        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
+    };
+}

package/dist/lib/design-resource-recovery.d.ts

@@ -0,0 +1,44 @@
+import { type DesignResourceRecoveryCheckpoint, type DesignResourceRecoveryCreateInput, type DesignResourceReplayProjection } from "./design-resource-recovery-types.js";
+import type { DesignResourceReconciliationResult } from "./design-resource-reconciliation-types.js";
+export interface DesignResourceRecoveryInspection {
+    status: "recoverable";
+    checkpoint_path: string;
+    checkpoint_raw_byte_digest: string;
+    replay: DesignResourceReplayProjection;
+    writeback: {
+        configured: false;
+    } | {
+        configured: true;
+        state: "unapplied" | "applied" | "conflict";
+        current_raw_byte_digest: string;
+        pre_write_raw_byte_digest: string;
+        expected_post_write_raw_byte_digest: string;
+    };
+}
+export declare function createDesignResourceRecoveryCheckpoint(repository: string, input: DesignResourceRecoveryCreateInput): Promise<{
+    status: "created" | "already-current";
+    checkpoint_path: string;
+    checkpoint_raw_byte_digest: string;
+}>;
+export declare function updateDesignResourceRecoveryCheckpoint(repository: string, input: DesignResourceRecoveryCreateInput, expectedCurrentDigest: string): Promise<{
+    status: "updated" | "already-current";
+    checkpoint_path: string;
+    checkpoint_raw_byte_digest: string;
+}>;
+export declare function inspectDesignResourceRecovery(repository: string, sessionId: string): Promise<DesignResourceRecoveryInspection>;
+export declare function previewDesignResourceRecoveryWriteback(repository: string, sessionId: string): Promise<DesignResourceRecoveryInspection & {
+    patch: DesignResourceRecoveryCheckpoint["writeback"];
+}>;
+export declare function applyDesignResourceRecoveryWriteback(repository: string, sessionId: string, auditLocator: string): Promise<{
+    status: "writeback-applied" | "writeback-idempotent" | "external-resource-revalidation-pending" | "blocked";
+    write_transaction: boolean;
+    idempotent_replay: boolean;
+    reconciliation: DesignResourceReconciliationResult;
+    target_raw_byte_digest: string;
+}>;
+export declare function reconcileDesignResourceRecovery(repository: string, sessionId: string, auditLocator: string): Promise<{
+    status: "reconciliation-balanced" | "external-resource-revalidation-pending" | "blocked";
+    write_transaction: false;
+    reconciliation: DesignResourceReconciliationResult;
+}>;
+export { removeDesignResourceRecoveryCheckpoint } from "./design-resource-recovery-cleanup.js";

package/dist/lib/design-resource-recovery.js

@@ -0,0 +1,216 @@
+import { createRecoveryCheckpointFile, deriveDigestCasState, atomicCasWrite, readRecoveryCheckpointFile, readRecoveryRepositoryFile, updateRecoveryCheckpointFile, } from "./design-resource-recovery-files.js";
+import { loadCurrentDesignResourceRecoveryCheckpoint, validateDesignResourceRepositoryAuthority, } from "./design-resource-recovery-current.js";
+import { encodeDesignResourceRecoveryCheckpoint, parseDesignResourceRecoveryCheckpoint, } from "./design-resource-recovery-codec.js";
+import { parseDesignResourceReconciliationAudit } from "./design-resource-reconciliation-codec.js";
+import { reconcileDesignResourceWriteback } from "./design-resource-reconciliation.js";
+import { activeAcceptedDesignResourceDeltas, createDesignResourceReplayProjection, validateDesignResourceRecoverySemantics, } from "./design-resource-recovery-replay.js";
+import { applyDesignResourceExactPatch, decodeDesignResourceText, verifyDesignResourceExactPatchReadback, verifyDesignResourceSupersededTextReadback, } from "./design-resource-recovery-text.js";
+import { validateDesignResourceAuthoritySourceItems } from "./design-resource-recovery-source-authority.js";
+import { validateReconciliationDownstreamOwners, validateSelectedResourceRepositoryBindings, } from "./design-resource-recovery-repository-bindings.js";
+import { DESIGN_RESOURCE_RECOVERY_SCHEMA } from "./design-resource-recovery-schema.js";
+import { sha256Hex } from "./strict-codec.js";
+export async function createDesignResourceRecoveryCheckpoint(repository, input) {
+    const { encoded } = await prepareDesignResourceRecoveryCheckpoint(repository, input);
+    const written = await createRecoveryCheckpointFile(repository, input.session_id, Buffer.from(encoded, "utf8"));
+    return {
+        status: written.changed ? "created" : "already-current",
+        checkpoint_path: written.path,
+        checkpoint_raw_byte_digest: written.raw_byte_digest,
+    };
+}
+export async function updateDesignResourceRecoveryCheckpoint(repository, input, expectedCurrentDigest) {
+    const current = await readRecoveryCheckpointFile(repository, input.session_id);
+    assertDigest("checkpoint_update", current.raw_byte_digest, expectedCurrentDigest);
+    const currentCheckpoint = parseDesignResourceRecoveryCheckpoint(current.bytes.toString("utf8"));
+    if (currentCheckpoint.session_id !== input.session_id)
+        throw new Error("design_resource_recovery_invalid:update_session_identity_mismatch");
+    validateDesignResourceRecoverySemantics(currentCheckpoint);
+    const { encoded } = await prepareDesignResourceRecoveryCheckpoint(repository, input);
+    const written = await updateRecoveryCheckpointFile(repository, input.session_id, Buffer.from(encoded, "utf8"), expectedCurrentDigest);
+    const readback = await readRecoveryCheckpointFile(repository, input.session_id);
+    assertDigest("checkpoint_update_readback", readback.raw_byte_digest, written.raw_byte_digest);
+    const parsed = parseDesignResourceRecoveryCheckpoint(readback.bytes.toString("utf8"));
+    validateDesignResourceRecoverySemantics(parsed);
+    return {
+        status: written.changed ? "updated" : "already-current",
+        checkpoint_path: written.path,
+        checkpoint_raw_byte_digest: written.raw_byte_digest,
+    };
+}
+async function prepareDesignResourceRecoveryCheckpoint(repository, input) {
+    validateDesignResourceRecoverySemantics(input);
+    const baseSnapshot = await readRecoveryRepositoryFile(repository, input.base.locator, "design_resource_recovery_base");
+    assertDigest("base", baseSnapshot.raw_byte_digest, input.base.raw_byte_digest);
+    const baseText = decodeDesignResourceText(baseSnapshot.bytes);
+    await validateDesignResourceRepositoryAuthority(repository, input.design_authority);
+    await validateDesignResourceAuthoritySourceItems(repository, input);
+    await validateSelectedResourceRepositoryBindings(repository, input);
+    let writeback;
+    if (input.writeback) {
+        const target = await readRecoveryRepositoryFile(repository, input.writeback.target_locator, "design_resource_recovery_writeback_target");
+        assertDigest("writeback_pre", target.raw_byte_digest, input.writeback.pre_write_raw_byte_digest);
+        const patched = applyDesignResourceExactPatch(target.bytes, input.writeback.patch);
+        assertDigest("writeback_expected_post", sha256Hex(patched.bytes), input.writeback.expected_post_write_raw_byte_digest);
+        verifyDesignResourceSupersededTextReadback(patched.bytes, input.writeback.patch, supersedingDeltaIds(input));
+        writeback = {
+            ...input.writeback,
+            target_encoding: patched.encoding,
+            target_eol_policy: patched.eol_policy,
+        };
+    }
+    const { schema_version: _inputSchema, base: _inputBase, writeback: _inputWriteback, ...common } = input;
+    const checkpoint = {
+        ...common,
+        schema_version: DESIGN_RESOURCE_RECOVERY_SCHEMA,
+        owner: "ty-context-design-resource-recovery",
+        base: {
+            ...input.base,
+            encoding: baseText.encoding,
+            eol_policy: baseText.eol_policy,
+        },
+        ...(writeback ? { writeback } : {}),
+    };
+    validateDesignResourceRecoverySemantics(checkpoint);
+    const encoded = encodeDesignResourceRecoveryCheckpoint(checkpoint);
+    const roundTrip = parseDesignResourceRecoveryCheckpoint(encoded);
+    validateDesignResourceRecoverySemantics(roundTrip);
+    return {
+        checkpoint: roundTrip,
+        encoded,
+    };
+}
+export async function inspectDesignResourceRecovery(repository, sessionId) {
+    const loaded = await loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId);
+    const writeback = loaded.checkpoint.writeback;
+    if (!writeback)
+        return {
+            status: "recoverable",
+            checkpoint_path: loaded.path,
+            checkpoint_raw_byte_digest: loaded.digest,
+            replay: createDesignResourceReplayProjection(loaded.checkpoint),
+            writeback: { configured: false },
+        };
+    const target = await readRecoveryRepositoryFile(repository, writeback.target_locator, "design_resource_recovery_writeback_target");
+    return {
+        status: "recoverable",
+        checkpoint_path: loaded.path,
+        checkpoint_raw_byte_digest: loaded.digest,
+        replay: createDesignResourceReplayProjection(loaded.checkpoint),
+        writeback: {
+            configured: true,
+            state: deriveDigestCasState(target.raw_byte_digest, writeback.pre_write_raw_byte_digest, writeback.expected_post_write_raw_byte_digest),
+            current_raw_byte_digest: target.raw_byte_digest,
+            pre_write_raw_byte_digest: writeback.pre_write_raw_byte_digest,
+            expected_post_write_raw_byte_digest: writeback.expected_post_write_raw_byte_digest,
+        },
+    };
+}
+export async function previewDesignResourceRecoveryWriteback(repository, sessionId) {
+    const inspection = await inspectDesignResourceRecovery(repository, sessionId);
+    const checkpoint = (await loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId)).checkpoint;
+    if (!checkpoint.writeback)
+        throw new Error("design_resource_recovery_invalid:writeback_not_configured");
+    return { ...inspection, patch: checkpoint.writeback };
+}
+export async function applyDesignResourceRecoveryWriteback(repository, sessionId, auditLocator) {
+    const { checkpoint } = await loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId);
+    const writeback = checkpoint.writeback;
+    if (!writeback)
+        throw new Error("design_resource_recovery_invalid:writeback_not_configured");
+    const auditSnapshot = await readRecoveryRepositoryFile(repository, auditLocator, "design_resource_recovery_fresh_audit");
+    const audit = parseDesignResourceReconciliationAudit(auditSnapshot.bytes.toString("utf8"));
+    const preReconciliation = reconcileDesignResourceWriteback(checkpoint, audit);
+    let externalRevalidationRequired = false;
+    if (preReconciliation.status === "reconciliation-balanced") {
+        try {
+            externalRevalidationRequired = (await validateReconciliationDownstreamOwners(repository, checkpoint)).external_revalidation_required;
+        }
+        catch (error) {
+            preReconciliation.status = "blocked";
+            preReconciliation.findings.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    const target = await readRecoveryRepositoryFile(repository, writeback.target_locator, "design_resource_recovery_writeback_target");
+    const state = deriveDigestCasState(target.raw_byte_digest, writeback.pre_write_raw_byte_digest, writeback.expected_post_write_raw_byte_digest);
+    if (state === "conflict")
+        throw new Error("design_resource_recovery_invalid:writeback_cas_conflict");
+    if (preReconciliation.status === "blocked")
+        return {
+            status: "blocked",
+            write_transaction: false,
+            idempotent_replay: state === "applied",
+            reconciliation: preReconciliation,
+            target_raw_byte_digest: target.raw_byte_digest,
+        };
+    let wrote = false;
+    if (state === "unapplied") {
+        const patched = applyDesignResourceExactPatch(target.bytes, writeback.patch, writeback.target_encoding, writeback.target_eol_policy);
+        assertDigest("writeback_expected_post", sha256Hex(patched.bytes), writeback.expected_post_write_raw_byte_digest);
+        await atomicCasWrite(repository, writeback.target_locator, patched.bytes, writeback.pre_write_raw_byte_digest, target.mode);
+        wrote = true;
+    }
+    const post = await readRecoveryRepositoryFile(repository, writeback.target_locator, "design_resource_recovery_writeback_readback");
+    assertDigest("writeback_post_readback", post.raw_byte_digest, writeback.expected_post_write_raw_byte_digest);
+    verifyDesignResourceExactPatchReadback(post.bytes, writeback.patch);
+    verifyDesignResourceSupersededTextReadback(post.bytes, writeback.patch, supersedingDeltaIds(checkpoint));
+    const reconciliation = reconcileDesignResourceWriteback(checkpoint, audit);
+    if (reconciliation.status === "reconciliation-balanced") {
+        try {
+            externalRevalidationRequired = (await validateReconciliationDownstreamOwners(repository, checkpoint)).external_revalidation_required;
+        }
+        catch (error) {
+            reconciliation.status = "blocked";
+            reconciliation.findings.push(error instanceof Error ? error.message : String(error));
+            reconciliation.findings.sort();
+        }
+    }
+    return {
+        status: reconciliation.status === "blocked"
+            ? "blocked"
+            : externalRevalidationRequired
+                ? "external-resource-revalidation-pending"
+                : wrote
+                    ? "writeback-applied"
+                    : "writeback-idempotent",
+        write_transaction: wrote,
+        idempotent_replay: !wrote,
+        reconciliation,
+        target_raw_byte_digest: post.raw_byte_digest,
+    };
+}
+export async function reconcileDesignResourceRecovery(repository, sessionId, auditLocator) {
+    const { checkpoint } = await loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId, { validateSelectedResources: false });
+    if (checkpoint.writeback)
+        throw new Error("design_resource_recovery_invalid:read_only_reconcile_requires_no_writeback");
+    const auditSnapshot = await readRecoveryRepositoryFile(repository, auditLocator, "design_resource_recovery_fresh_audit");
+    const audit = parseDesignResourceReconciliationAudit(auditSnapshot.bytes.toString("utf8"));
+    const reconciliation = reconcileDesignResourceWriteback(checkpoint, audit);
+    if (reconciliation.status === "blocked")
+        return { status: "blocked", write_transaction: false, reconciliation };
+    try {
+        const current = await validateReconciliationDownstreamOwners(repository, checkpoint);
+        return {
+            status: current.external_revalidation_required
+                ? "external-resource-revalidation-pending"
+                : "reconciliation-balanced",
+            write_transaction: false,
+            reconciliation,
+        };
+    }
+    catch (error) {
+        reconciliation.status = "blocked";
+        reconciliation.findings.push(error instanceof Error ? error.message : String(error));
+        reconciliation.findings.sort();
+        return { status: "blocked", write_transaction: false, reconciliation };
+    }
+}
+export { removeDesignResourceRecoveryCheckpoint } from "./design-resource-recovery-cleanup.js";
+function assertDigest(label, actual, expected) {
+    if (actual !== expected)
+        throw new Error(`design_resource_recovery_invalid:${label}_digest_mismatch:${expected}:${actual}`);
+}
+function supersedingDeltaIds(state) {
+    return new Set(activeAcceptedDesignResourceDeltas(state.deltas)
+        .filter((delta) => delta.supersedes.length > 0)
+        .map((delta) => delta.delta_id));
+}

package/dist/lib/long-task-acceptance-shape.js

@@ -10,7 +10,7 @@ export function parseCounterfactuals(value, label) {
             "check_key",
             "mutation",
             "expected_assertion_failures",
-        ], ["preserved_assertions"]);
+        ], ["preserved_assertions", "allowed_fanout_assertions"]);
         const mutation = object(row.mutation, `${itemLabel}.mutation`, ["type"], [
             "paths",
             "path",
@@ -36,6 +36,9 @@ export function parseCounterfactuals(value, label) {
             preserved_assertions: Object.hasOwn(row, "preserved_assertions")
                 ? strings(row.preserved_assertions, `${itemLabel}.preserved_assertions`).map((item, assertionIndex) => key(item, `${itemLabel}.preserved_assertions[${assertionIndex}]`))
                 : [],
+            allowed_fanout_assertions: Object.hasOwn(row, "allowed_fanout_assertions")
+                ? strings(row.allowed_fanout_assertions, `${itemLabel}.allowed_fanout_assertions`).map((item, assertionIndex) => key(item, `${itemLabel}.allowed_fanout_assertions[${assertionIndex}]`))
+                : [],
         };
     });
 }
@@ -49,7 +52,7 @@ export function parseGlobalCounterfactuals(value, label) {
             "check_key",
             "mutation",
             "expected_assertion_failures",
-        ], ["preserved_assertions"]);
+        ], ["preserved_assertions", "allowed_fanout_assertions"]);
         const bindingRef = string(row.binding_ref, `${itemLabel}.binding_ref`);
         if (!/^[a-z0-9][a-z0-9-]*\.[a-z0-9][a-z0-9-]*$/u.test(bindingRef))
             fail(`${itemLabel}.binding_ref`, "must be <outcome-key>.<binding-key>");
@@ -69,6 +72,9 @@ export function parseGlobalCounterfactuals(value, label) {
             preserved_assertions: Object.hasOwn(row, "preserved_assertions")
                 ? strings(row.preserved_assertions, `${itemLabel}.preserved_assertions`).map((entry, assertionIndex) => key(entry, `${itemLabel}.preserved_assertions[${assertionIndex}]`))
                 : [],
+            allowed_fanout_assertions: Object.hasOwn(row, "allowed_fanout_assertions")
+                ? strings(row.allowed_fanout_assertions, `${itemLabel}.allowed_fanout_assertions`).map((entry, assertionIndex) => key(entry, `${itemLabel}.allowed_fanout_assertions[${assertionIndex}]`))
+                : [],
         };
     });
 }

package/dist/lib/long-task-activation-validation.js

@@ -9,6 +9,7 @@ import { validateRawExecutionObservationOwnership } from "./long-task-observatio
 import { validateLongTaskDesignResourceHandoffs } from "./long-task-design-resource-handoff.js";
 import { validateLongTaskSemanticFactClosure } from "./long-task-semantic-fact-closure.js";
 import { freezeDeliveryCheck } from "./long-task-runner-freeze.js";
+import { scopeDeliveryBindings } from "./long-task-scoped-binding.js";
 import { classifyLongTaskRisk, validateRiskProof, } from "./long-task-risk.js";
 import { validateSourceContinuity } from "./long-task-source-continuity.js";
 import { compileSourceInventory } from "./long-task-source-inventory.js";
@@ -33,12 +34,13 @@ export async function validateContractForActivation(options) {
     }
     const sourceHashes = await attempt(mode, diagnostics, () => hashDeclaredFiles(repository, contract.task.source_paths, "source"));
     await attempt(mode, diagnostics, () => validateSourceAnchors(repository, contract.source_claims));
+    let sourceBackedExecutionTargets = new Map();
     const sourceItems = await attempt(mode, diagnostics, async () => {
         const items = await compileSourceInventory(repository, contract.task.source_paths);
         validateSourceContinuity(contract, items, mode === "collect"
             ? (error) => addDiagnosticError(diagnostics, new Error(error))
             : undefined);
-        validateSourceTargetContinuity(contract, items, mode === "collect"
+        sourceBackedExecutionTargets = validateSourceTargetContinuity(contract, items, mode === "collect"
             ? (error) => addDiagnosticError(diagnostics, new Error(error))
             : undefined);
         return items;
@@ -61,12 +63,20 @@ export async function validateContractForActivation(options) {
     });
     if (!workspace)
         return emptyCompiledResult(claims, risk, sourceHashes, sourceItems, context);
+    const observationAuthorityPaths = [
+        ...workspace.files
+            .map((file) => file.path)
+            .filter((file) => file === workdirRelative || file.startsWith(`${workdirRelative}/`)),
+        `${workdirRelative}/delivery-contract.yaml`,
+        ...Object.keys(sourceHashes ?? {}),
+        ...(context?.files ?? []),
+    ];
     const globalChecks = [];
     for (const check of contract.global.acceptance.checks) {
         const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
         if (!executionTarget)
             continue;
-        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, [], [], context?.files ?? []), null, check.key);
+        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, [], [], contract.outcomes.flatMap((outcome) => scopeDeliveryBindings(outcome.key, outcome.technical.bindings)), contract.outcomes.flatMap((outcome) => outcome.product.owner.path_globs), sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), null, check.key);
         if (frozen)
             globalChecks.push(frozen);
     }
@@ -77,7 +87,7 @@ export async function validateContractForActivation(options) {
             const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
             if (!executionTarget)
                 continue;
-            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key), semanticFactClosure?.expectations_by_check.get(check.key) ?? [], context?.files ?? []), outcome.key, check.key);
+            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key), semanticFactClosure?.expectations_by_check.get(check.key) ?? [], scopeDeliveryBindings(outcome.key, outcome.technical.bindings), outcome.product.owner.path_globs, sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), outcome.key, check.key);
             if (frozen)
                 checks.push(frozen);
         }

package/dist/lib/long-task-admitted-observation-records.d.ts

@@ -0,0 +1,25 @@
+import type { EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
+import type { JsonPointerExactLocator } from "./long-task-json-pointer-observation.js";
+export type AdmittedObservationCandidate = {
+    assertion_key: string;
+    identity_ref: string;
+    method: string;
+    actual_observation: {
+        artifact_path: string;
+        locator: JsonPointerExactLocator;
+        sensitivity: string;
+    };
+    comparison: {
+        comparator: string;
+        mode: string;
+        tolerance: unknown;
+        mask: unknown;
+    };
+    oracle: {
+        trust: string;
+        identity: string;
+        version: string;
+        sha256: string | null;
+    };
+};
+export declare function admittedObservationCandidates(records: EvidenceCapabilityRecordV2[]): AdmittedObservationCandidate[];

package/dist/lib/long-task-admitted-observation-records.js

@@ -0,0 +1,40 @@
+export function admittedObservationCandidates(records) {
+    const candidates = [];
+    for (const record of records) {
+        if (record.capability === "semantic_fact") {
+            candidates.push({
+                assertion_key: record.assertion_key,
+                identity_ref: record.fact_ref,
+                method: record.method,
+                actual_observation: record.actual_observation,
+                comparison: record.comparison,
+                oracle: record.oracle,
+            });
+            continue;
+        }
+        if (record.capability !== "design_method")
+            continue;
+        if ("fact_model" in record)
+            for (const result of record.rule_results)
+                candidates.push({
+                    assertion_key: record.assertion_key,
+                    identity_ref: result.obligation_ref,
+                    method: record.method,
+                    actual_observation: result.actual_observation,
+                    comparison: result.comparison,
+                    oracle: result.oracle,
+                });
+        else
+            for (const cell of record.cells)
+                for (const result of cell.fact_results)
+                    candidates.push({
+                        assertion_key: record.assertion_key,
+                        identity_ref: result.fact_ref,
+                        method: record.method,
+                        actual_observation: result.actual_observation,
+                        comparison: result.comparison,
+                        oracle: result.oracle,
+                    });
+    }
+    return candidates;
+}