project-tiny-context-harness 0.8.10 → 0.8.12

package/dist/lib/long-task-compact-primitives.js

@@ -0,0 +1,132 @@
+const STABLE_REF = /^[a-z0-9][a-z0-9._:-]*$/u;
+const SHA256 = /^[a-f0-9]{64}$/u;
+export { longTaskCompactSharedStructureTargets } from "./long-task-compact-structure-targets.js";
+export const LONG_TASK_COMPACT_CAPACITY_FIELDS = [
+    "claims",
+    "claim_projections",
+    "selector_members",
+    "structure_families",
+    "structure_references",
+    "structure_arguments",
+    "facts",
+    "obligations",
+    "assertions",
+    "canonical_bytes",
+];
+const PACKAGE_MAXIMUM = {
+    claims: 1_000_000,
+    claim_projections: 2_000_000,
+    selector_members: 5_000_000,
+    structure_families: 1_000_000,
+    structure_references: 10_000_000,
+    structure_arguments: 50_000_000,
+    facts: 1_000_000,
+    obligations: 2_000_000,
+    assertions: 5_000_000,
+    canonical_bytes: 256 * 1024 * 1024,
+};
+export function compactRequiredOutcome(value, outcomes, label) {
+    const ref = compactStableRef(value, `${label}.outcome_ref`);
+    const outcome = outcomes.get(ref);
+    if (!outcome)
+        compactFail(`${label}.outcome_ref`, `unknown outcome: ${ref}`);
+    return outcome;
+}
+export function compactResolveSelectors(value, selectors, label) {
+    if (Array.isArray(value))
+        return value.map((item, index) => compactResolveSelectors(item, selectors, `${label}[${index}]`));
+    if (!value || typeof value !== "object")
+        return value;
+    const row = value;
+    if (Object.keys(row).length === 1 && Object.hasOwn(row, "selector_ref")) {
+        const ref = compactStableRef(row.selector_ref, `${label}.selector_ref`);
+        const members = selectors.get(ref);
+        if (!members)
+            compactFail(`${label}.selector_ref`, `unknown selector: ${ref}`);
+        return [...members];
+    }
+    if (Object.hasOwn(row, "selector_ref"))
+        compactFail(label, "selector_ref must be the only key");
+    return Object.fromEntries(Object.entries(row).map(([key, item]) => [
+        key,
+        compactResolveSelectors(item, selectors, `${label}.${key}`),
+    ]));
+}
+export function validateLongTaskCompactCapacity(capacity, measured, label) {
+    for (const field of LONG_TASK_COMPACT_CAPACITY_FIELDS) {
+        if (capacity.maximum[field] > PACKAGE_MAXIMUM[field])
+            compactFail(`${label}.capacity.maximum.${field}`, `exceeds package maximum ${PACKAGE_MAXIMUM[field]}`);
+        if (capacity.measured[field] !== measured[field])
+            compactFail(`${label}.capacity.measured.${field}`, `measured mismatch: ${capacity.measured[field]}:${measured[field]}`);
+        if (measured[field] > capacity.maximum[field])
+            compactFail(`${label}.capacity.maximum.${field}`, `capacity exceeded: ${measured[field]}:${capacity.maximum[field]}`);
+    }
+}
+export function validateLongTaskCompactDeclaredMaximum(maximum, label) {
+    for (const field of LONG_TASK_COMPACT_CAPACITY_FIELDS)
+        if (maximum[field] > PACKAGE_MAXIMUM[field])
+            compactFail(`${label}.capacity.maximum.${field}`, `exceeds package maximum ${PACKAGE_MAXIMUM[field]}`);
+}
+export function compactUniqueRows(rows, field, label) {
+    const seen = new Set();
+    for (const [index, row] of rows.entries()) {
+        const value = compactStableRef(row[field], `${label}.rows[${index}].${field}`);
+        if (seen.has(value))
+            compactFail(label, `duplicate ${field}: ${value}`);
+        seen.add(value);
+    }
+}
+export function compactStrictObject(value, label, fields) {
+    const row = compactPlainObject(value, label);
+    const allowed = new Set(fields);
+    const unknown = Object.keys(row).filter((key) => !allowed.has(key));
+    if (unknown.length)
+        compactFail(label, `unknown keys: ${unknown.join(",")}`);
+    const missing = fields.filter((field) => !Object.hasOwn(row, field));
+    if (missing.length)
+        compactFail(label, `missing keys: ${missing.join(",")}`);
+    return row;
+}
+export function compactPlainObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        compactFail(label, "must be an object");
+    return value;
+}
+export function compactArray(value, label) {
+    if (!Array.isArray(value))
+        compactFail(label, "must be an array");
+    return value;
+}
+export function compactStableRef(value, label) {
+    const result = compactNonemptyString(value, label);
+    if (!STABLE_REF.test(result))
+        compactFail(label, "must be a stable reference");
+    return result;
+}
+export function compactStableRefs(value, label) {
+    return compactArray(value, label).map((item, index) => compactStableRef(item, `${label}[${index}]`));
+}
+export function compactSha256(value, label) {
+    const result = compactNonemptyString(value, label);
+    if (!SHA256.test(result))
+        compactFail(label, "must be a lowercase SHA-256");
+    return result;
+}
+export function compactNonemptyString(value, label) {
+    if (typeof value !== "string" || !value.trim())
+        compactFail(label, "must be a non-empty string");
+    return value;
+}
+export function compactInteger(value, label) {
+    if (!Number.isInteger(value) || Number(value) < 0)
+        compactFail(label, "must be an integer >= 0");
+    return Number(value);
+}
+export function compactLiteral(value, values, label) {
+    if (typeof value !== "string" || !values.includes(value))
+        compactFail(label, `must be one of ${values.join(",")}`);
+    return value;
+}
+export function compactFail(label, message) {
+    throw new Error(`long_task_compact_carrier_invalid:${label}:${message}`);
+}

