project-tiny-context-harness 0.2.84 → 0.6.0

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

@@ -0,0 +1,136 @@
+import { array, fail, key, literal, object, parseEnvironmentRequirements, PROOF_SURFACES, repositoryCwd, repositoryFile, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
+export function parseCheck(value, label) {
+    const row = object(value, label, ["key", "proof_surface", "runner", "verification_inputs"], [
+        "input_paths",
+        "expected_output_paths",
+        "artifact_globs",
+        "positive_assertions",
+        "negative_assertions",
+        "environment_requirements",
+    ]);
+    return {
+        key: key(row.key, `${label}.key`),
+        proof_surface: literal(row.proof_surface, PROOF_SURFACES, `${label}.proof_surface`),
+        runner: parseRunner(row.runner, `${label}.runner`),
+        verification_inputs: repositoryPatterns(row.verification_inputs, `${label}.verification_inputs`),
+        input_paths: Object.hasOwn(row, "input_paths")
+            ? repositoryPatterns(row.input_paths, `${label}.input_paths`)
+            : [],
+        expected_output_paths: Object.hasOwn(row, "expected_output_paths")
+            ? repositoryPatterns(row.expected_output_paths, `${label}.expected_output_paths`)
+            : [],
+        artifact_globs: Object.hasOwn(row, "artifact_globs")
+            ? repositoryPatterns(row.artifact_globs, `${label}.artifact_globs`)
+            : [],
+        positive_assertions: Object.hasOwn(row, "positive_assertions")
+            ? parseAssertions(row.positive_assertions, `${label}.positive_assertions`)
+            : [],
+        negative_assertions: Object.hasOwn(row, "negative_assertions")
+            ? parseAssertions(row.negative_assertions, `${label}.negative_assertions`)
+            : [],
+        environment_requirements: Object.hasOwn(row, "environment_requirements")
+            ? parseEnvironmentRequirements(row.environment_requirements, `${label}.environment_requirements`)
+            : [],
+    };
+}
+function parseRunner(value, label) {
+    const row = object(value, label, ["type", "target", "effect"], ["argv", "cwd", "timeout_ms", "retry_policy", "idempotent"]);
+    const timeout = Object.hasOwn(row, "timeout_ms")
+        ? Number(row.timeout_ms)
+        : 30_000;
+    if (!Number.isInteger(timeout) || timeout < 100 || timeout > 3_600_000)
+        fail(`${label}.timeout_ms`, "must be an integer from 100 to 3600000");
+    if (Object.hasOwn(row, "idempotent") && typeof row.idempotent !== "boolean")
+        fail(`${label}.idempotent`, "must be a boolean");
+    const type = literal(row.type, [
+        "package_script",
+        "project_binary",
+        "node_oracle",
+        "playwright_test",
+    ], `${label}.type`);
+    return {
+        type,
+        target: type === "package_script"
+            ? string(row.target, `${label}.target`)
+            : repositoryFile(row.target, `${label}.target`),
+        argv: Object.hasOwn(row, "argv") ? strings(row.argv, `${label}.argv`) : [],
+        cwd: Object.hasOwn(row, "cwd")
+            ? repositoryCwd(row.cwd, `${label}.cwd`)
+            : ".",
+        timeout_ms: timeout,
+        effect: literal(row.effect, ["read_only", "test_sandbox"], `${label}.effect`),
+        retry_policy: Object.hasOwn(row, "retry_policy")
+            ? literal(row.retry_policy, ["none", "transient_once"], `${label}.retry_policy`)
+            : "none",
+        idempotent: Object.hasOwn(row, "idempotent")
+            ? row.idempotent
+            : false,
+    };
+}
+function parseAssertions(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, ["key", "claims", "observation", "operator"], ["criterion", "expected"]);
+        const operator = literal(row.operator, [
+            "equals",
+            "not_equals",
+            "contains",
+            "not_contains",
+            "matches",
+            "not_matches",
+            "greater_than",
+            "greater_or_equal",
+            "less_than",
+            "less_or_equal",
+            "truthy",
+            "falsy",
+            "exists",
+            "set_equals",
+            "subset_of",
+            "superset_of",
+        ], `${itemLabel}.operator`);
+        const hasExpected = Object.hasOwn(row, "expected");
+        if (isBinaryAssertionOperator(operator) && !hasExpected)
+            fail(itemLabel, "assertion_expected_required");
+        if (!isBinaryAssertionOperator(operator) && hasExpected)
+            fail(itemLabel, "assertion_expected_forbidden");
+        if (isBinaryAssertionOperator(operator))
+            validateAssertionExpected(operator, row.expected, itemLabel);
+        const base = {
+            key: key(row.key, `${itemLabel}.key`),
+            ...(Object.hasOwn(row, "criterion")
+                ? { criterion: string(row.criterion, `${itemLabel}.criterion`) }
+                : {}),
+            claims: strings(row.claims, `${itemLabel}.claims`),
+            observation: string(row.observation, `${itemLabel}.observation`),
+            operator,
+        };
+        return isBinaryAssertionOperator(operator)
+            ? { ...base, operator, expected: row.expected }
+            : {
+                ...base,
+                operator: operator,
+            };
+    });
+}
+function isBinaryAssertionOperator(operator) {
+    return !["exists", "truthy", "falsy"].includes(operator);
+}
+function validateAssertionExpected(operator, expected, label) {
+    if (operator === "matches" || operator === "not_matches") {
+        if (typeof expected !== "string")
+            fail(label, "assertion_expected_string_required");
+        try {
+            new RegExp(expected, "u");
+        }
+        catch {
+            fail(label, "assertion_expected_invalid_regex");
+        }
+    }
+    if (["greater_than", "greater_or_equal", "less_than", "less_or_equal"].includes(operator) &&
+        (typeof expected !== "number" || !Number.isFinite(expected)))
+        fail(label, "assertion_expected_finite_number_required");
+    if (["set_equals", "subset_of", "superset_of"].includes(operator) &&
+        !Array.isArray(expected))
+        fail(label, "assertion_expected_array_required");
+}

