project-tiny-context-harness 0.8.16 → 0.11.0

package/dist/lib/long-task-source-supersession.js

@@ -0,0 +1,138 @@
+import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
+export function validateSameDomainSupersession(projection, material, facts, factClasses, factDomains, sourceDomains, sourceByKey, manifest) {
+    if (!projection.fact_refs.length)
+        semanticFactClosureInvalid("source_supersession_successor_fact_required", material.key);
+    const oldFactRefs = materialInputFactRefs(material, manifest);
+    if (!oldFactRefs.length)
+        semanticFactClosureInvalid("source_supersession_prior_fact_required", material.key);
+    const oldCells = semanticCells(oldFactRefs, material, facts, factClasses, factDomains);
+    const successorCells = semanticCells(projection.fact_refs, material, facts, factClasses, factDomains);
+    if (!sameSet(oldCells, successorCells))
+        semanticFactClosureInvalid("source_supersession_semantic_cell_mismatch", `${material.key}:${[...oldCells].sort().join(",")}:${[...successorCells]
+            .sort()
+            .join(",")}`);
+    const priorSources = new Set(material.authority_source_item_refs);
+    const supersedingSources = projection.basis_refs
+        .flatMap((ref) => projectionBasisSourceItems(ref, manifest, sourceByKey))
+        .filter((ref) => !priorSources.has(ref));
+    if (!supersedingSources.length)
+        semanticFactClosureInvalid("source_supersession_basis_required", material.key);
+    for (const sourceRef of [...new Set(supersedingSources)]) {
+        if (sourceDomains.get(sourceRef) !== material.authority_domain)
+            semanticFactClosureInvalid("source_supersession_domain_mismatch", `${material.key}:${sourceRef}:${material.authority_domain}:${sourceDomains.get(sourceRef)}`);
+        for (const factRef of projection.fact_refs) {
+            const fact = facts.get(factRef);
+            if (!fact.source_item_refs.includes(sourceRef) ||
+                !hasFactBearingSuccessorFragment(sourceRef, factRef, fact.basis_refs, manifest))
+                semanticFactClosureInvalid("source_supersession_basis_not_fact_bearing", `${material.key}:${sourceRef}:${factRef}`);
+        }
+    }
+}
+export function validateSameDomainScopeExclusion(projection, material, sourceDomains, sourceByKey, manifest) {
+    const exclusions = manifest.scope.exclusions.filter((row) => row.affected_refs.includes(projection.input_key));
+    if (exclusions.length !== 1)
+        semanticFactClosureInvalid(exclusions.length
+            ? "source_projection_scope_exclusion_ambiguous"
+            : "source_projection_scope_exclusion_missing", `${material.key}:${projection.input_key}`);
+    const exclusion = exclusions[0];
+    if (!projection.basis_refs.includes(exclusion.key))
+        semanticFactClosureInvalid("source_scope_exclusion_projection_binding_missing", `${material.key}:${exclusion.key}`);
+    const affectedFactRefs = exactAffectedFactRefs(exclusion.affected_refs, manifest);
+    if (!affectedFactRefs.length)
+        semanticFactClosureInvalid("source_scope_exclusion_exact_obligation_required", `${material.key}:${exclusion.key}`);
+    const materialFactRefs = new Set(materialInputFactRefs(material, manifest));
+    if (affectedFactRefs.some((factRef) => !materialFactRefs.has(factRef)))
+        semanticFactClosureInvalid("source_scope_exclusion_exact_binding_mismatch", `${material.key}:${exclusion.key}:${affectedFactRefs.join(",")}`);
+    const excludedSources = new Set(material.authority_source_item_refs);
+    for (const ref of exclusion.source_item_refs)
+        if (excludedSources.has(ref))
+            semanticFactClosureInvalid("source_scope_exclusion_owner_not_independent", `${material.key}:${ref}`);
+    const owners = exclusion.source_item_refs.filter((ref) => {
+        if (sourceDomains.get(ref) !== material.authority_domain)
+            return false;
+        const item = sourceByKey.get(ref);
+        if (!item || !["decision", "non_goal"].includes(item.kind))
+            return false;
+        const sourceInput = manifest.inputs.find((input) => input.kind === "source_item" && input.source_ref === ref);
+        return affectedFactRefs.every((factRef) => sourceInput?.fact_refs.includes(factRef));
+    });
+    if (!exclusion.source_item_refs.length ||
+        owners.length !== exclusion.source_item_refs.length)
+        semanticFactClosureInvalid("source_scope_exclusion_same_domain_owner_required", `${material.key}:${material.authority_domain}`);
+}
+function materialInputFactRefs(material, manifest) {
+    const inputKey = "input_key" in material
+        ? material.input_key
+        : material.fragment_ref.split("#fragment:", 1)[0];
+    const input = manifest.inputs.find((candidate) => candidate.key === inputKey ||
+        (candidate.kind === "source_item" && candidate.source_ref === inputKey));
+    return input?.fact_refs ?? [];
+}
+function semanticCells(refs, material, facts, factClasses, factDomains) {
+    const result = new Set();
+    for (const factRef of refs) {
+        const fact = facts.get(factRef);
+        if (!fact)
+            semanticFactClosureInvalid("source_supersession_fact_unknown", `${material.key}:${factRef}`);
+        if (factClasses[factRef] !== "delivery_semantic" ||
+            factDomains[factRef] !== material.authority_domain ||
+            !fact.semantic_cell)
+            semanticFactClosureInvalid("source_supersession_delivery_cell_required", `${material.key}:${factRef}`);
+        result.add(semanticCellIdentity(fact.semantic_cell));
+    }
+    return result;
+}
+function semanticCellIdentity(cell) {
+    return [
+        cell.outcome_ref,
+        cell.unit_ref,
+        cell.family_ref,
+        cell.condition_ref,
+        cell.property_ref,
+        cell.value_kind,
+    ].join("\0");
+}
+function sameSet(left, right) {
+    return (left.size === right.size && [...left].every((value) => right.has(value)));
+}
+function projectionBasisSourceItems(ref, manifest, sourceByKey) {
+    if (sourceByKey.has(ref))
+        return [ref];
+    const input = manifest.inputs.find((item) => item.key === ref);
+    if (!input)
+        return [];
+    if (input.kind === "source_item")
+        return [input.source_ref];
+    if (input.kind === "source_fragment" || input.kind === "semantic_anchor") {
+        const inputKey = input.source_ref.split("#fragment:", 1)[0];
+        if (sourceByKey.has(inputKey))
+            return [inputKey];
+        const materialInput = manifest.inputs.find((item) => item.key === inputKey);
+        if (!materialInput)
+            return [];
+        return materialInput.basis_refs.filter((basisRef) => sourceByKey.has(basisRef));
+    }
+    return input.basis_refs.filter((basisRef) => sourceByKey.has(basisRef));
+}
+function hasFactBearingSuccessorFragment(sourceRef, factRef, factBasisRefs, manifest) {
+    return manifest.inputs.some((input) => input.kind === "source_fragment" &&
+        input.source_ref.startsWith(`${sourceRef}#fragment:`) &&
+        input.disposition === "fact_bearing" &&
+        input.fact_refs.includes(factRef) &&
+        factBasisRefs.includes(input.key));
+}
+function exactAffectedFactRefs(refs, manifest) {
+    const facts = new Set(manifest.facts.map((fact) => fact.key));
+    const result = new Set();
+    for (const ref of refs) {
+        if (facts.has(ref))
+            result.add(ref);
+        const cell = manifest.fact_cells.find((candidate) => candidate.key === ref);
+        if (cell?.fact_ref)
+            result.add(cell.fact_ref);
+        const proof = manifest.proof_obligations.find((candidate) => candidate.key === ref);
+        if (proof)
+            result.add(proof.fact_ref);
+    }
+    return [...result].sort();
+}