package/dist/lib/long-task-compact-projections.d.ts

@@ -0,0 +1,4 @@
+export declare function prepareLongTaskCompactOutcomeTargets(outcomes: Record<string, unknown>[]): void;
+export declare function materializeLongTaskCompactClaimProjections(projections: Record<string, unknown>[], claims: Map<string, Record<string, unknown>>, outcomes: Map<string, Record<string, unknown>>): void;
+export declare function materializeLongTaskCompactFactBindings(facts: Record<string, unknown>[], obligations: Record<string, unknown>[], factByKey: Map<string, Record<string, unknown>>, templates: Map<string, Record<string, unknown>>, outcomes: Map<string, Record<string, unknown>>): void;
+export declare function materializeLongTaskCompactAssertions(assertions: Record<string, unknown>[], claims: Map<string, Record<string, unknown>>, facts: Map<string, Record<string, unknown>>, outcomes: Map<string, Record<string, unknown>>): void;

package/dist/lib/long-task-compact-projections.js

@@ -0,0 +1,153 @@
+import { compactArray, compactFail, compactInteger, compactLiteral, compactNonemptyString, compactPlainObject, compactRequiredOutcome, compactSha256, compactStableRef, compactStableRefs, } from "./long-task-compact-primitives.js";
+export function prepareLongTaskCompactOutcomeTargets(outcomes) {
+    for (const [index, outcome] of outcomes.entries()) {
+        const label = `outcomes[${index}]`;
+        if (Object.hasOwn(outcome, "semantic_fact_bindings"))
+            compactFail(label, "expanded semantic_fact_bindings cannot coexist");
+        const product = compactPlainObject(outcome.product, `${label}.product`);
+        const technical = compactPlainObject(outcome.technical, `${label}.technical`);
+        for (const field of ["requirements", "non_completing_outcomes"])
+            if (Object.hasOwn(product, field))
+                compactFail(`${label}.product.${field}`, "expanded projection cannot coexist");
+        for (const field of ["obligations", "forbidden_shortcuts"])
+            if (Object.hasOwn(technical, field))
+                compactFail(`${label}.technical.${field}`, "expanded projection cannot coexist");
+        product.requirements = [];
+        product.non_completing_outcomes = [];
+        technical.obligations = [];
+        technical.forbidden_shortcuts = [];
+        outcome.semantic_fact_bindings = {
+            manifest_ref: "",
+            facts: [],
+            proofs: [],
+        };
+    }
+}
+export function materializeLongTaskCompactClaimProjections(projections, claims, outcomes) {
+    for (const [index, projection] of projections.entries()) {
+        const label = `compact_semantic_carrier.claim_projections.rows[${index}]`;
+        const outcome = compactRequiredOutcome(projection.outcome_ref, outcomes, label);
+        const claimKey = projection.claim_key === null
+            ? null
+            : compactStableRef(projection.claim_key, `${label}.claim_key`);
+        const claim = claimKey ? claims.get(claimKey) : null;
+        if (claimKey && !claim)
+            compactFail(`${label}.claim_key`, `unknown claim: ${claimKey}`);
+        const statement = claim
+            ? compactNonemptyString(claim.statement, `${label}.statement`)
+            : compactNonemptyString(projection.statement, `${label}.statement`);
+        const applicabilityRefs = compactStableRefs(projection.applicability_refs, `${label}.applicability_refs`);
+        const kind = compactLiteral(projection.projection_kind, [
+            "requirement",
+            "obligation",
+            "forbidden_shortcut",
+            "non_completing_outcome",
+        ], `${label}.projection_kind`);
+        const product = compactPlainObject(outcome.product, `${label}.product`);
+        const technical = compactPlainObject(outcome.technical, `${label}.technical`);
+        const base = {
+            key: compactStableRef(projection.projection_key ?? projection.claim_key, `${label}.projection_key`),
+            statement,
+            applicability_refs: applicabilityRefs,
+        };
+        if (kind === "requirement" || kind === "obligation") {
+            const requiredProofSurfaces = compactStableRefs(projection.required_proof_surfaces, `${label}.required_proof_surfaces`);
+            const row = { ...base, required_proof_surfaces: requiredProofSurfaces };
+            if (kind === "requirement")
+                product.requirements.push(row);
+            else
+                technical.obligations.push(row);
+        }
+        else {
+            if (projection.required_proof_surfaces !== null)
+                compactFail(`${label}.required_proof_surfaces`, "must be null for statement-only projection");
+            if (kind === "forbidden_shortcut")
+                technical.forbidden_shortcuts.push(base);
+            else
+                product.non_completing_outcomes.push(base);
+        }
+    }
+}
+export function materializeLongTaskCompactFactBindings(facts, obligations, factByKey, templates, outcomes) {
+    for (const [index, fact] of facts.entries()) {
+        const label = `compact_semantic_carrier.facts[${index}]`;
+        const outcome = compactRequiredOutcome(fact.outcome_ref, outcomes, label);
+        const binding = compactPlainObject(outcome.semantic_fact_bindings, `${label}.semantic_fact_bindings`);
+        if (!binding.manifest_ref)
+            binding.manifest_ref = compactStableRef(fact.manifest_ref, `${label}.manifest_ref`);
+        else if (binding.manifest_ref !== fact.manifest_ref)
+            compactFail(`${label}.manifest_ref`, "outcome manifest_ref mismatch");
+        binding.facts.push({
+            fact_ref: compactStableRef(fact.fact_key, `${label}.fact_key`),
+            fact_revision_digest: compactSha256(fact.fact_revision_digest, `${label}.fact_revision_digest`),
+            claim_ref: compactStableRef(fact.claim_ref, `${label}.claim_ref`),
+            applicability_ref: compactStableRef(fact.applicability_ref, `${label}.applicability_ref`),
+        });
+    }
+    for (const [index, obligation] of obligations.entries()) {
+        const label = `compact_semantic_carrier.obligations.rows[${index}]`;
+        const outcome = compactRequiredOutcome(obligation.outcome_ref, outcomes, label);
+        const factKey = compactStableRef(obligation.fact_key, `${label}.fact_key`);
+        if (!factByKey.has(factKey))
+            compactFail(`${label}.fact_key`, `unknown fact: ${factKey}`);
+        const templateRef = compactStableRef(obligation.template_ref, `${label}.template_ref`);
+        const template = templates.get(templateRef);
+        if (!template)
+            compactFail(`${label}.template_ref`, `unknown template: ${templateRef}`);
+        const overrides = compactPlainObject(obligation.overrides, `${label}.overrides`);
+        if (["proof_ref", "fact_ref", "obligation_revision_digest"].some((field) => Object.hasOwn(overrides, field)))
+            compactFail(`${label}.overrides`, "identity fields cannot be overridden");
+        const binding = compactPlainObject(outcome.semantic_fact_bindings, `${label}.semantic_fact_bindings`);
+        binding.proofs.push({
+            ...template,
+            ...overrides,
+            proof_ref: compactStableRef(obligation.obligation_key, `${label}.obligation_key`),
+            obligation_revision_digest: compactSha256(obligation.obligation_revision_digest, `${label}.obligation_revision_digest`),
+            fact_ref: factKey,
+        });
+    }
+}
+export function materializeLongTaskCompactAssertions(assertions, claims, facts, outcomes) {
+    for (const [index, projection] of assertions.entries()) {
+        const label = `compact_semantic_carrier.assertion_projections.rows[${index}]`;
+        const outcome = compactRequiredOutcome(projection.outcome_ref, outcomes, label);
+        const acceptance = compactPlainObject(outcome.acceptance, `${label}.acceptance`);
+        const checkRef = compactStableRef(projection.check_ref, `${label}.check_ref`);
+        const check = compactArray(acceptance.checks, `${label}.checks`)
+            .map((item, checkIndex) => compactPlainObject(item, `${label}.checks[${checkIndex}]`))
+            .find((item) => item.key === checkRef);
+        if (!check)
+            compactFail(`${label}.check_ref`, `unknown check: ${checkRef}`);
+        const criterionKind = compactLiteral(projection.criterion_kind, ["claim_statement", "semantic_fact"], `${label}.criterion_kind`);
+        const criterionRef = compactStableRef(projection.criterion_ref, `${label}.criterion_ref`);
+        let criterion;
+        if (criterionKind === "claim_statement") {
+            const claim = claims.get(criterionRef);
+            if (!claim)
+                compactFail(`${label}.criterion_ref`, `unknown claim: ${criterionRef}`);
+            criterion = compactNonemptyString(claim.statement, `${label}.criterion`);
+        }
+        else {
+            if (!facts.has(criterionRef))
+                compactFail(`${label}.criterion_ref`, `unknown fact: ${criterionRef}`);
+            criterion = `The current candidate satisfies the exact Source Fact ${criterionRef}.`;
+        }
+        const assertion = {
+            key: compactStableRef(projection.key, `${label}.key`),
+            criterion,
+            claims: compactStableRefs(projection.claims, `${label}.claims`),
+            applicability_ref: compactStableRef(projection.applicability_ref, `${label}.applicability_ref`),
+            observation: compactNonemptyString(projection.observation, `${label}.observation`),
+            evidence_capabilities: compactStableRefs(projection.evidence_capabilities, `${label}.evidence_capabilities`),
+            operator: compactNonemptyString(projection.operator, `${label}.operator`),
+            expected: projection.expected,
+        };
+        const positive = compactArray(check.positive_assertions, `${label}.positive_assertions`);
+        if (positive.some((item) => compactPlainObject(item, label).key === assertion.key))
+            compactFail(`${label}.key`, `duplicate assertion: ${assertion.key}`);
+        const position = compactInteger(projection.position, `${label}.position`);
+        if (position > positive.length)
+            compactFail(`${label}.position`, `position exceeds current assertion length: ${position}:${positive.length}`);
+        positive.splice(position, 0, assertion);
+    }
+}