package/dist/lib/long-task-claim-definitions.d.ts

@@ -0,0 +1,7 @@
+import type { ClaimProofV2, DeliveryContractV2, DeliveryOutcomeV2, GlobalClaimV2, ProductClaimV2 } from "./long-task-delivery-types.js";
+export declare function generateClaims(outcome: DeliveryOutcomeV2): ProductClaimV2[];
+export declare function generateGlobalClaims(global: DeliveryContractV2["global"]): GlobalClaimV2[];
+export declare function validateGlobalProofPolarity(claim: GlobalClaimV2, proof: ClaimProofV2): void;
+export declare function validateProofSurface(claim: ProductClaimV2, proof: ClaimProofV2, outcomeKey: string): void;
+export declare function assertAllClaimsCovered(uncovered: string[]): void;
+export declare function assertAllGlobalClaimsCovered(uncovered: string[]): void;

package/dist/lib/long-task-claim-definitions.js

@@ -0,0 +1,78 @@
+import { fail } from "./long-task-delivery-shape.js";
+export function generateClaims(outcome) {
+    const claims = [claim(outcome.key, "result", "result")];
+    for (const requirement of outcome.product.requirements)
+        claims.push(claim(outcome.key, `requirement.${requirement.key}`, "requirement", requirement.required_proof_surfaces));
+    for (const control of outcome.product.controls) {
+        const fields = [
+            ["location", control.location],
+            ["trigger", control.trigger],
+            ["input", control.input],
+            ["loading", control.loading_state],
+            ["empty", control.empty_state],
+            ["success", control.success_state],
+            ["failure", control.failure_state],
+            ["feedback", control.feedback],
+        ];
+        for (const [field, value] of fields)
+            if (value.trim())
+                claims.push(claim(outcome.key, `control.${control.key}.${field}`, "control", [
+                    "ui_browser",
+                ]));
+    }
+    for (const item of outcome.product.non_completing_outcomes)
+        claims.push(claim(outcome.key, `non_completing.${item.key}`, "non_completing"));
+    for (const item of outcome.technical.obligations)
+        claims.push(claim(outcome.key, `obligation.${item.key}`, "obligation", item.required_proof_surfaces));
+    for (const item of outcome.technical.forbidden_shortcuts)
+        claims.push(claim(outcome.key, `forbidden_shortcut.${item.key}`, "forbidden_shortcut"));
+    return claims;
+}
+export function generateGlobalClaims(global) {
+    return [
+        ...global.product.non_goals.map((item) => globalClaim(`non_goal.${item.key}`, "global_non_goal", "negative")),
+        ...global.technical.constraints.map((item) => globalClaim(`constraint.${item.key}`, "global_constraint", "any")),
+        ...global.technical.forbidden_shortcuts.map((item) => globalClaim(`forbidden_shortcut.${item.key}`, "global_forbidden_shortcut", "negative")),
+    ].sort((left, right) => left.id.localeCompare(right.id));
+}
+export function validateGlobalProofPolarity(claim, proof) {
+    if (claim.required_polarity === "negative" && proof.polarity !== "negative")
+        fail("global_negative_claim_proof_required", `${claim.local_key}:${proof.check_key}`);
+}
+export function validateProofSurface(claim, proof, outcomeKey) {
+    if (claim.kind === "control" && proof.proof_surface !== "ui_browser")
+        fail("ui_claim_requires_ui_browser", `${outcomeKey}:${claim.local_key}`);
+    if ((claim.kind === "non_completing" || claim.kind === "forbidden_shortcut") &&
+        proof.polarity !== "negative" &&
+        proof.polarity !== "counterfactual")
+        fail("negative_or_counterfactual_claim_proof_required", `${outcomeKey}:${claim.local_key}`);
+    if ((claim.kind === "requirement" || claim.kind === "obligation") &&
+        claim.required_proof_surfaces.length > 0 &&
+        !claim.required_proof_surfaces.includes(proof.proof_surface))
+        fail(`${claim.kind}_proof_surface_mismatch`, `${outcomeKey}:${claim.local_key}:${proof.proof_surface}`);
+}
+export function assertAllClaimsCovered(uncovered) {
+    if (uncovered.length)
+        fail("product_claim_uncovered", uncovered.sort().join(","));
+}
+export function assertAllGlobalClaimsCovered(uncovered) {
+    if (uncovered.length)
+        fail("global_claim_uncovered", uncovered.sort().join(","));
+}
+function claim(outcomeKey, localKey, kind, requiredProofSurfaces = []) {
+    return {
+        id: `${outcomeKey}.${localKey}`,
+        outcome_key: outcomeKey,
+        local_key: localKey,
+        kind,
+        required_proof_surfaces: requiredProofSurfaces,
+    };
+}
+function globalClaim(localKey, kind, requiredPolarity) {
+    return {
+        id: `GLOBAL.${localKey}`,
+        local_key: localKey,
+        kind,
+        required_polarity: requiredPolarity,
+    };
+}