package/dist/lib/long-task-stage-policy.d.ts

@@ -1,4 +1,9 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { CompiledOutcomeV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
 type Reporter = (message: string) => void;
-export declare function validateDeliveryStages(contract: DeliveryContractV2, report?: Reporter): void;
+export declare function validateDeliveryStages(contract: DeliveryContractV2, report?: Reporter, options?: {
+    defer_completion_authority_closure?: boolean;
+    acceptance_reachability?: AcceptanceReachabilityV1 | null;
+    compiled_outcomes?: readonly CompiledOutcomeV2[];
+}): void;
 export {};

package/dist/lib/long-task-stage-policy.js

@@ -1,5 +1,6 @@
-import { outcomeResultExternallyBlocked } from "./long-task-claims.js";
-export function validateDeliveryStages(contract, report) {
+import { machineAuthorizedAssertions } from "./long-task-acceptance-reachability-helpers.js";
+import { resultApplicabilityEffectivelyExternallyBlocked, resultApplicabilityProfiles, } from "./long-task-effective-external-takeover.js";
+export function validateDeliveryStages(contract, report, options = {}) {
     unique(contract.stages.map((stage) => stage.key), "stage_key_duplicate", report);
     const stages = new Map(contract.stages.map((stage) => [stage.key, stage]));
     const outcomes = new Map(contract.outcomes.map((outcome) => [outcome.key, outcome]));
@@ -20,7 +21,7 @@ export function validateDeliveryStages(contract, report) {
         if (!stages.has(outcome.stage))
             issue(report, "outcome_stage_unknown", `${outcome.key}:${outcome.stage}`);
     validateStageCycles(contract, report);
-    validateStageGateClosure(contract, report);
+    validateStageGateClosure(contract, report, options);
 }
 function validateStageCycles(contract, report) {
     const stages = new Map(contract.stages.map((stage) => [stage.key, stage]));
@@ -43,7 +44,7 @@ function validateStageCycles(contract, report) {
     for (const stage of stages.keys())
         visit(stage);
 }
-function validateStageGateClosure(contract, report) {
+function validateStageGateClosure(contract, report, options = {}) {
     const outcomes = new Map(contract.outcomes.map((outcome) => [outcome.key, outcome]));
     for (const stage of contract.stages) {
         const gate = outcomes.get(stage.gate_outcome);
@@ -61,23 +62,38 @@ function validateStageGateClosure(contract, report) {
                     issue(report, "stage_outcome_missing_gate_dependency", `${stage.key}:${outcome.key}:${dependencyGate}`);
         }
         const stageGateChecks = gate.acceptance.checks.filter((check) => check.journey_roles.includes("stage_gate"));
-        const resultExternallyBlocked = outcomeResultExternallyBlocked(contract, gate.key);
+        if (options.defer_completion_authority_closure)
+            continue;
+        const compiledGate = options.compiled_outcomes?.find((candidate) => candidate.key === gate.key);
+        const gateProfiles = stageGateApplicabilityProfiles(gate);
+        const resultExternallyBlocked = gateProfiles.length > 0 &&
+            gateProfiles.every((profile) => resultApplicabilityEffectivelyExternallyBlocked(options.acceptance_reachability, gate.key, profile.key, profile.target_ref));
         if (!stageGateChecks.length && !resultExternallyBlocked)
             issue(report, "stage_gate_check_required", `${stage.key}:${gate.key}`);
         else if (!resultExternallyBlocked &&
-            !stageGateChecks.some((check) => provesGate(check, gate)))
+            !gateProfiles.every((profile) => resultApplicabilityEffectivelyExternallyBlocked(options.acceptance_reachability, gate.key, profile.key, profile.target_ref) ||
+                provesGate(gate, profile.key, options.compiled_outcomes === undefined
+                    ? undefined
+                    : compiledGate?.acceptance.checks, stageGateChecks)))
             issue(report, "stage_gate_target_runtime_result_required", `${stage.key}:${gate.key}`);
-        for (const targetRef of resultExternallyBlocked
-            ? []
-            : contract.task.target_profile.required_target_refs)
-            if (!stageGateChecks.some((check) => check.execution_target.target_ref === targetRef &&
-                check.execution_target.entrypoint === "root" &&
-                provesGate(check, gate)))
+        for (const targetRef of contract.task.target_profile.required_target_refs)
+            if (!gateProfilesForTarget(gateProfiles, targetRef).length ||
+                !gateProfilesForTarget(gateProfiles, targetRef).every((profile) => resultApplicabilityEffectivelyExternallyBlocked(options.acceptance_reachability, gate.key, profile.key, profile.target_ref) ||
+                    provesGate(gate, profile.key, options.compiled_outcomes === undefined
+                        ? undefined
+                        : compiledGate?.acceptance.checks, stageGateChecks, targetRef)))
                 issue(report, "stage_gate_required_target_proof_missing", `${stage.key}:${targetRef}`);
         const stageOutcomes = contract.outcomes.filter((candidate) => candidate.stage === stage.key);
         if (!resultExternallyBlocked &&
             stageOutcomes.length > 1 &&
-            !stageGateChecks.some((check) => [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("cross_surface_consistency"))))
+            !(options.compiled_outcomes === undefined
+                ? stageGateChecks.some((check) => [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.claims.length > 0 &&
+                    assertion.evidence_capabilities.includes("cross_surface_consistency")))
+                : machineAuthorizedAssertions(compiledGate?.acceptance.checks ?? [], {
+                    authority_scope: "ordinary_claim",
+                    check_journey_role: "stage_gate",
+                    required_evidence_capability: "cross_surface_consistency",
+                }).some((match) => match.check.execution_target.entrypoint === "root")))
             issue(report, "stage_gate_cross_surface_consistency_required", `${stage.key}:${stageOutcomes.map((outcome) => outcome.key).join(",")}`);
     }
     for (const outcome of contract.outcomes)
@@ -86,16 +102,44 @@ function validateStageGateClosure(contract, report) {
                 !contract.stages.some((stage) => stage.gate_outcome === outcome.key))
                 issue(report, "stage_gate_role_on_non_gate", `${outcome.key}:${check.key}`);
 }
-function provesGate(check, gate) {
-    const assertions = [
-        ...check.positive_assertions,
-        ...check.negative_assertions,
-    ];
-    const provesResult = assertions.some((assertion) => assertion.claims.includes("result")) ||
-        (gate.acceptance.population?.check_key === check.key &&
-            gate.acceptance.population.claims.includes("result"));
-    return (provesResult &&
-        assertions.some((assertion) => assertion.evidence_capabilities.includes("target_runtime")));
+function stageGateApplicabilityProfiles(gate) {
+    const exactStageProfiles = resultApplicabilityProfiles(gate, {
+        journey_role: "stage_gate",
+    });
+    return exactStageProfiles.length
+        ? exactStageProfiles
+        : resultApplicabilityProfiles(gate);
+}
+function gateProfilesForTarget(profiles, targetRef) {
+    return profiles.filter((profile) => profile.target_ref === targetRef);
+}
+function provesGate(gate, applicabilityRef, compiledChecks, declaredChecks, targetRef) {
+    if (compiledChecks !== undefined)
+        return machineAuthorizedAssertions(compiledChecks, {
+            authority_scope: "ordinary_claim",
+            local_claim_ref: "result",
+            applicability_ref: applicabilityRef,
+            target_ref: targetRef,
+            check_journey_role: "stage_gate",
+            required_evidence_capability: "target_runtime",
+        }).some((match) => match.check.execution_target.entrypoint === "root");
+    return declaredChecks.some((check) => {
+        if (targetRef !== undefined &&
+            check.execution_target.target_ref !== targetRef)
+            return false;
+        if (check.execution_target.entrypoint !== "root")
+            return false;
+        const assertions = [
+            ...check.positive_assertions,
+            ...check.negative_assertions,
+        ];
+        const provesResult = assertions.some((assertion) => assertion.claims.includes("result") &&
+            assertion.applicability_ref === applicabilityRef &&
+            assertion.evidence_capabilities.includes("target_runtime")) ||
+            (gate.acceptance.population?.check_key === check.key &&
+                gate.acceptance.population.claims.includes("result"));
+        return provesResult;
+    });
 }
 function outcomeDependsOn(start, target, outcomes) {
     const seen = new Set();

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

@@ -1,4 +1,4 @@
-import type { CompiledDeliveryContractV2, FinalReceiptV2, InitialTaskBaseV2, ProgressRecordV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
+import type { CompiledDeliveryContractV2, FinalReceiptV2, FinalReceiptV3, InitialTaskBaseV2, ProgressRecordV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
 import type { AuthorityRevisionProposalV2 } from "./long-task-authority-revision-types.js";
 export interface ActiveLongTaskAuthorityV3 {
     schema_version: "active-long-task-authority-v3";
@@ -20,7 +20,12 @@ export interface ActiveAuthorityLoadResultV3 {
     source: "none" | "active_authority_v3";
     migrated: boolean;
 }
-export type ActiveAuthorityLockOperation = "commit" | "clear" | "abandon" | "migrate";
+export type ActiveAuthorityLockOperation = "compile" | "commit" | "clear" | "abandon" | "migrate" | "external_confirmation" | "context_mutation" | "finalize";
+export interface ActiveAuthorityLockToken {
+    readonly repository_root: string;
+    readonly operation: ActiveAuthorityLockOperation;
+    readonly lock_id: string;
+}
 export interface ActiveAuthorityIdentityExpectation {
     task_id: string;
     authority_revision: number;
@@ -44,7 +49,7 @@ export declare function worktreeIdentity(repositoryRoot: string): string;
 export declare function activeRecordPath(repositoryRoot: string): Promise<string>;
 export declare function activeAuthorityLockPath(repositoryRoot: string): Promise<string>;
 export declare function activeAuthorityLockExists(repositoryRoot: string): Promise<boolean>;
-export declare function withActiveAuthorityLock<T>(repositoryRoot: string, operation: ActiveAuthorityLockOperation, action: () => Promise<T>): Promise<T>;
+export declare function withActiveAuthorityLock<T>(repositoryRoot: string, operation: ActiveAuthorityLockOperation, action: (token: ActiveAuthorityLockToken) => Promise<T>): Promise<T>;
 export declare function writeCompiledDeliveryContract(compiled: CompiledDeliveryContractV2): Promise<void>;
 export declare function stageCompiledDeliveryContract(compiled: CompiledDeliveryContractV2): Promise<StagedCompiledDeliveryContractV2>;
 export declare function readCompiledDeliveryContract(workdir: string): Promise<CompiledDeliveryContractV2>;
@@ -70,7 +75,16 @@ export declare function approvePendingAuthorityRevision(workdir: string, revisio
 export declare function authorityRevisionApproved(workdir: string, revision: string): Promise<boolean>;
 export declare function clearAuthorityRevision(workdir: string): Promise<void>;
 export declare function invalidateDerivedProgress(workdir: string): Promise<void>;
-export declare function writeFinalReceipt(repositoryRoot: string, workdir: string, unsigned: Omit<FinalReceiptV2, "receipt_sha256">): Promise<FinalReceiptV2>;
+export declare function sealFinalReceipt(unsigned: Omit<FinalReceiptV3, "receipt_sha256">): FinalReceiptV3;
+export declare function commitFinalReceiptTransaction(input: {
+    lock_token: ActiveAuthorityLockToken;
+    repository_root: string;
+    workdir: string;
+    unsigned: Omit<FinalReceiptV3, "receipt_sha256">;
+    expected_authority: ActiveAuthorityIdentityExpectation;
+    close_on_accept: boolean;
+    validate_current: (phase: "after_receipt_stage" | "after_receipt_publish" | "after_authority_clear") => Promise<void>;
+}): Promise<FinalReceiptV3>;
 export declare function readFinalReceipt(_repositoryRoot: string, workdir: string): Promise<FinalReceiptV2 | null>;
 export declare function activeAuthorityIdentityMatches(authority: ActiveLongTaskAuthorityV3, expected: ActiveAuthorityIdentityExpectation): boolean;
 export declare function clearActiveBindingCas(options: ClearActiveBindingCasOptions): Promise<boolean>;