package/dist/lib/long-task-compact-structure-targets.d.ts

@@ -0,0 +1,2 @@
+import type { CompactSharedStructureTarget } from "./compact-shared-structures.js";
+export declare function longTaskCompactSharedStructureTargets(root: Record<string, unknown>, carrier: Record<string, unknown>): CompactSharedStructureTarget[];

package/dist/lib/long-task-compact-structure-targets.js

@@ -0,0 +1,90 @@
+const BASE_STRUCTURE_BOUNDARY_BY_FIELD = {
+    path_globs: "contract.path-set",
+    expected_change_paths: "contract.path-set",
+    input_paths: "contract.check.input-paths",
+    verification_inputs: "contract.check.verification-inputs",
+    scenario: "contract.check.scenario",
+    expected_output_paths: "contract.check.output-paths",
+    mutation: "contract.counterfactual.mutation",
+    execution_target: "contract.check.execution-target",
+    artifact_globs: "contract.check.artifact-globs",
+    journey_roles: "contract.check.journey-roles",
+    carrier_paths: "contract.binding.carrier-paths",
+    preserved_assertions: "contract.counterfactual.preserved-assertions",
+    expected_assertion_failures: "contract.counterfactual.expected-assertion-failures",
+};
+export function longTaskCompactSharedStructureTargets(root, carrier) {
+    const targets = [];
+    for (const [field, boundary] of [
+        ["claim_catalog", "contract.claim"],
+        ["claim_projections", "contract.claim-projection"],
+        ["obligations", "contract.obligation"],
+        ["assertion_projections", "contract.assertion"],
+    ])
+        addCompactTableTargets(targets, carrier[field], boundary);
+    if (Array.isArray(carrier.fact_sets))
+        for (const factSet of carrier.fact_sets)
+            addCompactTableTargets(targets, factSet, "contract.fact");
+    if (Array.isArray(carrier.proof_templates))
+        for (const template of carrier.proof_templates) {
+            const row = plainRecord(template);
+            if (row && Object.hasOwn(row, "binding"))
+                addTarget(targets, row, "binding", "contract.proof.policy");
+        }
+    for (const [key, value] of Object.entries(root)) {
+        if (key === "compact_semantic_carrier")
+            continue;
+        collectBaseTargets(targets, value);
+    }
+    return targets;
+}
+function collectBaseTargets(targets, value) {
+    if (Array.isArray(value)) {
+        value.forEach((item) => collectBaseTargets(targets, item));
+        return;
+    }
+    const row = plainRecord(value);
+    if (!row)
+        return;
+    for (const [key, child] of Object.entries(row)) {
+        const boundary = BASE_STRUCTURE_BOUNDARY_BY_FIELD[key];
+        if (boundary && child && typeof child === "object") {
+            addTarget(targets, row, key, boundary);
+            continue;
+        }
+        collectBaseTargets(targets, child);
+    }
+}
+function addCompactTableTargets(targets, value, boundary) {
+    const table = plainRecord(value);
+    if (!table || !Array.isArray(table.columns) || !Array.isArray(table.rows))
+        return;
+    const columns = table.columns.map(String);
+    const defaults = plainRecord(table.defaults);
+    if (defaults)
+        for (const key of Object.keys(defaults))
+            if (defaults[key] && typeof defaults[key] === "object")
+                addTarget(targets, defaults, key, `${boundary}.default.${key}`);
+    for (const rowValue of table.rows) {
+        if (!Array.isArray(rowValue) || rowValue.length !== columns.length)
+            continue;
+        for (const [index, column] of columns.entries())
+            if (rowValue[index] && typeof rowValue[index] === "object")
+                addTarget(targets, rowValue, index, `${boundary}.${column}`);
+    }
+}
+function addTarget(targets, parent, key, boundary) {
+    const indexed = parent;
+    targets.push({
+        boundary,
+        read: () => indexed[key],
+        write: (value) => {
+            indexed[key] = value;
+        },
+    });
+}
+function plainRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}

