project-tiny-context-harness 0.8.16 → 0.11.0

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

@@ -2,15 +2,6 @@ import { assertAllClaimsCovered, assertAllGlobalClaimsCovered, generateClaims, g
 import { fail } from "./long-task-delivery-shape.js";
 import { validateClaimAssertionOperator, validateGlobalAssertionOperator, } from "./long-task-claim-proof-policy.js";
 import { matchesRepoPattern } from "./long-task-paths.js";
-export function outcomeResultExternallyBlocked(contract, outcomeKey) {
-    const resultClaim = `${outcomeKey}.result`;
-    return contract.global.acceptance.external_confirmations.some((confirmation) => confirmation.blocks_target &&
-        confirmation.impact_claims.includes(resultClaim));
-}
-export function allOutcomeResultsExternallyBlocked(contract) {
-    return (contract.outcomes.length > 0 &&
-        contract.outcomes.every((outcome) => outcomeResultExternallyBlocked(contract, outcome.key)));
-}
 export function compileProductClaimCoverage(contract, options = {}) {
     const byGlobal = generateGlobalClaims(contract.global);
     const byOutcome = Object.fromEntries(contract.outcomes.map((outcome) => [outcome.key, generateClaims(outcome)]));
@@ -326,13 +317,9 @@ function addBlockingExternalConfirmationProofs(contract, claim, proofs) {
         confirmation.impact_claims.includes(claim.id));
     if (!confirmations.length)
         return;
-    const proofSurfaces = "required_proof_surfaces" in claim &&
-        claim.required_proof_surfaces.length > 0
-        ? claim.required_proof_surfaces
-        : ["runtime_behavior"];
     for (const confirmation of confirmations)
         for (const applicabilityRef of claim.applicability_refs)
-            for (const proofSurface of proofSurfaces)
+            for (const proofSurface of externalClaimProofSurfaces(confirmation, claim, applicabilityRef))
                 addProof(proofs, claim.local_key, {
                     check_key: `EXTERNAL.${confirmation.key}`,
                     assertion_key: null,
@@ -341,6 +328,20 @@ function addBlockingExternalConfirmationProofs(contract, claim, proofs) {
                     applicability_ref: applicabilityRef,
                 });
 }
+function externalClaimProofSurfaces(confirmation, claim, applicabilityRef) {
+    const declared = [
+        ...new Set((confirmation.obligations ?? [])
+            .filter((obligation) => obligation.claim_ref === claim.id &&
+            obligation.applicability_ref === applicabilityRef)
+            .map((obligation) => obligation.proof_surface)),
+    ];
+    if (declared.length)
+        return declared;
+    return "required_proof_surfaces" in claim &&
+        claim.required_proof_surfaces.length
+        ? claim.required_proof_surfaces
+        : ["runtime_behavior"];
+}
 function sameSet(left, right) {
     return (left.length === right.length &&
         new Set(left).size === left.length &&

package/dist/lib/long-task-command-process.d.ts

@@ -0,0 +1,9 @@
+export interface SpawnedCommandExecution {
+    exit_code: number;
+    stdout: Buffer;
+    stderr: Buffer;
+    pid: number;
+    started_at: string;
+    completed_at: string;
+}
+export declare function spawnCommandOnce(executable: string, argv: string[], cwd: string, timeoutMs: number, environment: NodeJS.ProcessEnv, containProcessTree: boolean): Promise<SpawnedCommandExecution>;

package/dist/lib/long-task-command-process.js

@@ -0,0 +1,178 @@
+import { spawn } from "node:child_process";
+import { createProcessTreeObserver, } from "./long-task-process-tree.js";
+import { spawnWindowsJobCommandOnce } from "./long-task-windows-job-supervisor.js";
+const OUTPUT_LIMIT = 2 * 1024 * 1024;
+const PROCESS_TREE_GRACE_MS = 1_000;
+export function spawnCommandOnce(executable, argv, cwd, timeoutMs, environment, containProcessTree) {
+    if (containProcessTree && process.platform === "win32")
+        return spawnWindowsJobCommandOnce(executable, argv, cwd, timeoutMs, environment, OUTPUT_LIMIT);
+    return new Promise((resolve, reject) => {
+        const child = spawn(executable, argv, {
+            cwd,
+            shell: false,
+            windowsHide: true,
+            env: environment,
+            detached: containProcessTree && process.platform !== "win32",
+        });
+        const pid = child.pid ?? -1;
+        const processTree = containProcessTree && pid > 0 ? createProcessTreeObserver(pid) : null;
+        const state = {
+            child,
+            pid,
+            processTree,
+            treeMonitor: Promise.resolve(),
+            treeMonitorError: null,
+            stdout: [],
+            stderr: [],
+            size: 0,
+            settled: false,
+            terminationReason: null,
+            terminationTask: null,
+            timer: null,
+            forceTimer: null,
+            abandonTimer: null,
+            startedAt: new Date().toISOString(),
+            resolve,
+            reject,
+        };
+        if (processTree)
+            state.treeMonitor = processTree.wait().catch((error) => {
+                state.treeMonitorError = error;
+            });
+        child.stdout.on("data", captureOutput(state, state.stdout));
+        child.stderr.on("data", captureOutput(state, state.stderr));
+        child.on("error", (error) => handleSpawnError(state, error));
+        child.on("close", (code) => void handleClose(state, code));
+        state.timer = setTimeout(() => terminateExecution(state, "command_timeout"), timeoutMs);
+        if (pid < 0)
+            terminateExecution(state, "command_spawn_pid_unavailable");
+    });
+}
+function captureOutput(state, target) {
+    return (chunk) => {
+        state.size += chunk.length;
+        if (state.size > OUTPUT_LIMIT) {
+            terminateExecution(state, "command_output_limit_exceeded");
+            return;
+        }
+        target.push(Buffer.from(chunk));
+    };
+}
+function handleSpawnError(state, error) {
+    if (state.settled)
+        return;
+    state.settled = true;
+    state.processTree?.stop();
+    clearExecutionTimers(state);
+    const spawnError = new Error(`command_spawn_error:${message(error)}`);
+    if (!state.processTree) {
+        state.reject(spawnError);
+        return;
+    }
+    void state.processTree
+        .terminate(true)
+        .catch(() => undefined)
+        .finally(() => state.reject(spawnError));
+}
+async function handleClose(state, code) {
+    state.processTree?.stop();
+    clearExecutionTimers(state);
+    if (state.settled)
+        return;
+    state.settled = true;
+    if (state.terminationReason) {
+        await finishBoundedTermination(state);
+        state.reject(state.terminationReason);
+        return;
+    }
+    if (!(await assertTreeClosure(state)))
+        return;
+    state.resolve({
+        exit_code: code ?? -1,
+        stdout: Buffer.concat(state.stdout),
+        stderr: Buffer.concat(state.stderr),
+        pid: state.pid,
+        started_at: state.startedAt,
+        completed_at: new Date().toISOString(),
+    });
+}
+async function finishBoundedTermination(state) {
+    try {
+        await state.terminationTask;
+        await state.treeMonitor;
+        if (state.processTree)
+            await state.processTree.forceQuiescence();
+    }
+    catch {
+        // Preserve the original bounded termination reason after the hard cleanup.
+    }
+}
+async function assertTreeClosure(state) {
+    if (!state.processTree)
+        return true;
+    try {
+        await state.treeMonitor;
+        if (state.treeMonitorError)
+            throw state.treeMonitorError;
+        await state.processTree.assertQuiescent();
+        return true;
+    }
+    catch (error) {
+        await state.processTree.terminate(true).catch(() => undefined);
+        state.reject(error);
+        return false;
+    }
+}
+function terminateExecution(state, reason) {
+    if (state.settled || state.terminationReason)
+        return;
+    state.terminationReason = new Error(reason);
+    state.processTree?.stop();
+    startGracefulTermination(state);
+    state.forceTimer = setTimeout(() => startForcedTermination(state), PROCESS_TREE_GRACE_MS);
+    state.forceTimer.unref();
+    state.abandonTimer = setTimeout(() => abandonExecution(state), PROCESS_TREE_GRACE_MS * 2);
+    state.abandonTimer.unref();
+}
+function startGracefulTermination(state) {
+    if (state.processTree)
+        state.terminationTask = state.processTree
+            .terminate(false)
+            .catch((error) => {
+            state.treeMonitorError ??= error;
+        });
+    else {
+        state.child.kill();
+        state.terminationTask = Promise.resolve();
+    }
+}
+function startForcedTermination(state) {
+    if (state.processTree)
+        state.terminationTask = state.processTree.terminate(true).catch((error) => {
+            state.treeMonitorError ??= error;
+        });
+    else
+        state.child.kill("SIGKILL");
+}
+function abandonExecution(state) {
+    if (state.settled)
+        return;
+    state.settled = true;
+    state.child.stdout.destroy();
+    state.child.stderr.destroy();
+    const cleanup = state.processTree
+        ? state.processTree.forceQuiescence().catch(() => undefined)
+        : Promise.resolve();
+    void cleanup.finally(() => state.reject(state.terminationReason));
+}
+function clearExecutionTimers(state) {
+    if (state.timer)
+        clearTimeout(state.timer);
+    if (state.forceTimer)
+        clearTimeout(state.forceTimer);
+    if (state.abandonTimer)
+        clearTimeout(state.abandonTimer);
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -56,6 +56,9 @@ export function createLongTaskCompactContract(contractInput, factRevisions, obli
                 fact_revision_digest: revision,
                 claim_ref: binding.claim_ref,
                 applicability_ref: binding.applicability_ref,
+                ...(binding.required_polarity
+                    ? { required_polarity: binding.required_polarity }
+                    : {}),
             });
         }
         for (const binding of outcome.semantic_fact_bindings.proofs) {

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

@@ -82,6 +82,11 @@ export function materializeLongTaskCompactFactBindings(facts, obligations, factB
             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`),
+            ...(Object.hasOwn(fact, "required_polarity")
+                ? {
+                    required_polarity: compactPolarity(fact.required_polarity, `${label}.required_polarity`),
+                }
+                : {}),
         });
     }
     for (const [index, obligation] of obligations.entries()) {
@@ -107,6 +112,11 @@ export function materializeLongTaskCompactFactBindings(facts, obligations, factB
         });
     }
 }
+function compactPolarity(value, label) {
+    if (value !== "positive" && value !== "negative")
+        compactFail(label, "must be positive or negative");
+    return value;
+}
 export function materializeLongTaskCompactAssertions(assertions, claims, facts, outcomes) {
     for (const [index, projection] of assertions.entries()) {
         const label = `compact_semantic_carrier.assertion_projections.rows[${index}]`;

package/dist/lib/long-task-complete-delivery-evidence-types.d.ts

@@ -0,0 +1,38 @@
+import type { EvidenceCapabilityV2 } from "./long-task-semantic-contract-types.js";
+interface CompleteDeliveryEvidenceBaseV2 {
+    assertion_key: string;
+    capability: EvidenceCapabilityV2;
+}
+export interface ActualProvenanceEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "actual_provenance";
+    source_kind: "product_runtime" | "observer_runtime" | "durable_store";
+    source_ref: string;
+    actual_sha256: string;
+}
+export interface DistinctIdentityEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "distinct_identity";
+    identities: Array<{
+        identity_ref: string;
+        data_state_sha256: string;
+    }>;
+}
+export interface DataStateEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "data_state";
+    state_ref: string;
+    state_sha256: string;
+    read_session_id: string;
+}
+export interface PopulationCoverageEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "population_coverage";
+    universe_sha256: string;
+    observed_sha256: string;
+    excluded_sha256: string;
+    set_equality: true;
+}
+export interface RecoveryEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "recovery";
+    failure_session_id: string;
+    recovery_session_id: string;
+    recovered_state_sha256: string;
+}
+export {};

package/dist/lib/long-task-complete-delivery-evidence-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/long-task-completion-types.d.ts

@@ -0,0 +1,109 @@
+import type { DeliveryContractV2 } from "./long-task-contract-types.js";
+import type { VerifierIdentityV2 } from "./long-task-authority-types.js";
+import type { CheckExecutionResultV2, LongTaskFindingV2 } from "./long-task-runtime-types.js";
+import type { ExternalConfirmationEvaluationV1 } from "./long-task-external-confirmation-types.js";
+export interface TargetedVerificationResultV2 {
+    schema_version: "long-task-targeted-progress-v2";
+    compiled_identity: string;
+    snapshot_sha256: string;
+    acceptance_authorized: false;
+    selected_outcome: string | null;
+    selected_check: string | null;
+    updated_progress_records: string[];
+    check_results: CheckExecutionResultV2[];
+    findings: LongTaskFindingV2[];
+    repair_frontier?: RepairFrontierV1;
+    completed_at: string;
+}
+export interface RepairFrontierCheckV1 {
+    check_ref: string;
+    outcome_key: string | null;
+    check_key: string;
+    raw_execution_identity: string;
+    obligation_refs: string[];
+    reasons: string[];
+}
+export interface RepairFrontierGroupV1 {
+    root_cause_key: string;
+    finding_codes: string[];
+    source_fragment_refs: string[];
+    affected_fact_refs: string[];
+    affected_proof_obligation_refs: string[];
+    affected_claim_refs: string[];
+    expected_authority_refs: string[];
+    actual_evidence_refs: string[];
+    suggested_implementation_owners: string[];
+    suggested_owner_paths: string[];
+    verification_owners: string[];
+    invalidation_reasons: string[];
+    rerun_obligation_refs: string[];
+    minimum_diagnostic_reverify: string[];
+    still_valid_diagnostic_evidence: string[];
+}
+export interface RepairFrontierSessionV1 {
+    raw_execution_identity: string;
+    check_refs: string[];
+    obligation_refs: string[];
+}
+export interface RepairFrontierV1 {
+    schema_version: "long-task-repair-frontier-v1";
+    authority_scope: "derived_diagnostic_only";
+    acceptance_authorized: false;
+    persisted: false;
+    compiled_identity: string;
+    authority_revision: number;
+    candidate_snapshot_sha256: string;
+    changed_paths: string[];
+    summary: {
+        finding_groups: number;
+        affected_facts: number;
+        affected_proof_obligations: number;
+        minimum_checks: number;
+        still_valid_progress_records: number;
+    };
+    groups: RepairFrontierGroupV1[];
+    minimum_diagnostic_reverify: RepairFrontierCheckV1[];
+    rerun_sessions: RepairFrontierSessionV1[];
+    still_valid_diagnostic_evidence: string[];
+    forbidden_authority_changes_without_revision: {
+        fields: string[];
+        protected_paths: string[];
+    };
+    final_gate_requirement: "complete_one_snapshot_rerun_still_required";
+    generated_at: string;
+}
+export type OutcomeStatusV2 = "unverified" | "progress_passing" | "progress_failing" | "progress_stale" | "blocked_external";
+export type StageStatusV2 = "locked" | "ready" | "unverified" | "progress_passing" | "progress_failing" | "progress_stale" | "blocked_external";
+export interface FinalReceiptV2 {
+    schema_version: "long-task-final-receipt-v2" | "long-task-final-receipt-v3";
+    receipt_sha256: string;
+    authority_scope: "audit_only";
+    reusable_for_acceptance: false;
+    workflow_status: "machine_accepted" | "delivery_accepted" | "machine_accepted_external_pending" | "needs_work" | "blocked_external";
+    target_profile: DeliveryContractV2["task"]["target_profile"];
+    target_state: DeliveryContractV2["task"]["target_profile"]["required_state"] | "not_accepted" | "blocked_external";
+    stage_results: Record<string, "passed" | "failed" | "blocked_external" | "blocked_dependency">;
+    compiled_identity: string;
+    contract_sha256: string;
+    snapshot_sha256: string;
+    git_head: string;
+    git_tree: string;
+    source_hashes: Record<string, string>;
+    context_hashes: Record<string, string>;
+    verifier_identity: VerifierIdentityV2;
+    check_results: CheckExecutionResultV2[];
+    outcome_results: Record<string, "passed" | "failed" | "blocked_external">;
+    external_confirmations: DeliveryContractV2["global"]["acceptance"]["external_confirmations"];
+    external_confirmation_results?: ExternalConfirmationEvaluationV1[];
+    findings: LongTaskFindingV2[];
+    snapshot_preparation_ms: number;
+    started_at: string;
+    completed_at: string;
+    /** Present on newly finalized v3 Receipts; historical Receipts remain audit-only. */
+    finalization_identity_sha256?: string;
+}
+export type FinalReceiptV3 = Omit<FinalReceiptV2, "schema_version"> & {
+    schema_version: "long-task-final-receipt-v3";
+    external_confirmation_results: ExternalConfirmationEvaluationV1[];
+    finalization_identity_sha256: string;
+};

package/dist/lib/long-task-completion-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,5 +1,6 @@
 import type { CompiledCheckV2, DeliveryContractV2, EffectiveRiskLevel } from "./long-task-delivery-types.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
 type Reporter = (message: string) => void;
 export declare function semanticConformanceRequired(contract: DeliveryContractV2, _effectiveRisk?: EffectiveRiskLevel): boolean;
-export declare function validateSemanticConformance(contract: DeliveryContractV2, effectiveRisk: EffectiveRiskLevel, compiledChecks: CompiledCheckV2[], report?: Reporter): void;
+export declare function validateSemanticConformance(contract: DeliveryContractV2, effectiveRisk: EffectiveRiskLevel, compiledChecks: CompiledCheckV2[], report?: Reporter, reachability?: AcceptanceReachabilityV1 | null): void;
 export {};

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

@@ -1,4 +1,5 @@
-import { allOutcomeResultsExternallyBlocked } from "./long-task-claims.js";
+import { machineAuthorizedAssertionExists } from "./long-task-acceptance-reachability-helpers.js";
+import { allOutcomeResultsFullyEffectivelyExternallyBlocked } from "./long-task-effective-external-takeover.js";
 export function semanticConformanceRequired(contract, _effectiveRisk) {
     const productFamilies = new Set(contract.task.execution_targets
         .filter((target) => contract.task.target_profile.required_target_refs.includes(target.key))
@@ -6,18 +7,24 @@ export function semanticConformanceRequired(contract, _effectiveRisk) {
     return (contract.risk.facts.weak_observability.length > 0 &&
         (productFamilies.size > 1 || contract.stages.length > 1));
 }
-export function validateSemanticConformance(contract, effectiveRisk, compiledChecks, report) {
+export function validateSemanticConformance(contract, effectiveRisk, compiledChecks, report, reachability) {
     const declared = contract.global.acceptance.checks.filter((check) => check.journey_roles.includes("conformance"));
     if (semanticConformanceRequired(contract, effectiveRisk) &&
         !declared.length &&
-        !allOutcomeResultsExternallyBlocked(contract)) {
+        !allOutcomeResultsFullyEffectivelyExternallyBlocked(contract, reachability)) {
         issue(report, "semantic_conformance_check_required", contract.task.id);
         return;
     }
     for (const check of declared) {
         if (check.runner.effect !== "read_only")
             issue(report, "conformance_check_must_be_read_only", check.key);
-        if (![...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("target_runtime")))
+        if (!machineAuthorizedAssertionExists(compiledChecks, {
+            authority_scope: "ordinary_claim",
+            outcome_key: null,
+            check_key: check.key,
+            check_journey_role: "conformance",
+            required_evidence_capability: "target_runtime",
+        }))
             issue(report, "conformance_target_runtime_evidence_required", check.key);
         const compiled = compiledChecks.find((candidate) => candidate.outcome_key === null && candidate.key === check.key);
         if (!compiled)

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

@@ -1,3 +1,4 @@
+import { compareUtf8Paths, normalizeContextPath, } from "./context-catalog/catalog-paths.js";
 import { canonicalJson, sha256Hex } from "./strict-codec.js";
 /**
  * Hashes only manifest structure that can change the currently selected
@@ -11,13 +12,14 @@ export function contextAuthorityTopologyHash(manifest, selectedFiles) {
             .filter((area) => selected.has(normalizeRepoPath(area.context)))
             .map(({ line: _line, default: _default, forbidden_runtime_dependencies, kind, ...area }) => ({
             ...area,
+            id: area.id.normalize("NFC"),
             ...(kind === undefined ? {} : { kind }),
             context: normalizeRepoPath(area.context),
             forbidden_runtime_dependencies: [
                 ...forbidden_runtime_dependencies,
             ].sort(),
         }))
-            .sort((left, right) => left.id.localeCompare(right.id)),
+            .sort((left, right) => compareUtf8Paths(left.id, 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 }) => ({
@@ -26,12 +28,12 @@ export function contextAuthorityTopologyHash(manifest, selectedFiles) {
             default_children: [...default_children]
                 .map(normalizeRepoPath)
                 .filter((child) => selected.has(child))
-                .sort(),
+                .sort(compareUtf8Paths),
         }))
-            .sort((left, right) => left.path.localeCompare(right.path)),
+            .sort((left, right) => compareUtf8Paths(left.path, right.path)),
     };
     return sha256Hex(canonicalJson(topology));
 }
 function normalizeRepoPath(value) {
-    return value.replace(/\\/gu, "/").replace(/^\.\//u, "");
+    return normalizeContextPath(value);
 }

package/dist/lib/long-task-contract-types.d.ts

@@ -3,7 +3,7 @@ import type { CounterfactualControlV2, GlobalCounterfactualControlV2 } from "./l
 import type { DeliveryControlFieldNameV2 } from "./long-task-control-types.js";
 import type { ApplicableKeyedStatementV2, CheckExecutionTargetV2, ClaimApplicabilityV2, DeliveryJourneyRoleV2, DeliveryScenarioV2, DeliveryStageV2, EvidenceCapabilityV2, ExecutionTargetV2, ExternalConfirmationKindV2, KeyedStatementV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
 import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
-import type { SemanticFactManifestRefV2, SemanticFactOutcomeBindingsV2 } from "./semantic-fact-types.js";
+import type { SemanticFactGlobalBindingsV2, SemanticFactManifestRefV2, SemanticFactOutcomeBindingsV2 } from "./semantic-fact-types.js";
 export type SourceClaimDispositionV2 = {
     type: "claim";
     refs: string[];
@@ -26,16 +26,42 @@ export type SourceClaimDispositionV2 = {
     type: "decision_required";
     reason: string;
 };
+export type ExternalJudgmentBasisKindV2 = "subjective_preference" | "expert_assessment" | "authorization";
+export interface SourceClaimJudgmentBasisV2 {
+    kind: ExternalJudgmentBasisKindV2;
+    claim_ref: string;
+    applicability_refs: string[];
+}
 export interface SourceClaimV2 {
     key: string;
     source_ref: string;
     statement: string;
     disposition: SourceClaimDispositionV2;
+    judgment_basis?: SourceClaimJudgmentBasisV2;
 }
 export interface KeyedPathV2 {
     key: string;
     path: string;
 }
+export type ExternalConfirmationIdentityAssuranceV2 = {
+    scheme: "ed25519";
+    key_id: string;
+    public_key_ref: string;
+} | {
+    scheme: "declared_only";
+};
+export type CompiledExternalConfirmationIdentityAssuranceV2 = {
+    scheme: "ed25519";
+    key_id: string;
+    public_key_ref: string;
+    public_key_sha256: string;
+} | {
+    scheme: "declared_only";
+};
+export interface ExternalConfirmationJudgmentBasisV2 {
+    kind: ExternalJudgmentBasisKindV2;
+    source_ref: string;
+}
 export interface ExternalConfirmationV2 {
     key: string;
     description: string;
@@ -43,6 +69,29 @@ export interface ExternalConfirmationV2 {
     kind: ExternalConfirmationKindV2;
     impact_claims: string[];
     blocks_target: boolean;
+    actor?: {
+        id: string;
+        role: string;
+        authority_kind: "human" | "expert" | "external_system";
+        identity_assurance?: ExternalConfirmationIdentityAssuranceV2;
+    };
+    target_ref?: string;
+    environment_identity?: string;
+    scenario?: DeliveryScenarioV2;
+    evidence_requirements?: KeyedStatementV2[];
+    obligations?: Array<{
+        key: string;
+        claim_ref: string;
+        applicability_ref: string;
+        fact_ref: string | null;
+        proof_ref: string | null;
+        method: string;
+        proof_surface: ProofSurface;
+        evidence_capabilities: EvidenceCapabilityV2[];
+        expected_authority_ref: string;
+        result_kind: "actual" | "judgment";
+        judgment_basis?: ExternalConfirmationJudgmentBasisV2;
+    }>;
 }
 export type ProofSurface = "ui_browser" | "runtime_behavior" | "api_contract" | "data_state" | "security_boundary" | "population_coverage" | "implementation_structure";
 export type RunnerType = "package_script" | "project_binary" | "node_oracle" | "playwright_test";
@@ -56,6 +105,7 @@ interface DeliveryAssertionBaseV2 {
     applicability_ref?: string;
     observation: string;
     evidence_capabilities: EvidenceCapabilityV2[];
+    expected_authority_ref?: string;
 }
 export type DeliveryAssertionV2 = (DeliveryAssertionBaseV2 & {
     operator: PresenceOrUnaryAssertionOperator;
@@ -247,6 +297,7 @@ export interface DeliveryContractV2 {
     };
     global: {
         applicability: ClaimApplicabilityV2[];
+        semantic_fact_bindings?: SemanticFactGlobalBindingsV2;
         product: {
             non_goals: ApplicableKeyedStatementV2[];
         };

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

@@ -1,13 +1,19 @@
 import type { CompiledCheckV2, CounterfactualControlV2, GlobalCounterfactualControlV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
 export interface CounterfactualSandboxV2 {
     root: string;
+    mutation_source_root: string;
     dispose(): Promise<void>;
 }
+export interface CounterfactualProcessExecutionRootV2 {
+    root: string;
+    mutation_source_root: string;
+}
 type RemoveTree = (target: string, options: {
     recursive: true;
     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, protectedAuthorityPaths?: readonly string[]): Promise<CounterfactualSandboxV2>;
+export declare function createCounterfactualSandbox(snapshotRoot: string, check: CompiledCheckV2, control: CounterfactualControlV2 | GlobalCounterfactualControlV2, bindingCarrierPaths: string[], manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[], executionUniverse?: readonly CompiledCheckV2[]): Promise<CounterfactualSandboxV2>;
+export declare function counterfactualSandboxProcessExecution(sandbox: CounterfactualSandboxV2): CounterfactualProcessExecutionRootV2 | null;
 export declare function removeCounterfactualSandboxRoot(root: string, removeTree?: RemoveTree, wait?: Wait): Promise<void>;
 export {};