project-tiny-context-harness 0.6.2 → 0.7.1

package/dist/lib/long-task-authority-revision-diagnosis.js

@@ -0,0 +1,141 @@
+import path from "node:path";
+import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
+import { projectAuthorityRevisionDecision } from "./long-task-authority-revision-summary.js";
+import { activeAuthorityIdentityMatches, loadActiveLongTaskAuthority, } from "./long-task-state.js";
+import { allCompiledChecks, runDeliveryChecks, selectChecks, } from "./long-task-verifier-v2.js";
+import { createWorkspaceSnapshot, repositoryRoot, } from "./long-task-workspace.js";
+export async function diagnoseAuthorityRevision(workdirInput, selection = {}) {
+    const repository = await repositoryRoot(process.cwd());
+    const loaded = await loadActiveLongTaskAuthority(repository, {
+        migrate_legacy: true,
+    });
+    const active = loaded.authority;
+    if (!active)
+        throw new Error("active_task_missing");
+    const workdir = path.resolve(workdirInput);
+    if (active.workdir !== workdir)
+        throw new Error("active_task_workdir_mismatch");
+    const revisionCapture = {
+        proposal: null,
+    };
+    const candidate = await compileDeliveryContract(workdir, repository, {
+        revise: true,
+        previous_authority: active.authority_snapshot,
+        authority_revision_mode: "diagnose",
+        on_authority_revision(value) {
+            revisionCapture.proposal = value;
+        },
+    });
+    if (candidate.task.id !== active.task_id)
+        throw new Error("active_task_id_mismatch");
+    if (!(await activeIdentityStillMatches(repository, active)))
+        throw new Error("active_authority_changed_during_revision_diagnosis");
+    const proposal = revisionCapture.proposal;
+    if (!proposal)
+        return result({
+            status: "no_authority_change",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: null,
+            selection,
+        });
+    const decision = projectAuthorityRevisionDecision(proposal);
+    if (proposal.change_class === "monotonic_evidence_strengthening")
+        return result({
+            status: "monotonic_revision_available",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: decision,
+            selection,
+        });
+    if (proposal.change_class !== "scope_only_expansion")
+        return result({
+            status: "protected_change_previewed",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: decision,
+            selection,
+        });
+    const selected = selectChecks(candidate, selection);
+    const activeCheckIds = new Set(allCompiledChecks(active.authority_snapshot).map((check) => check.internal_id));
+    const runnable = selected.filter((check) => activeCheckIds.has(check.internal_id));
+    const skipped = selected
+        .filter((check) => !activeCheckIds.has(check.internal_id))
+        .map((check) => check.internal_id)
+        .sort();
+    if (!runnable.length)
+        return result({
+            status: "scope_candidate_previewed",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: decision,
+            selection,
+            skipped,
+        });
+    const snapshot = await createWorkspaceSnapshot(candidate.repository_root, candidate.workdir, `revision-diagnosis-${candidate.task.id}`);
+    try {
+        const run = await runDeliveryChecks(candidate, snapshot, runnable, true);
+        const unchanged = await activeIdentityStillMatches(repository, active);
+        if (!unchanged)
+            run.findings.push(activeAuthorityChangedFinding());
+        return result({
+            status: unchanged ? "scope_candidate_exercised" : "candidate_stale",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: decision,
+            selection,
+            skipped,
+            diagnosticsExecuted: true,
+            snapshotSha256: snapshot.manifest.snapshot_sha256,
+            checkResults: run.check_results,
+            findings: run.findings,
+        });
+    }
+    finally {
+        await snapshot.dispose();
+    }
+}
+async function activeIdentityStillMatches(repository, active) {
+    try {
+        const current = (await loadActiveLongTaskAuthority(repository)).authority;
+        return (current !== null &&
+            activeAuthorityIdentityMatches(current, {
+                task_id: active.task_id,
+                authority_revision: active.authority_revision,
+                compiled_identity: active.active_authority_identity,
+                worktree_identity: active.worktree_identity,
+            }));
+    }
+    catch {
+        return false;
+    }
+}
+function activeAuthorityChangedFinding() {
+    return {
+        code: "active_authority_changed_during_revision_diagnosis",
+        outcome_key: null,
+        check_key: null,
+        message: "Active Authority changed while candidate diagnosis was running.",
+        next_action: "Discard these transient results and diagnose the current Contract against the new Active Authority.",
+    };
+}
+function result(input) {
+    return {
+        schema_version: "long-task-authority-revision-diagnosis-v2",
+        status: input.status,
+        active_compiled_identity: input.activeIdentity,
+        candidate_compiled_identity: input.candidateIdentity,
+        revision: input.revision,
+        acceptance_authorized: false,
+        progress_written: false,
+        pending_revision_written: false,
+        diagnostics_executed: input.diagnosticsExecuted ?? false,
+        selected_outcome: input.selection.outcome ?? null,
+        selected_check: input.selection.check ?? null,
+        skipped_candidate_checks: input.skipped ?? [],
+        snapshot_sha256: input.snapshotSha256 ?? null,
+        check_results: input.checkResults ?? [],
+        findings: input.findings ?? [],
+        completed_at: new Date().toISOString(),
+    };
+}