package/dist/lib/long-task-counterfactual-sandbox.d.ts

@@ -8,6 +8,6 @@ type RemoveTree = (target: string, options: {
     force: true;
 }) => Promise<void>;
 type Wait = (milliseconds: number) => Promise<void>;
-export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2): Promise<CounterfactualSandboxV2>;
+export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[]): Promise<CounterfactualSandboxV2>;
 export declare function removeCounterfactualSandboxRoot(root: string, removeTree?: RemoveTree, wait?: Wait): Promise<void>;
 export {};

package/dist/lib/long-task-counterfactual-sandbox.js

@@ -1,7 +1,7 @@
 import { copyFile, cp, lstat, mkdir, mkdtemp, readlink, realpath, rm, symlink, } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { matchesRepoPattern } from "./long-task-paths.js";
+import { matchesRepoPattern, normalizeRepositoryFile, } from "./long-task-paths.js";
 const TRANSIENT_REMOVE_CODES = new Set([
     "EBUSY",
     "EMFILE",
@@ -11,7 +11,7 @@ const TRANSIENT_REMOVE_CODES = new Set([
 ]);
 const REMOVE_RETRY_LIMIT = process.platform === "win32" ? 6 : 2;
 const REMOVE_RETRY_DELAY_MS = 100;
-export async function createCounterfactualSandbox(snapshotRoot, check, control, bindingCarrierPaths, manifest) {
+export async function createCounterfactualSandbox(snapshotRoot, check, control, bindingCarrierPaths, manifest, protectedAuthorityPaths = []) {
     const root = await mkdtemp(path.join(os.tmpdir(), "ty-context-counterfactual-"));
     if (!manifest) {
         await cp(snapshotRoot, root, {
@@ -44,9 +44,11 @@ export async function createCounterfactualSandbox(snapshotRoot, check, control,
         if (requirement.kind === "directory")
             patterns.push(`${requirement.target}/**`);
     }
-    const selected = manifest.files
-        .map((file) => file.path)
-        .filter((relative) => exactPaths.has(relative) ||
+    const candidates = new Set([
+        ...manifest.files.map((file) => file.path),
+        ...protectedAuthorityPaths.map((file, index) => normalizeRepositoryFile(file, `counterfactual.protected_authority_paths[${index}]`)),
+    ]);
+    const selected = [...candidates].filter((relative) => exactPaths.has(relative) ||
         patterns.some((pattern) => matchesRepoPattern(relative, pattern)));
     await copyInBatches(snapshotRoot, root, selected);
     await mkdir(path.join(root, check.runner.resolved_cwd), { recursive: true });

package/dist/lib/long-task-delivery-parser.d.ts

@@ -11,3 +11,4 @@ export interface ParseDeliveryContractOptions {
 export declare function parseDeliveryContract(workdir: string): Promise<DeliveryContractV2>;
 export declare function parseDeliveryContractBundle(workdirInput: string, repositoryInput?: string, options?: ParseDeliveryContractOptions): Promise<ParsedDeliveryContractV2>;
 export declare function parseDeliveryContractText(raw: string): DeliveryContractV2;
+export declare function parseDeliveryContractTextForMigration(raw: string): DeliveryContractV2;

package/dist/lib/long-task-delivery-parser.js

@@ -1,5 +1,6 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { materializeLongTaskCompactCarrier, materializeLongTaskCompactCarrierForMigration, } from "./long-task-compact-carrier.js";
 import { parseStrictYaml, sha256Hex } from "./strict-codec.js";
 import { validateDeliveryContractStructure } from "./long-task-delivery-validation.js";
 import { parseOutcome, parseOutcomeFragment, safeFragmentPath, } from "./long-task-outcome-parser.js";
@@ -20,7 +21,11 @@ export async function parseDeliveryContractBundle(workdirInput, repositoryInput,
         ? path.resolve(repositoryInput)
         : await repositoryRoot(workdir);
     const raw = await readFile(await assertProtectedRepositoryFile(repository, file, "delivery_contract"), "utf8");
-    const root = parseRoot(raw, true);
+    let root = parseRoot(raw, true);
+    if (Object.hasOwn(root, "compact_semantic_carrier")) {
+        root = materializeLongTaskCompactCarrier(root).root;
+        assertNoSemanticDriftMigration(semanticDriftMigrationFields(root));
+    }
     const hasInline = Object.hasOwn(root, "outcomes");
     const hasFiles = Object.hasOwn(root, "outcome_files");
     if (hasInline === hasFiles)
@@ -64,7 +69,19 @@ export async function parseDeliveryContractBundle(workdirInput, repositoryInput,
     };
 }
 export function parseDeliveryContractText(raw) {
-    const root = parseRoot(raw, false);
+    return parseDeliveryContractTextInternal(raw, false);
+}
+export function parseDeliveryContractTextForMigration(raw) {
+    return parseDeliveryContractTextInternal(raw, true);
+}
+function parseDeliveryContractTextInternal(raw, allowLegacyCarrier) {
+    let root = parseRoot(raw, false);
+    if (Object.hasOwn(root, "compact_semantic_carrier")) {
+        root = (allowLegacyCarrier
+            ? materializeLongTaskCompactCarrierForMigration(root)
+            : materializeLongTaskCompactCarrier(root)).root;
+        assertNoSemanticDriftMigration(semanticDriftMigrationFields(root));
+    }
     const contract = parseContractRoot(root, array(root.outcomes, "outcomes").map((item, index) => parseOutcome(item, `outcomes[${index}]`)));
     validateDeliveryContractStructure(contract);
     return contract;
@@ -77,16 +94,31 @@ function parseRoot(raw, bundle) {
         decoded.schema_version ===
             "long-task-delivery-v1")
         throw new Error("long_task_delivery_v1_retired_use_v2");
-    assertNoSemanticDriftMigration(semanticDriftMigrationFields(decoded));
-    return object(decoded, "$", [
+    if (!decoded ||
+        typeof decoded !== "object" ||
+        Array.isArray(decoded) ||
+        !Object.hasOwn(decoded, "compact_semantic_carrier"))
+        assertNoSemanticDriftMigration(semanticDriftMigrationFields(decoded));
+    const root = object(decoded, "$", [
         "schema_version",
         "semantic_fact_manifest",
         "task",
-        "source_claims",
         "stages",
         "risk",
         "global",
-    ], bundle ? ["outcomes", "outcome_files"] : ["outcomes"]);
+    ], bundle
+        ? [
+            "source_claims",
+            "compact_semantic_carrier",
+            "outcomes",
+            "outcome_files",
+        ]
+        : ["source_claims", "compact_semantic_carrier", "outcomes"]);
+    const hasExpanded = Object.hasOwn(root, "source_claims");
+    const hasCompact = Object.hasOwn(root, "compact_semantic_carrier");
+    if (hasExpanded === hasCompact)
+        throw new Error("delivery_contract_invalid:$:exactly one of source_claims or compact_semantic_carrier is required");
+    return root;
 }
 function parseContractRoot(root, outcomes) {
     literal(root.schema_version, ["long-task-delivery-v2"], "schema_version");

package/dist/lib/long-task-design-resource-handoff.d.ts

@@ -1,4 +1,5 @@
 import type { DesignResourceHandoffPreflightV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceHandoffPreflightV2 } from "./design-resource-symbolic-fact-types.js";
 import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
 export interface ContractDesignTarget {
     outcome_key: string;
@@ -10,7 +11,7 @@ export interface IndexedHandoffTarget {
     target: DesignResourceHandoffTargetV1;
 }
 export interface LongTaskDesignHandoffConsumer {
-    consume(preflight: DesignResourceHandoffPreflightV1): void;
+    consume(preflight: DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2): void;
     finish(): void;
 }
 export declare function validateLongTaskDesignResourceHandoffs(contract: DeliveryContractV2, repository: string): Promise<void>;

package/dist/lib/long-task-design-resource-handoff.js

@@ -2,8 +2,8 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { containsDesignResourceHandoff, parseDesignResourceHandoffMarkdown, } from "./design-resource-handoff-parser.js";
 import { createDesignResourceHandoffSetIntegrity } from "./design-resource-handoff-set-integrity.js";
-import { preflightParsedDesignResourceHandoff } from "./design-resource-handoff-validation.js";
-import { assertSameSet, designSourceItemClaims, invalid, validateTargetIdentity, validateVerificationMethodBindings, } from "./long-task-design-resource-method-binding.js";
+import { preflightParsedDesignResourceHandoffAny } from "./design-resource-handoff-validation.js";
+import { assertSameSet, designSourceItemClaims, invalid, validateTargetIdentity, validateSymbolicTargetIdentity, validateSymbolicVerificationMethodBindings, validateVerificationMethodBindings, } from "./long-task-design-resource-method-binding.js";
 import { validateLongTaskDesignTargetCapabilities } from "./long-task-design-target-capabilities.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 export async function validateLongTaskDesignResourceHandoffs(contract, repository) {
@@ -15,7 +15,7 @@ export async function validateLongTaskDesignResourceHandoffs(contract, repositor
         const content = await readFile(file, "utf8");
         if (!containsDesignResourceHandoff(content))
             continue;
-        consumer.consume(await preflightParsedDesignResourceHandoff(repository, parseDesignResourceHandoffMarkdown(sourcePath, content)));
+        consumer.consume(await preflightParsedDesignResourceHandoffAny(repository, parseDesignResourceHandoffMarkdown(sourcePath, content)));
     }
     consumer.finish();
 }
@@ -32,9 +32,30 @@ export function createLongTaskDesignHandoffConsumer(contract) {
     let duplicate = null;
     const unbound = [];
     const handoffSetIntegrity = createDesignResourceHandoffSetIntegrity(invalid);
+    const allSourceItems = new Set();
+    const resourcePaths = new Map();
+    let crossVersionIssue = null;
+    const recordCrossVersionIssue = (code, detail) => {
+        crossVersionIssue ??= { code, detail };
+    };
     return {
         consume(preflight) {
-            handoffSetIntegrity.consume(preflight);
+            for (const sourceItem of preflight.source_item_keys) {
+                if (allSourceItems.has(sourceItem))
+                    recordCrossVersionIssue("handoff_set_source_item_duplicate", sourceItem);
+                else
+                    allSourceItems.add(sourceItem);
+            }
+            for (const resource of preflight.handoff.resources) {
+                const identity = JSON.stringify(resource);
+                const previous = resourcePaths.get(resource.path);
+                if (previous && previous !== identity)
+                    recordCrossVersionIssue("handoff_set_resource_path_conflict", resource.path);
+                else
+                    resourcePaths.set(resource.path, identity);
+            }
+            if (!("preflight_schema_version" in preflight))
+                handoffSetIntegrity.consume(preflight);
             for (const target of preflight.handoff.targets) {
                 if (indexedTargetKeys.has(target.key)) {
                     duplicate ??= target.key;
@@ -46,13 +67,27 @@ export function createLongTaskDesignHandoffConsumer(contract) {
                     unbound.push(target.key);
                     continue;
                 }
-                const indexedTarget = { preflight, target };
                 consumed.add(target.key);
                 try {
-                    validateTargetIdentity(contractTarget, indexedTarget);
-                    validateLongTaskDesignTargetCapabilities(contract, contractTarget, indexedTarget);
-                    validateCoverageClaims(contract, contractTarget, indexedTarget);
-                    validateBlockerBindings(contract, contractTarget, indexedTarget);
+                    if ("preflight_schema_version" in preflight) {
+                        const indexedTarget = {
+                            preflight,
+                            target,
+                        };
+                        validateSymbolicTargetIdentity(contractTarget, indexedTarget);
+                        validateSymbolicCoverageClaims(contract, contractTarget, indexedTarget);
+                        validateBlockerBindings(contract, contractTarget, indexedTarget);
+                    }
+                    else {
+                        const indexedTarget = {
+                            preflight,
+                            target: target,
+                        };
+                        validateTargetIdentity(contractTarget, indexedTarget);
+                        validateLongTaskDesignTargetCapabilities(contract, contractTarget, indexedTarget);
+                        validateCoverageClaims(contract, contractTarget, indexedTarget);
+                        validateBlockerBindings(contract, contractTarget, indexedTarget);
+                    }
                 }
                 catch (error) {
                     validationErrors.set(target.key, error);
@@ -63,6 +98,8 @@ export function createLongTaskDesignHandoffConsumer(contract) {
             if (duplicate)
                 invalid("handoff_target_duplicate", duplicate);
             handoffSetIntegrity.finish();
+            if (crossVersionIssue)
+                invalid(crossVersionIssue.code, crossVersionIssue.detail);
             for (const contractTarget of contractTargets) {
                 if (!consumed.has(contractTarget.target.key))
                     invalid("target_handoff_missing", contractTarget.target.key);
@@ -74,6 +111,23 @@ export function createLongTaskDesignHandoffConsumer(contract) {
         },
     };
 }
+function validateSymbolicCoverageClaims(contract, contractTarget, indexed) {
+    const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
+    const rows = indexed.preflight.handoff.coverage.filter((row) => row.target_ref === contractTarget.target.key);
+    if (!rows.length)
+        invalid("v2_target_covered_claims_required", contractTarget.target.key);
+    const sourceItemRefs = [
+        ...new Set([
+            ...rows.flatMap((row) => row.source_item_refs),
+            ...indexed.preflight.manifest.fact_rules.flatMap((rule) => rule.source_item_refs),
+            ...indexed.preflight.manifest.disposition_regions.flatMap((region) => region.source_item_refs),
+        ]),
+    ];
+    const claimsBySourceItem = new Map();
+    for (const sourceItemRef of sourceItemRefs)
+        claimsBySourceItem.set(sourceItemRef, designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims));
+    validateSymbolicVerificationMethodBindings(contract, contractTarget, indexed, claimsBySourceItem);
+}
 function validateCoverageClaims(contract, contractTarget, indexed) {
     const target = contractTarget.target;
     const check = contract.outcomes
@@ -103,8 +157,14 @@ function validateBlockerBindings(contract, contractTarget, indexed) {
         item.key,
         item,
     ]));
-    const availableMethods = new Set(contractTarget.target.verification_method_bindings.map((item) => item.method));
-    for (const blocker of indexed.preflight.handoff.acceptance_blockers) {
+    const availableMethods = new Set([
+        ...contractTarget.target.verification_method_bindings,
+        ...(contractTarget.target.symbolic_method_bindings ?? []),
+    ].map((item) => item.method));
+    const blockers = "preflight_schema_version" in indexed.preflight
+        ? indexed.preflight.manifest.acceptance_blockers
+        : indexed.preflight.handoff.acceptance_blockers;
+    for (const blocker of blockers) {
         if (!blocker.target_refs.includes(contractTarget.target.key))
             continue;
         const contractBlocker = bound.get(blocker.key);