project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,170 +0,0 @@
-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]));
-    for (const stage of contract.stages) {
-        for (const dependency of stage.depends_on) {
-            if (dependency === stage.key)
-                issue(report, "stage_dependency_self", stage.key);
-            else if (!stages.has(dependency))
-                issue(report, "stage_dependency_unknown", `${stage.key}:${dependency}`);
-        }
-        const gate = outcomes.get(stage.gate_outcome);
-        if (!gate)
-            issue(report, "stage_gate_outcome_unknown", `${stage.key}:${stage.gate_outcome}`);
-        else if (gate.stage !== stage.key)
-            issue(report, "stage_gate_outcome_mismatch", `${stage.key}:${gate.key}`);
-    }
-    for (const outcome of contract.outcomes)
-        if (!stages.has(outcome.stage))
-            issue(report, "outcome_stage_unknown", `${outcome.key}:${outcome.stage}`);
-    validateStageCycles(contract, report);
-    validateStageGateClosure(contract, report, options);
-}
-function validateStageCycles(contract, report) {
-    const stages = new Map(contract.stages.map((stage) => [stage.key, stage]));
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (key) => {
-        if (visiting.has(key)) {
-            issue(report, "stage_dependency_cycle", key);
-            return;
-        }
-        if (visited.has(key))
-            return;
-        visiting.add(key);
-        for (const dependency of stages.get(key)?.depends_on ?? [])
-            if (stages.has(dependency))
-                visit(dependency);
-        visiting.delete(key);
-        visited.add(key);
-    };
-    for (const stage of stages.keys())
-        visit(stage);
-}
-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);
-        if (!gate || gate.stage !== stage.key)
-            continue;
-        for (const outcome of contract.outcomes.filter((candidate) => candidate.stage === stage.key && candidate.key !== gate.key))
-            if (!outcomeDependsOn(gate.key, outcome.key, outcomes))
-                issue(report, "stage_gate_missing_outcome_dependency", `${stage.key}:${gate.key}:${outcome.key}`);
-        for (const dependency of stage.depends_on) {
-            const dependencyGate = contract.stages.find((candidate) => candidate.key === dependency)?.gate_outcome;
-            if (!dependencyGate)
-                continue;
-            for (const outcome of contract.outcomes.filter((candidate) => candidate.stage === stage.key))
-                if (!outcomeDependsOn(outcome.key, dependencyGate, outcomes))
-                    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"));
-        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 &&
-            !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 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 &&
-            !(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)
-        for (const check of outcome.acceptance.checks)
-            if (check.journey_roles.includes("stage_gate") &&
-                !contract.stages.some((stage) => stage.gate_outcome === outcome.key))
-                issue(report, "stage_gate_role_on_non_gate", `${outcome.key}:${check.key}`);
-}
-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();
-    const visit = (key) => {
-        if (key === target)
-            return true;
-        if (seen.has(key))
-            return false;
-        seen.add(key);
-        return (outcomes.get(key)?.depends_on ?? []).some(visit);
-    };
-    return visit(start);
-}
-function unique(values, code, report) {
-    const seen = new Set();
-    for (const value of values) {
-        if (seen.has(value))
-            issue(report, code, value);
-        seen.add(value);
-    }
-}
-function issue(report, code, detail) {
-    const message = `delivery_contract_invalid:${code}:${detail}`;
-    if (report)
-        report(message);
-    else
-        throw new Error(message);
-}

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

@@ -1,93 +0,0 @@
-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";
-    task_id: string;
-    repository_root: string;
-    worktree_identity: string;
-    workdir: string;
-    active_authority_identity: string;
-    authority_revision: number;
-    initial_task_base: InitialTaskBaseV2;
-    verifier_identity: VerifierIdentityV2;
-    activated_at: string;
-    authority_snapshot: CompiledDeliveryContractV2;
-    authority_snapshot_sha256: string;
-}
-export type CompiledCacheStatusV3 = "compiled_cache_matching" | "compiled_cache_missing_repairable" | "compiled_cache_mismatched_ignored";
-export interface ActiveAuthorityLoadResultV3 {
-    authority: ActiveLongTaskAuthorityV3 | null;
-    source: "none" | "active_authority_v3";
-    migrated: boolean;
-}
-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;
-    compiled_identity: string;
-    worktree_identity?: string;
-}
-export interface ClearActiveBindingCasOptions extends ActiveAuthorityIdentityExpectation {
-    repository_root: string;
-    workdir: string;
-}
-export interface StagedCompiledDeliveryContractV2 {
-    publish(): Promise<void>;
-    discard(): Promise<void>;
-}
-export interface PendingAuthorityRevisionV2 extends AuthorityRevisionProposalV2 {
-    schema_version: "long-task-authority-revision-pending-v2";
-    created_at: string;
-}
-export declare function runtimePath(workdir: string, file?: string): string;
-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: (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>;
-export declare function loadActiveLongTaskAuthority(repositoryRoot: string, _options?: {
-    migrate_legacy?: boolean;
-}): Promise<ActiveAuthorityLoadResultV3>;
-export declare function loadActiveCompiledAuthority(repositoryRoot: string, workdir?: string, options?: {
-    migrate_legacy?: boolean;
-}): Promise<CompiledDeliveryContractV2 | null>;
-export declare function readActiveLongTaskBinding(repositoryRoot: string): Promise<ActiveLongTaskAuthorityV3 | null>;
-export declare function inspectCompiledCache(authority: ActiveLongTaskAuthorityV3): Promise<CompiledCacheStatusV3>;
-export declare function commitActiveAuthority(options: {
-    candidate: CompiledDeliveryContractV2;
-    expected_previous_identity: string | null;
-}): Promise<ActiveLongTaskAuthorityV3>;
-export declare function activateDeliveryContract(compiled: CompiledDeliveryContractV2): Promise<ActiveLongTaskAuthorityV3>;
-export declare function assertMatchingActiveBinding(compiled: CompiledDeliveryContractV2): Promise<ActiveLongTaskAuthorityV3>;
-export declare function writeProgressRecord(workdir: string, record: ProgressRecordV2): Promise<void>;
-export declare function readProgressRecords(workdir: string): Promise<Record<string, ProgressRecordV2>>;
-export declare function writePendingAuthorityRevision(workdir: string, pending: PendingAuthorityRevisionV2): Promise<void>;
-export declare function readPendingAuthorityRevision(workdir: string): Promise<PendingAuthorityRevisionV2 | null>;
-export declare function approvePendingAuthorityRevision(workdir: string, revision: string): Promise<void>;
-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 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>;
-export declare function abandonLongTaskState(repositoryRoot: string, workdir: string): Promise<void>;
-export declare function forceClearCorruptActiveState(repositoryRoot: string, workdir: string): Promise<void>;
-export declare function clearFinalReceipt(repositoryRoot: string, workdir: string): Promise<void>;