package/dist/lib/long-task-claim-proof-policy.d.ts

@@ -0,0 +1,4 @@
+import type { DeliveryAssertionV2, DeliveryContractV2, ProductClaimV2, ProofSurface } from "./long-task-delivery-types.js";
+export declare function validateDeclaredCheckSafety(contract: DeliveryContractV2, report?: (message: string) => void): void;
+export declare function validateClaimAssertionOperator(claim: ProductClaimV2, assertion: DeliveryAssertionV2, proofSurface: ProofSurface, outcomeKey: string, checkKey: string): void;
+export declare function validateGlobalAssertionOperator(assertion: DeliveryAssertionV2, checkKey: string): void;

package/dist/lib/long-task-claim-proof-policy.js

@@ -0,0 +1,57 @@
+const PRESENCE_OR_UNARY = new Set(["exists", "truthy", "falsy"]);
+export function validateDeclaredCheckSafety(contract, report) {
+    for (const check of contract.global.acceptance.checks)
+        validateCheck(check, null, report);
+    for (const outcome of contract.outcomes)
+        for (const check of outcome.acceptance.checks)
+            validateCheck(check, outcome.key, report);
+}
+export function validateClaimAssertionOperator(claim, assertion, proofSurface, outcomeKey, checkKey) {
+    if (!assertion.claims.length || !PRESENCE_OR_UNARY.has(assertion.operator))
+        return;
+    const implementationStructureObligation = claim.kind === "obligation" &&
+        proofSurface === "implementation_structure" &&
+        claim.required_proof_surfaces.includes("implementation_structure");
+    if (assertion.operator === "exists" && implementationStructureObligation)
+        return;
+    throw new Error(`claim_assertion_explicit_expected_required:${outcomeKey}:${checkKey}:${assertion.key}`);
+}
+export function validateGlobalAssertionOperator(assertion, checkKey) {
+    if (assertion.claims.length && PRESENCE_OR_UNARY.has(assertion.operator))
+        throw new Error(`claim_assertion_explicit_expected_required:GLOBAL:${checkKey}:${assertion.key}`);
+}
+function validateCheck(check, outcomeKey, report) {
+    for (const assertion of [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ]) {
+        if (!assertion.criterion)
+            issue(report, `assertion_criterion_required:${outcomeKey ?? "GLOBAL"}.${check.key}.${assertion.key}`);
+        if (check.runner.type === "playwright_test" && assertion.claims.length) {
+            const canonical = assertion.observation === `playwright.case.${assertion.key}.passed` &&
+                assertion.operator === "equals" &&
+                assertion.expected === true;
+            if (!canonical)
+                issue(report, `playwright_claim_assertion_invalid:${outcomeKey ?? "GLOBAL"}:${check.key}:${assertion.key}`);
+        }
+        if (outcomeKey === null)
+            captureOrReport(report, () => validateGlobalAssertionOperator(assertion, check.key));
+    }
+}
+function issue(report, message) {
+    if (!report)
+        throw new Error(message);
+    report(message);
+}
+function captureOrReport(report, action) {
+    if (!report) {
+        action();
+        return;
+    }
+    try {
+        action();
+    }
+    catch (error) {
+        report(error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/lib/long-task-claims.d.ts

@@ -0,0 +1,10 @@
+import type { ClaimCoverageSummaryV2, DeliveryContractV2, GlobalClaimV2, ProductClaimV2 } from "./long-task-delivery-types.js";
+export interface CompiledClaimsV2 {
+    by_global: GlobalClaimV2[];
+    by_outcome: Record<string, ProductClaimV2[]>;
+    summary: ClaimCoverageSummaryV2;
+}
+export declare function compileProductClaimCoverage(contract: DeliveryContractV2, options?: {
+    allow_uncovered?: boolean;
+}): CompiledClaimsV2;
+export declare function assertCompiledClaimsCovered(compiled: CompiledClaimsV2): void;

package/dist/lib/long-task-claims.js

@@ -0,0 +1,187 @@
+import { assertAllClaimsCovered, assertAllGlobalClaimsCovered, generateClaims, generateGlobalClaims, validateGlobalProofPolarity, validateProofSurface, } from "./long-task-claim-definitions.js";
+import { fail } from "./long-task-delivery-shape.js";
+import { validateClaimAssertionOperator, validateGlobalAssertionOperator, } from "./long-task-claim-proof-policy.js";
+export function compileProductClaimCoverage(contract, options = {}) {
+    const byGlobal = generateGlobalClaims(contract.global);
+    const byOutcome = Object.fromEntries(contract.outcomes.map((outcome) => [outcome.key, generateClaims(outcome)]));
+    for (const [outcomeKey, claims] of Object.entries(byOutcome))
+        if (!claims.some((claim) => claim.kind !== "result"))
+            fail("outcome_atomic_claim_required", outcomeKey);
+    const globalClaimMap = new Map(byGlobal.map((claim) => [claim.local_key, claim]));
+    const outcomeClaimIds = new Set(Object.values(byOutcome)
+        .flat()
+        .map((claim) => claim.id));
+    const globalProofs = new Map();
+    const addGlobalProof = (claimKey, proof) => {
+        const claim = globalClaimMap.get(claimKey);
+        if (!claim) {
+            if (outcomeClaimIds.has(claimKey))
+                fail("global_assertion_claim_cross_scope", claimKey);
+            fail("global_assertion_claim_unknown", claimKey);
+        }
+        validateGlobalProofPolarity(claim, proof);
+        const rows = globalProofs.get(claimKey) ?? [];
+        rows.push(proof);
+        globalProofs.set(claimKey, rows);
+    };
+    for (const check of contract.global.acceptance.checks) {
+        const assertionKeys = new Set();
+        for (const [polarity, assertions] of [
+            ["positive", check.positive_assertions],
+            ["negative", check.negative_assertions],
+        ])
+            for (const assertion of assertions) {
+                if (assertionKeys.has(assertion.key))
+                    fail("assertion_key_duplicate", `GLOBAL:${check.key}:${assertion.key}`);
+                assertionKeys.add(assertion.key);
+                validateGlobalAssertionOperator(assertion, check.key);
+                for (const claimKey of assertion.claims)
+                    addGlobalProof(claimKey, {
+                        check_key: check.key,
+                        assertion_key: assertion.key,
+                        polarity,
+                        proof_surface: check.proof_surface,
+                    });
+            }
+    }
+    const globalRows = {};
+    const uncoveredGlobal = [];
+    for (const claim of byGlobal) {
+        const proofs = globalProofs.get(claim.local_key) ?? [];
+        const covered = proofs.length > 0;
+        globalRows[claim.local_key] = { covered, proofs };
+        if (!covered)
+            uncoveredGlobal.push(claim.id);
+    }
+    const outcomeKeys = new Set(contract.outcomes.map((outcome) => outcome.key));
+    const globalLocalKeys = new Set(byGlobal.map((claim) => claim.local_key));
+    const summaryRows = {};
+    const uncoveredOutcome = [];
+    for (const outcome of contract.outcomes) {
+        const claims = byOutcome[outcome.key];
+        const claimMap = new Map(claims.map((claim) => [claim.local_key, claim]));
+        const proofs = new Map();
+        const addProof = (claimKey, proof, observation, assertion) => {
+            const claim = claimMap.get(claimKey);
+            if (!claim) {
+                if (globalLocalKeys.has(claimKey))
+                    fail("assertion_claim_cross_scope", `${outcome.key}:${claimKey}`);
+                const first = claimKey.split(".")[0];
+                if (outcomeKeys.has(first) && first !== outcome.key)
+                    fail("assertion_claim_cross_outcome", `${outcome.key}:${claimKey}`);
+                fail("assertion_claim_unknown", `${outcome.key}:${claimKey}`);
+            }
+            if (observation === "playwright.passed" &&
+                (claim.kind === "requirement" || claim.kind === "control"))
+                fail("fine_grained_claim_requires_ac_observation", `${outcome.key}:${claim.local_key}`);
+            validateProofSurface(claim, proof, outcome.key);
+            if (assertion)
+                validateClaimAssertionOperator(claim, assertion, proof.proof_surface, outcome.key, proof.check_key);
+            const rows = proofs.get(claimKey) ?? [];
+            rows.push(proof);
+            proofs.set(claimKey, rows);
+        };
+        for (const check of outcome.acceptance.checks) {
+            const assertionKeys = new Set();
+            for (const [polarity, assertions] of [
+                ["positive", check.positive_assertions],
+                ["negative", check.negative_assertions],
+            ]) {
+                for (const assertion of assertions) {
+                    if (assertionKeys.has(assertion.key))
+                        fail("assertion_key_duplicate", `${outcome.key}:${check.key}:${assertion.key}`);
+                    assertionKeys.add(assertion.key);
+                    for (const claimKey of assertion.claims)
+                        addProof(claimKey, {
+                            check_key: check.key,
+                            assertion_key: assertion.key,
+                            polarity,
+                            proof_surface: check.proof_surface,
+                        }, assertion.observation, assertion);
+                }
+            }
+        }
+        if (outcome.acceptance.population) {
+            const population = outcome.acceptance.population;
+            const check = outcome.acceptance.checks.find((candidate) => candidate.key === population.check_key);
+            if (!check)
+                fail("outcome_check_reference_unknown", `${outcome.key}:${population.check_key}`);
+            for (const claimKey of population.claims)
+                addProof(claimKey, {
+                    check_key: check.key,
+                    assertion_key: null,
+                    polarity: "population",
+                    proof_surface: check.proof_surface,
+                });
+        }
+        for (const counterfactual of outcome.acceptance.counterfactual_controls) {
+            const check = outcome.acceptance.checks.find((candidate) => candidate.key === counterfactual.check_key);
+            if (!check)
+                fail("outcome_check_reference_unknown", `${outcome.key}:${counterfactual.check_key}`);
+            const assertionKeys = new Set([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.key));
+            if (!counterfactual.expected_assertion_failures.length)
+                fail("counterfactual_expected_assertion_required", `${outcome.key}:${counterfactual.key}`);
+            for (const assertionKey of counterfactual.expected_assertion_failures)
+                if (!assertionKeys.has(assertionKey))
+                    fail("counterfactual_assertion_unknown", `${outcome.key}:${counterfactual.key}:${assertionKey}`);
+            for (const claimKey of counterfactual.claims)
+                addProof(claimKey, {
+                    check_key: check.key,
+                    assertion_key: counterfactual.expected_assertion_failures.join(","),
+                    polarity: "counterfactual",
+                    proof_surface: check.proof_surface,
+                });
+        }
+        const rows = {};
+        for (const claim of claims) {
+            const claimProofs = proofs.get(claim.local_key) ?? [];
+            const requiredSurfaces = [...claim.required_proof_surfaces].sort();
+            const coveredSurfaces = [
+                ...new Set(claimProofs.map((proof) => proof.proof_surface)),
+            ].sort();
+            const missingSurfaces = requiredSurfaces.filter((surface) => !coveredSurfaces.includes(surface));
+            const covered = claimProofs.length > 0 &&
+                (requiredSurfaces.length === 0 || missingSurfaces.length === 0);
+            rows[claim.local_key] = {
+                required_surfaces: requiredSurfaces,
+                covered_surfaces: coveredSurfaces,
+                missing_surfaces: missingSurfaces,
+                covered,
+                proofs: claimProofs,
+            };
+            if (claimProofs.length && missingSurfaces.length)
+                fail("product_claim_required_surfaces_missing", `${outcome.key}:${claim.local_key}:${missingSurfaces.join(",")}`);
+            if (!covered)
+                uncoveredOutcome.push(claim.id);
+        }
+        summaryRows[outcome.key] = rows;
+    }
+    const uncovered = [...uncoveredGlobal, ...uncoveredOutcome].sort();
+    const total = byGlobal.length +
+        Object.values(byOutcome).reduce((sum, claims) => sum + claims.length, 0);
+    const compiled = {
+        by_global: byGlobal,
+        by_outcome: byOutcome,
+        summary: {
+            claims_total: total,
+            claims_covered: total - uncovered.length,
+            uncovered_claims: uncovered,
+            claims_by_global: globalRows,
+            claims_by_outcome: summaryRows,
+        },
+    };
+    if (!options.allow_uncovered)
+        assertCompiledClaimsCovered(compiled);
+    return compiled;
+}
+export function assertCompiledClaimsCovered(compiled) {
+    const uncoveredGlobal = compiled.by_global
+        .filter((claim) => !compiled.summary.claims_by_global[claim.local_key]?.covered)
+        .map((claim) => claim.id);
+    const uncoveredOutcome = Object.values(compiled.by_outcome)
+        .flat()
+        .filter((claim) => !compiled.summary.claims_by_outcome[claim.outcome_key]?.[claim.local_key]?.covered)
+        .map((claim) => claim.id);
+    assertAllGlobalClaimsCovered(uncoveredGlobal);
+    assertAllClaimsCovered(uncoveredOutcome);
+}

package/dist/lib/long-task-context-authority-topology.d.ts

@@ -0,0 +1,7 @@
+import type { ContextManifest } from "./context-manifest-schema.js";
+/**
+ * Hashes only manifest structure that can change the currently selected
+ * durable Context authority. Retrieval aliases and load guidance remain in
+ * context.toml for future Agent routing but do not revise an active delivery.
+ */
+export declare function contextAuthorityTopologyHash(manifest: ContextManifest, selectedFiles: Iterable<string>): string;

package/dist/lib/long-task-context-authority-topology.js

@@ -0,0 +1,37 @@
+import { canonicalJson, sha256Hex } from "./strict-codec.js";
+/**
+ * Hashes only manifest structure that can change the currently selected
+ * durable Context authority. Retrieval aliases and load guidance remain in
+ * context.toml for future Agent routing but do not revise an active delivery.
+ */
+export function contextAuthorityTopologyHash(manifest, selectedFiles) {
+    const selected = new Set([...selectedFiles].map(normalizeRepoPath));
+    const topology = {
+        areas: manifest.areas
+            .filter((area) => selected.has(normalizeRepoPath(area.context)))
+            .map(({ line: _line, default: _default, forbidden_runtime_dependencies, kind, ...area }) => ({
+            ...area,
+            ...(kind === undefined ? {} : { kind }),
+            context: normalizeRepoPath(area.context),
+            forbidden_runtime_dependencies: [
+                ...forbidden_runtime_dependencies,
+            ].sort(),
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id)),
+        contexts: manifest.contexts
+            .filter((context) => selected.has(normalizeRepoPath(context.path)))
+            .map(({ line: _line, read_when: _readWhen, read_policy: _readPolicy, triggers: _triggers, default_children, ...context }) => ({
+            ...context,
+            path: normalizeRepoPath(context.path),
+            default_children: [...default_children]
+                .map(normalizeRepoPath)
+                .filter((child) => selected.has(child))
+                .sort(),
+        }))
+            .sort((left, right) => left.path.localeCompare(right.path)),
+    };
+    return sha256Hex(canonicalJson(topology));
+}
+function normalizeRepoPath(value) {
+    return value.replace(/\\/gu, "/").replace(/^\.\//u, "");
+}

package/dist/lib/long-task-context-authority.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledDeliveryContractV2, ContextAuthoritySnapshotV2 } from "./long-task-delivery-types.js";
+export interface NormalizedContextAuthoritySnapshotV2 extends ContextAuthoritySnapshotV2 {
+    controlling_files: string[];
+    supporting_files: string[];
+}
+export declare function normalizeContextAuthoritySnapshot(snapshot: ContextAuthoritySnapshotV2): NormalizedContextAuthoritySnapshotV2;
+export declare function contextAuthorityProjection(snapshot: ContextAuthoritySnapshotV2): {
+    mode: ContextAuthoritySnapshotV2["mode"];
+    topology_sha256: string;
+    controlling_files: string[];
+    sha256: Record<string, string>;
+};
+export declare function contextAuthorityChanged(previous: ContextAuthoritySnapshotV2, next: ContextAuthoritySnapshotV2): boolean;
+export declare function canRetainProgressForSupportingContextRevision(previous: CompiledDeliveryContractV2, next: CompiledDeliveryContractV2): boolean;

package/dist/lib/long-task-context-authority.js

@@ -0,0 +1,66 @@
+import { canonicalValueJson } from "./strict-codec.js";
+export function normalizeContextAuthoritySnapshot(snapshot) {
+    const files = uniqueSorted(snapshot.files);
+    const available = new Set(files);
+    const declaredAuthority = Array.isArray(snapshot.controlling_files)
+        ? snapshot.controlling_files.filter((file) => available.has(file))
+        : files;
+    const declaredSupporting = Array.isArray(snapshot.supporting_files)
+        ? snapshot.supporting_files.filter((file) => available.has(file))
+        : [];
+    const authority = new Set(declaredAuthority);
+    const supporting = new Set(declaredSupporting.filter((file) => !authority.has(file)));
+    for (const file of files)
+        if (!authority.has(file) && !supporting.has(file))
+            authority.add(file);
+    return {
+        mode: snapshot.mode,
+        topology_sha256: snapshot.topology_sha256,
+        files,
+        sha256: Object.fromEntries(files
+            .filter((file) => file in snapshot.sha256)
+            .map((file) => [file, snapshot.sha256[file]])),
+        controlling_files: [...authority].sort(),
+        supporting_files: [...supporting].sort(),
+    };
+}
+export function contextAuthorityProjection(snapshot) {
+    const normalized = normalizeContextAuthoritySnapshot(snapshot);
+    return {
+        mode: normalized.mode,
+        topology_sha256: normalized.topology_sha256,
+        controlling_files: normalized.controlling_files,
+        sha256: Object.fromEntries(normalized.controlling_files
+            .filter((file) => file in normalized.sha256)
+            .map((file) => [file, normalized.sha256[file]])),
+    };
+}
+export function contextAuthorityChanged(previous, next) {
+    return !same(contextAuthorityProjection(previous), contextAuthorityProjection(next));
+}
+export function canRetainProgressForSupportingContextRevision(previous, next) {
+    const previousContext = normalizeContextAuthoritySnapshot(previous.context_snapshot);
+    const nextContext = normalizeContextAuthoritySnapshot(next.context_snapshot);
+    if (same(previousContext, nextContext))
+        return false;
+    if (contextAuthorityChanged(previousContext, nextContext))
+        return false;
+    return same(progressRetentionProjection(previous), progressRetentionProjection(next));
+}
+function progressRetentionProjection(compiled) {
+    const { compiled_identity: _compiledIdentity, authority_revision: _authorityRevision, context_snapshot: contextSnapshot, authority_materials: authorityMaterials, ...rest } = compiled;
+    return {
+        ...rest,
+        context_snapshot: contextAuthorityProjection(contextSnapshot),
+        authority_materials: {
+            ...authorityMaterials,
+            context_snapshot: contextAuthorityProjection(authorityMaterials.context_snapshot),
+        },
+    };
+}
+function same(left, right) {
+    return canonicalValueJson(left) === canonicalValueJson(right);
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort();
+}