package/dist/lib/long-task-authority-revision-enforcement.d.ts

@@ -1,3 +1,5 @@
+import type { AuthorityRevisionProposalV2 } from "./long-task-authority-revision-types.js";
 import type { AuthorityHashesV2, CompiledDeliveryContractV2, CompiledOutcomeV2, DeliveryContractV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
 export declare function assertRiskNotDowngraded(previous: CompiledDeliveryContractV2, nextLevel: "standard" | "strict", nextReasons: string[]): void;
-export declare function enforceAuthorityRevision(previous: CompiledDeliveryContractV2, nextContract: DeliveryContractV2, nextHashes: AuthorityHashesV2, nextMaterials: NextAuthorityMaterialsV2, nextGlobalChecks: CompiledDeliveryContractV2["global"]["acceptance"]["checks"], nextOutcomes: CompiledOutcomeV2[], nextVerifier: VerifierIdentityV2, workdir: string, riskFloor: "standard" | "strict"): Promise<void>;
+export declare function buildAuthorityRevisionProposal(previous: CompiledDeliveryContractV2, nextContract: DeliveryContractV2, nextHashes: AuthorityHashesV2, nextMaterials: NextAuthorityMaterialsV2, nextGlobalChecks: CompiledDeliveryContractV2["global"]["acceptance"]["checks"], nextOutcomes: CompiledOutcomeV2[], nextVerifier: VerifierIdentityV2, riskFloor: "standard" | "strict"): AuthorityRevisionProposalV2;
+export declare function enforceAuthorityRevision(proposal: AuthorityRevisionProposalV2, workdir: string): Promise<void>;

package/dist/lib/long-task-authority-revision-enforcement.js

@@ -1,6 +1,7 @@
 import { changedAuthoritySections } from "./long-task-authority.js";
 import { authorityMaterialHashes, compiledAuthorityMaterials, } from "./long-task-authority-materials.js";
-import { authorityRevisionDiff, } from "./long-task-authority-revision.js";
+import { authorityRevisionDiff } from "./long-task-authority-revision.js";
+import { classifyAuthorityRevision, summarizeAuthorityRevision, } from "./long-task-authority-revision-summary.js";
 import { authorityRevisionApproved, writePendingAuthorityRevision, } from "./long-task-state.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 export function assertRiskNotDowngraded(previous, nextLevel, nextReasons) {
@@ -11,11 +12,11 @@ export function assertRiskNotDowngraded(previous, nextLevel, nextReasons) {
     if (removed.length)
         throw new Error(`authority_risk_downgrade_rejected:${removed.join(",")}`);
 }
-export async function enforceAuthorityRevision(previous, nextContract, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier, workdir, riskFloor) {
+export function buildAuthorityRevisionProposal(previous, nextContract, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier, riskFloor) {
     const previousMaterials = compiledAuthorityMaterials(previous);
     const diff = authorityRevisionDiff(previous, nextContract, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier);
-    if (!diff.reduction_reasons.length)
-        return;
+    const changeClass = classifyAuthorityRevision(diff);
+    const approvalSummary = summarizeAuthorityRevision(diff, nextContract.outcomes.map((outcome) => outcome.key));
     const unsignedRevision = {
         previous_hashes: previous.authority_hashes,
         next_hashes: nextHashes,
@@ -26,16 +27,23 @@ export async function enforceAuthorityRevision(previous, nextContract, nextHashe
         changed_authority_sections: changedAuthoritySections(previous.authority_hashes, nextHashes),
         revision_diff: diff,
         new_risk_floor: riskFloor,
-        affected_outcomes_or_contracts: nextContract.outcomes.map((outcome) => outcome.key),
+        affected_outcomes_or_contracts: approvalSummary.affected_outcomes,
+        change_class: changeClass,
+        approval_required: diff.reduction_reasons.length > 0,
+        approval_summary: approvalSummary,
     };
     const revisionIdentity = sha256Hex(canonicalValueJson(unsignedRevision));
-    if (!(await authorityRevisionApproved(workdir, revisionIdentity))) {
+    return { ...unsignedRevision, revision_identity: revisionIdentity };
+}
+export async function enforceAuthorityRevision(proposal, workdir) {
+    if (!proposal.approval_required)
+        return;
+    if (!(await authorityRevisionApproved(workdir, proposal.revision_identity))) {
         await writePendingAuthorityRevision(workdir, {
             schema_version: "long-task-authority-revision-pending-v2",
-            ...unsignedRevision,
-            revision_identity: revisionIdentity,
+            ...proposal,
             created_at: new Date().toISOString(),
         });
-        throw new Error(`authority_change_requires_user_decision:${revisionIdentity}`);
+        throw new Error(`authority_change_requires_user_decision:${proposal.revision_identity}`);
     }
 }

package/dist/lib/long-task-authority-revision-summary.d.ts

@@ -0,0 +1,11 @@
+import type { AuthorityRevisionApprovalSummaryV2, AuthorityRevisionChangeClassV2, AuthorityRevisionDecisionV2, AuthorityRevisionDiffV2 } from "./long-task-authority-revision-types.js";
+export declare function classifyAuthorityRevision(diff: AuthorityRevisionDiffV2): AuthorityRevisionChangeClassV2;
+export declare function summarizeAuthorityRevision(diff: AuthorityRevisionDiffV2, outcomeKeys: string[]): AuthorityRevisionApprovalSummaryV2;
+export declare function projectAuthorityRevisionDecision(value: {
+    revision_identity: string;
+    revision_diff: AuthorityRevisionDiffV2;
+    affected_outcomes_or_contracts: string[];
+    change_class?: AuthorityRevisionChangeClassV2;
+    approval_required?: boolean;
+    approval_summary?: AuthorityRevisionApprovalSummaryV2;
+}): AuthorityRevisionDecisionV2;

package/dist/lib/long-task-authority-revision-summary.js

@@ -0,0 +1,99 @@
+const SCOPE_EXPANSION_REASONS = new Set([
+    "owner_path_expanded",
+    "expected_change_path_expanded",
+    "allowed_path_expanded",
+]);
+const PROOF_REDUCTION_REASONS = new Set([
+    "check_removed",
+    "negative_assertion_removed",
+    "proof_surface_changed",
+    "runner_definition_changed",
+    "verification_input_removed_or_replaced",
+    "input_path_coverage_reduced",
+    "expected_output_requirement_weakened",
+    "artifact_removed",
+    "environment_requirement_removed",
+    "binding_removed_or_expanded",
+    "obligation_removed_or_weakened",
+    "rollback_or_recovery_weakened",
+    "counterfactual_removed",
+    "population_weakened",
+    "verifier_content_changed",
+    "acceptance_not_monotonic",
+]);
+export function classifyAuthorityRevision(diff) {
+    if (!diff.reduction_reasons.length)
+        return "monotonic_evidence_strengthening";
+    if (diff.reduction_reasons.every((reason) => SCOPE_EXPANSION_REASONS.has(reason)))
+        return "scope_only_expansion";
+    return "protected_semantic_or_proof_change";
+}
+export function summarizeAuthorityRevision(diff, outcomeKeys) {
+    const affectedOutcomes = scopeAffectedOutcomes(diff);
+    const changeClass = classifyAuthorityRevision(diff);
+    return {
+        product_semantics_changed: diff.product_claims_added.length > 0 ||
+            diff.product_claims_removed.length > 0 ||
+            diff.product_claims_changed.length > 0 ||
+            diff.product_semantics_changed.length > 0,
+        global_or_technical_semantics_changed: diff.global_semantics_changed.length > 0 ||
+            diff.technical_obligations_changed,
+        source_or_claims_changed: diff.source_claims_changed ||
+            diff.source_claims_added.length > 0 ||
+            diff.source_claims_removed_or_changed.length > 0 ||
+            diff.source_paths_removed_or_replaced.length > 0 ||
+            diff.source_files_added.length > 0 ||
+            diff.source_files_removed.length > 0 ||
+            diff.source_files_changed.length > 0,
+        context_authority_changed: diff.context_snapshot_mode_changed ||
+            diff.context_topology_changed ||
+            diff.context_files_added.length > 0 ||
+            diff.context_files_removed.length > 0 ||
+            diff.context_files_changed.length > 0,
+        acceptance_or_proof_weakened: diff.reduction_reasons.some((reason) => PROOF_REDUCTION_REASONS.has(reason)),
+        verifier_or_runner_changed: diff.verifier_content_changed ||
+            diff.verifier_runtime_locator_changed ||
+            diff.runner_definitions_changed.length > 0,
+        write_scope_expanded: diff.owner_or_path_boundary_changed,
+        risk_changed: diff.risk_changed,
+        external_confirmations_changed: diff.external_confirmations_changed,
+        added_verification_dependencies: uniqueSorted([
+            ...diff.verification_inputs_added,
+            ...diff.input_paths_added,
+        ]),
+        expanded_owner_paths: uniqueSorted(diff.owner_paths_expanded),
+        expanded_expected_change_paths: uniqueSorted(diff.expected_change_paths_expanded),
+        expanded_allowed_support_paths: uniqueSorted(diff.allowed_paths_expanded),
+        protected_reasons: uniqueSorted(diff.reduction_reasons),
+        affected_outcomes: changeClass === "scope_only_expansion" && affectedOutcomes.length > 0
+            ? affectedOutcomes
+            : uniqueSorted(outcomeKeys),
+    };
+}
+export function projectAuthorityRevisionDecision(value) {
+    const diff = {
+        ...value.revision_diff,
+        verification_inputs_added: value.revision_diff.verification_inputs_added ?? [],
+        input_paths_added: value.revision_diff.input_paths_added ?? [],
+        external_confirmations_changed: value.revision_diff.external_confirmations_changed ?? false,
+    };
+    return {
+        revision_identity: value.revision_identity,
+        change_class: value.change_class ?? classifyAuthorityRevision(diff),
+        approval_required: value.approval_required ?? true,
+        approval_summary: value.approval_summary ??
+            summarizeAuthorityRevision(diff, value.affected_outcomes_or_contracts),
+    };
+}
+function scopeAffectedOutcomes(diff) {
+    return uniqueSorted([
+        ...diff.owner_paths_expanded,
+        ...diff.expected_change_paths_expanded,
+        ...diff.allowed_paths_expanded,
+    ]
+        .map((entry) => entry.split(":", 1)[0])
+        .filter((key) => key.length > 0 && key !== "GLOBAL"));
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}

package/dist/lib/long-task-authority-revision-types.d.ts

@@ -1,4 +1,44 @@
-import type { VerifierIdentityV2 } from "./long-task-authority-types.js";
+import type { AuthorityHashesV2, AuthorityMaterialHashesV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-authority-types.js";
+export type AuthorityRevisionChangeClassV2 = "monotonic_evidence_strengthening" | "scope_only_expansion" | "protected_semantic_or_proof_change";
+export interface AuthorityRevisionApprovalSummaryV2 {
+    product_semantics_changed: boolean;
+    global_or_technical_semantics_changed: boolean;
+    source_or_claims_changed: boolean;
+    context_authority_changed: boolean;
+    acceptance_or_proof_weakened: boolean;
+    verifier_or_runner_changed: boolean;
+    write_scope_expanded: boolean;
+    risk_changed: boolean;
+    external_confirmations_changed: boolean;
+    added_verification_dependencies: string[];
+    expanded_owner_paths: string[];
+    expanded_expected_change_paths: string[];
+    expanded_allowed_support_paths: string[];
+    protected_reasons: string[];
+    affected_outcomes: string[];
+}
+export interface AuthorityRevisionProposalV2 {
+    previous_hashes: AuthorityHashesV2;
+    next_hashes: AuthorityHashesV2;
+    previous_materials: NextAuthorityMaterialsV2;
+    next_materials: NextAuthorityMaterialsV2;
+    previous_material_hashes: AuthorityMaterialHashesV2;
+    next_material_hashes: AuthorityMaterialHashesV2;
+    changed_authority_sections: string[];
+    revision_diff: AuthorityRevisionDiffV2;
+    new_risk_floor: "standard" | "strict";
+    affected_outcomes_or_contracts: string[];
+    change_class: AuthorityRevisionChangeClassV2;
+    approval_required: boolean;
+    approval_summary: AuthorityRevisionApprovalSummaryV2;
+    revision_identity: string;
+}
+export interface AuthorityRevisionDecisionV2 {
+    revision_identity: string;
+    change_class: AuthorityRevisionChangeClassV2;
+    approval_required: boolean;
+    approval_summary: AuthorityRevisionApprovalSummaryV2;
+}
 export interface AuthorityRevisionDiffV2 {
     product_claims_added: string[];
     product_claims_removed: string[];
@@ -26,7 +66,9 @@ export interface AuthorityRevisionDiffV2 {
     allowed_paths_expanded: string[];
     forbidden_paths_removed: string[];
     runner_definitions_changed: string[];
+    verification_inputs_added: string[];
     verification_inputs_removed_or_replaced: string[];
+    input_paths_added: string[];
     input_paths_removed_or_narrowed: string[];
     expected_output_paths_removed_or_weakened: string[];
     artifacts_removed: string[];
@@ -36,6 +78,7 @@ export interface AuthorityRevisionDiffV2 {
     rollback_or_recovery_weakened: string[];
     counterfactuals_removed: string[];
     population_weakened: string[];
+    external_confirmations_changed: boolean;
     verifier_content_changed: boolean;
     verifier_runtime_locator_changed: boolean;
     verifier_files_changed: string[];

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

@@ -1,7 +1,7 @@
 import { acceptanceSemanticsChanged, isMonotonicAcceptanceStrengthening, } from "./long-task-authority.js";
 import { authorityMaterialRevisionDiff, changedProductClaimSemantics, sourceClaimAdditions, } from "./long-task-authority-material-diff.js";
 import { compileProductClaimCoverage } from "./long-task-claims.js";
-import { addedValues, bindingReductions, changedRunnerFields, checkIndex, counterfactualReductions, expandedPatterns, globalCounterfactualReductions, obligationReductions, removedExactValues, removedGlobalForbiddenPaths, removedOrNarrowedInputPaths, removedOrReplacedVerificationInputs, removedOrWeakenedExpectedOutputPaths, removedStructuredValues, removedValues, rollbackReductions, same, sourceClaimReductions, } from "./long-task-authority-revision-details.js";
+import { addedInputPaths, addedVerificationInputs, addedValues, bindingReductions, changedRunnerFields, checkIndex, counterfactualReductions, expandedPatterns, globalCounterfactualReductions, obligationReductions, removedExactValues, removedGlobalForbiddenPaths, removedOrNarrowedInputPaths, removedOrReplacedVerificationInputs, removedOrWeakenedExpectedOutputPaths, removedStructuredValues, removedValues, rollbackReductions, same, sourceClaimReductions, } from "./long-task-authority-revision-details.js";
 import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
 export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier) {
     const materialDiff = authorityMaterialRevisionDiff(previous, nextMaterials);
@@ -19,7 +19,9 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
     const negativeAssertionsRemoved = [];
     const proofSurfacesChanged = [];
     const runnerDefinitionsChanged = [];
+    const verificationInputsAdded = [];
     const verificationInputsRemovedOrReplaced = [];
+    const inputPathsAdded = [];
     const inputPathsRemovedOrNarrowed = [];
     const expectedOutputPathsRemovedOrWeakened = [];
     const artifactsRemoved = [];
@@ -34,7 +36,9 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
         if (before.proof_surface !== after.proof_surface)
             proofSurfacesChanged.push(`${identity}:${before.proof_surface}->${after.proof_surface}`);
         runnerDefinitionsChanged.push(...changedRunnerFields(identity, before, after));
+        verificationInputsAdded.push(...addedVerificationInputs(identity, before, after));
         verificationInputsRemovedOrReplaced.push(...removedOrReplacedVerificationInputs(identity, before, after));
+        inputPathsAdded.push(...addedInputPaths(identity, before, after));
         inputPathsRemovedOrNarrowed.push(...removedOrNarrowedInputPaths(identity, before, after));
         expectedOutputPathsRemovedOrWeakened.push(...removedOrWeakenedExpectedOutputPaths(identity, before, after));
         artifactsRemoved.push(...removedExactValues(identity, before.artifact_globs, after.artifact_globs));
@@ -76,6 +80,7 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
     const riskChanged = previous.authority_hashes.risk_authority_hash !==
         nextHashes.risk_authority_hash;
     const acceptanceChanged = acceptanceSemanticsChanged(previous, next);
+    const externalConfirmationsChanged = !same(previous.global.acceptance.external_confirmations, next.global.acceptance.external_confirmations);
     const monotonic = isMonotonicAcceptanceStrengthening(previous, next);
     const reductionReasons = [
         ...(productClaimsAdded.length ? ["product_claim_added"] : []),
@@ -157,7 +162,9 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
         allowed_paths_expanded: allowedPathsExpanded,
         forbidden_paths_removed: forbiddenPathsRemoved,
         runner_definitions_changed: runnerDefinitionsChanged,
+        verification_inputs_added: verificationInputsAdded,
         verification_inputs_removed_or_replaced: verificationInputsRemovedOrReplaced,
+        input_paths_added: inputPathsAdded,
         input_paths_removed_or_narrowed: inputPathsRemovedOrNarrowed,
         expected_output_paths_removed_or_weakened: expectedOutputPathsRemovedOrWeakened,
         artifacts_removed: artifactsRemoved,
@@ -167,6 +174,7 @@ export function authorityRevisionDiff(previous, next, nextHashes, nextMaterials,
         rollback_or_recovery_weakened: rollbackOrRecoveryWeakened,
         counterfactuals_removed: counterfactualsRemoved,
         population_weakened: populationWeakened,
+        external_confirmations_changed: externalConfirmationsChanged,
         ...verifierDiff,
         source_claims_changed: previous.authority_hashes.source_authority_hash !==
             nextHashes.source_authority_hash,

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

@@ -1,4 +1,5 @@
 import type { CompiledDeliveryContractV2, InitialTaskBaseV2 } from "./long-task-delivery-types.js";
+import type { AuthorityRevisionProposalV2 } from "./long-task-authority-revision-types.js";
 export interface CompileDeliveryOptionsV2 {
     require_completion_gate?: boolean;
     revise?: boolean;
@@ -6,5 +7,7 @@ export interface CompileDeliveryOptionsV2 {
     initial_task_base?: InitialTaskBaseV2;
     authority_revision?: number;
     previous_authority?: CompiledDeliveryContractV2 | null;
+    authority_revision_mode?: "enforce" | "diagnose";
+    on_authority_revision?: (proposal: AuthorityRevisionProposalV2) => void;
 }
 export declare function compileDeliveryContract(workdirInput: string, projectRootInput?: string, options?: CompileDeliveryOptionsV2): Promise<CompiledDeliveryContractV2>;

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

@@ -5,7 +5,7 @@ import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 import { changedAuthoritySections, computeAuthorityHashes, } from "./long-task-authority.js";
 import { authorityMaterialsChanged, compiledAuthorityMaterials, computeAuthorityMaterials, } from "./long-task-authority-materials.js";
 import { normalizeContextAuthoritySnapshot } from "./long-task-context-authority.js";
-import { assertRiskNotDowngraded, enforceAuthorityRevision, } from "./long-task-authority-revision-enforcement.js";
+import { assertRiskNotDowngraded, buildAuthorityRevisionProposal, enforceAuthorityRevision, } from "./long-task-authority-revision-enforcement.js";
 import { validateActualRiskSurfaces } from "./long-task-risk-surfaces.js";
 import { captureVerifierIdentity } from "./long-task-verifier-identity.js";
 import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
@@ -83,7 +83,10 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
         if (options.revise && authorityChanged) {
             assertRiskNotDowngraded(previous, risk.effective_level, risk.reasons);
             authorityRevision = previous.authority_revision + 1;
-            await enforceAuthorityRevision(previous, contract, authorityHashes, authorityMaterials, globalChecks, outcomes, verifier, workdir, risk.minimum_level);
+            const proposal = buildAuthorityRevisionProposal(previous, contract, authorityHashes, authorityMaterials, globalChecks, outcomes, verifier, risk.minimum_level);
+            options.on_authority_revision?.(proposal);
+            if (options.authority_revision_mode !== "diagnose")
+                await enforceAuthorityRevision(proposal, workdir);
         }
     }
     const unsigned = {

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

@@ -1,4 +1,5 @@
-import type { AuthorityMaterialHashesV2, AuthorityHashesV2, CompiledDeliveryContractV2, FinalReceiptV2, InitialTaskBaseV2, NextAuthorityMaterialsV2, ProgressRecordV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
+import type { CompiledDeliveryContractV2, FinalReceiptV2, 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;
@@ -34,21 +35,8 @@ export interface StagedCompiledDeliveryContractV2 {
     publish(): Promise<void>;
     discard(): Promise<void>;
 }
-export interface PendingAuthorityRevisionV2 {
+export interface PendingAuthorityRevisionV2 extends AuthorityRevisionProposalV2 {
     schema_version: "long-task-authority-revision-pending-v2";
-    previous_hashes: AuthorityHashesV2;
-    next_hashes: AuthorityHashesV2;
-    previous_materials: NextAuthorityMaterialsV2;
-    next_materials: NextAuthorityMaterialsV2;
-    previous_material_hashes: AuthorityMaterialHashesV2;
-    next_material_hashes: AuthorityMaterialHashesV2;
-    changed_authority_sections: string[];
-    revision_diff: Record<string, unknown> & {
-        reduction_reasons: string[];
-    };
-    new_risk_floor: "standard" | "strict";
-    affected_outcomes_or_contracts: string[];
-    revision_identity: string;
     created_at: string;
 }
 export declare function runtimePath(workdir: string, file?: string): string;

package/dist/lib/long-task-status-v2.d.ts

@@ -1,3 +1,4 @@
+import type { AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
 import type { ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2 } from "./long-task-delivery-types.js";
 import { type AuditGateStatusV2 } from "./long-task-status-projection.js";
 export interface DeliveryStatusV2 {
@@ -17,6 +18,7 @@ export interface DeliveryStatusV2 {
     progress_passing: string[];
     progress_failing: string[];
     findings: LongTaskFindingV2[];
+    pending_authority_revision: AuthorityRevisionDecisionV2 | null;
 }
 export declare function readDeliveryStatus(workdir: string): Promise<DeliveryStatusV2>;
 export declare function resumeDeliveryTask(workdir: string): Promise<Record<string, unknown>>;

package/dist/lib/long-task-status-v2.js

@@ -1,8 +1,9 @@
 import path from "node:path";
 import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
+import { projectAuthorityRevisionDecision } from "./long-task-authority-revision-summary.js";
 import { runDeliveryFinalGate } from "./long-task-final-v2.js";
 import { deliveryCompileFreshness } from "./long-task-freshness.js";
-import { activeAuthorityLockExists, clearActiveBindingCas, inspectCompiledCache, loadActiveLongTaskAuthority, readActiveLongTaskBinding, readFinalReceipt, readProgressRecords, } from "./long-task-state.js";
+import { activeAuthorityLockExists, clearActiveBindingCas, inspectCompiledCache, loadActiveLongTaskAuthority, readActiveLongTaskBinding, readFinalReceipt, readPendingAuthorityRevision, readProgressRecords, } from "./long-task-state.js";
 import { projectDeliveryStatus, } from "./long-task-status-projection.js";
 import { captureWorkspaceManifest, currentGitState, repositoryRoot, } from "./long-task-workspace.js";
 export async function readDeliveryStatus(workdir) {
@@ -20,7 +21,10 @@ async function readDeliveryStatusForAuthority(active) {
     const cacheStatus = await inspectCompiledCache(active);
     const current = await captureWorkspaceManifest(compiled.repository_root, compiled.workdir);
     const stale = await deliveryCompileFreshness(compiled);
-    const progress = await readProgressRecords(active.workdir);
+    const [progress, pending] = await Promise.all([
+        readProgressRecords(active.workdir),
+        readPendingAuthorityRevision(active.workdir),
+    ]);
     let receipt = null;
     let receiptError = null;
     try {
@@ -53,6 +57,9 @@ async function readDeliveryStatusForAuthority(active) {
         needs_reverify: projection.needsReverify,
         progress_passing: projection.progressPassing,
         progress_failing: projection.progressFailing,
+        pending_authority_revision: pending
+            ? projectAuthorityRevisionDecision(pending)
+            : null,
         findings: [
             ...projection.findings,
             ...(cacheStatus === "compiled_cache_matching"
@@ -96,6 +103,7 @@ export async function resumeDeliveryTask(workdir) {
         needs_reverify: status.needs_reverify,
         progress_passing: status.progress_passing,
         progress_failing: status.progress_failing,
+        pending_authority_revision: status.pending_authority_revision,
         recent_findings: status.findings,
         next_safe_action: nextAction(status),
     };
@@ -273,6 +281,8 @@ function externalPendingMessage(confirmations) {
     return `Machine-verifiable scope accepted. Complete external delivery remains pending: ${pending}. Do not report complete external delivery.`;
 }
 function nextAction(status) {
+    if (status.pending_authority_revision)
+        return `Ask the user to approve or reject Authority Revision ${status.pending_authority_revision.revision_identity}; keep the previous Authority active until then.`;
     if (status.findings.length)
         return status.findings.at(-1).next_action;
     if (status.ready_outcomes.length)

package/dist/lib/long-task-verifier-v2.d.ts

@@ -11,3 +11,7 @@ export declare function verifyDeliveryContract(workdir: string, selection?: {
 }): Promise<TargetedVerificationResultV2>;
 export declare function runDeliveryChecks(compiled: CompiledDeliveryContractV2, snapshot: WorkspaceSnapshotV2, checks: CompiledCheckV2[], includeCounterfactuals: boolean, finalGate?: boolean): Promise<DeliveryRunV2>;
 export declare function allCompiledChecks(compiled: CompiledDeliveryContractV2): CompiledCheckV2[];
+export declare function selectChecks(compiled: CompiledDeliveryContractV2, selection: {
+    outcome?: string;
+    check?: string;
+}): CompiledCheckV2[];

package/dist/lib/long-task-verifier-v2.js

@@ -214,7 +214,7 @@ export function allCompiledChecks(compiled) {
         ...compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
     ];
 }
-function selectChecks(compiled, selection) {
+export function selectChecks(compiled, selection) {
     const checks = allCompiledChecks(compiled);
     if (selection.outcome &&
         !compiled.outcomes.some((outcome) => outcome.key === selection.outcome))

package/migrations/README.md

@@ -1,8 +1,8 @@
-# Migrations
-
-Schema migrations for Harness config and managed file layout belong here.
-
-Version 0.6.0 includes `long-task-v1-retirement`. It safely removes the
-retired repo-local Hook, reports a legacy active projection as
-`manual_required`, and deliberately does not import V1 progress or receipts
-into the V2 Claim/Evidence authority.
+# Migrations
+
+Schema migrations for Harness config and managed file layout belong here.
+
+Version 0.6.0 includes `long-task-v1-retirement`. It safely removes the
+retired repo-local Hook, reports a legacy active projection as
+`manual_required`, and deliberately does not import V1 progress or receipts
+into the V2 Claim/Evidence authority.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-tiny-context-harness",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "description": "Minimal project memory and validation harness for AI coding agents.",
   "license": "MIT",
   "author": "Seven128",
@@ -53,6 +53,8 @@
     "test:default:built": "node ../../tests/ty-context/run-package-suite.mjs default",
     "test:default": "npm run build && npm run test:default:built",
     "test:built": "npm run test:default:built && npm run test:long-task-workflow:built",
+    "test:trust:built": "npm run test:default:built && npm run test:long-task-trust:built",
+    "test:trust": "npm run build && npm run test:trust:built",
     "pretest": "npm run build",
     "test": "npm run test:built",
     "test:workflow-default:built": "node --test --test-concurrency=1 ../../tests/ty-context/workflow-contract-routing.test.mjs",
@@ -60,6 +62,8 @@
     "test:delivery-contract": "npm run build && npm run test:delivery-contract:built",
     "test:long-task-workflow:built": "node ../../tests/ty-context/run-package-suite.mjs long-task",
     "test:long-task-workflow": "npm run build && npm run test:long-task-workflow:built",
+    "test:long-task-trust:built": "node ../../tests/ty-context/run-package-suite.mjs long-task-trust",
+    "test:long-task-trust": "npm run build && npm run test:long-task-trust:built",
     "test:long-task-performance": "npm run build && node ../../tests/ty-context/long-task-performance.mjs",
     "prepack": "npm run build"
   },