project-tiny-context-harness 0.11.0 → 0.12.1

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

@@ -1,121 +0,0 @@
-import { addedInputPaths, addedVerificationInputs, bindingReductions, changedRunnerFields, counterfactualReductions, expandedPatterns, globalCounterfactualReductions, obligationReductions, removedExactValues, removedGlobalForbiddenPaths, removedOrNarrowedInputPaths, removedOrReplacedVerificationInputs, removedOrWeakenedExpectedOutputPaths, removedStructuredValues, rollbackReductions, same, } from "./long-task-authority-revision-details.js";
-export function analyzeCheckRevisions(beforeChecks, afterChecks) {
-    const result = {
-        negative_assertions_removed: [],
-        acceptance_semantics_reduced: [],
-        proof_surfaces_changed: [],
-        runner_definitions_changed: [],
-        verification_inputs_added: [],
-        verification_inputs_removed_or_replaced: [],
-        input_paths_added: [],
-        input_paths_removed_or_narrowed: [],
-        expected_output_paths_removed_or_weakened: [],
-        artifacts_removed: [],
-        environment_requirements_removed: [],
-    };
-    for (const [identity, before] of beforeChecks) {
-        const after = afterChecks.get(identity);
-        if (!after)
-            continue;
-        for (const assertion of before.negative_assertions)
-            if (!after.negative_assertions.some((item) => same(item, assertion)))
-                result.negative_assertions_removed.push(`${identity}:${assertion.key}`);
-        if (!same(before.execution_target, after.execution_target))
-            result.acceptance_semantics_reduced.push(`${identity}:execution_target`);
-        collectRemovedValues(result.acceptance_semantics_reduced, `${identity}:journey_role`, before.journey_roles, after.journey_roles);
-        collectRemovedValues(result.acceptance_semantics_reduced, `${identity}:scenario.given`, before.scenario.given, after.scenario.given);
-        collectRemovedValues(result.acceptance_semantics_reduced, `${identity}:scenario.when`, before.scenario.when, after.scenario.when);
-        collectAssertionReductions(result.acceptance_semantics_reduced, identity, before.positive_assertions, after.positive_assertions);
-        if (before.proof_surface !== after.proof_surface)
-            result.proof_surfaces_changed.push(`${identity}:${before.proof_surface}->${after.proof_surface}`);
-        result.runner_definitions_changed.push(...changedRunnerFields(identity, before, after));
-        result.verification_inputs_added.push(...addedVerificationInputs(identity, before, after));
-        result.verification_inputs_removed_or_replaced.push(...removedOrReplacedVerificationInputs(identity, before, after));
-        result.input_paths_added.push(...addedInputPaths(identity, before, after));
-        result.input_paths_removed_or_narrowed.push(...removedOrNarrowedInputPaths(identity, before, after));
-        result.expected_output_paths_removed_or_weakened.push(...removedOrWeakenedExpectedOutputPaths(identity, before, after));
-        result.artifacts_removed.push(...removedExactValues(identity, before.artifact_globs, after.artifact_globs));
-        result.environment_requirements_removed.push(...removedStructuredValues(identity, before.environment_requirements, after.environment_requirements));
-    }
-    return result;
-}
-function collectRemovedValues(result, prefix, before, after) {
-    for (const value of before)
-        if (!after.some((candidate) => same(candidate, value)))
-            result.push(`${prefix}:${String(value)}`);
-}
-function collectAssertionReductions(result, identity, before, after) {
-    const next = new Map(after.map((assertion) => [assertion.key, assertion]));
-    for (const assertion of before) {
-        const candidate = next.get(assertion.key);
-        if (!candidate) {
-            result.push(`${identity}:positive_assertion.${assertion.key}:removed`);
-            continue;
-        }
-        const semanticChanged = assertion.criterion !== candidate.criterion ||
-            !same(assertion.claims, candidate.claims) ||
-            assertion.observation !== candidate.observation ||
-            assertion.operator !== candidate.operator ||
-            !same(assertion.expected, candidate.expected);
-        const capabilityRemoved = assertion.evidence_capabilities.some((capability) => !candidate.evidence_capabilities.includes(capability));
-        if (semanticChanged || capabilityRemoved)
-            result.push(`${identity}:positive_assertion.${assertion.key}:changed`);
-    }
-}
-export function analyzeOutcomeRevisions(previous, next) {
-    const result = {
-        owner_paths_expanded: [],
-        owner_context_refs_removed: [],
-        expected_change_paths_expanded: [],
-        allowed_paths_expanded: [],
-        forbidden_paths_removed: removedGlobalForbiddenPaths(previous, next),
-        bindings_removed_or_expanded: [],
-        obligations_removed_or_weakened: [],
-        rollback_or_recovery_weakened: [],
-        counterfactuals_removed: globalCounterfactualReductions(previous, next),
-        population_weakened: [],
-    };
-    const previousOutcomes = new Map(previous.outcomes.map((outcome) => [outcome.key, outcome]));
-    for (const after of next.outcomes) {
-        const before = previousOutcomes.get(after.key);
-        if (!before)
-            continue;
-        result.owner_paths_expanded.push(...expandedPatterns(after.key, before.product.owner.path_globs, after.product.owner.path_globs));
-        result.owner_context_refs_removed.push(...removedExactValues(after.key, before.product.owner.context_refs, after.product.owner.context_refs));
-        result.expected_change_paths_expanded.push(...expandedPatterns(after.key, before.technical.expected_change_paths, after.technical.expected_change_paths));
-        result.allowed_paths_expanded.push(...expandedPatterns(after.key, before.technical.allowed_support_paths, after.technical.allowed_support_paths));
-        result.forbidden_paths_removed.push(...removedExactValues(after.key, before.technical.forbidden_paths, after.technical.forbidden_paths));
-        result.bindings_removed_or_expanded.push(...bindingReductions(before, after));
-        result.obligations_removed_or_weakened.push(...obligationReductions(before, after));
-        result.rollback_or_recovery_weakened.push(...rollbackReductions(before, after));
-        result.counterfactuals_removed.push(...counterfactualReductions(before, after));
-        if (before.acceptance.population &&
-            (!after.acceptance.population ||
-                !same(before.acceptance.population, after.acceptance.population)))
-            result.population_weakened.push(after.key);
-    }
-    return result;
-}
-export function keyedAuthorityChanges(before, after) {
-    const beforeByKey = new Map(before.map((item) => [item.key, item]));
-    const afterByKey = new Map(after.map((item) => [item.key, item]));
-    return [
-        ...before
-            .filter((item) => !afterByKey.has(item.key))
-            .map((item) => `${item.key}:removed`),
-        ...after
-            .filter((item) => !beforeByKey.has(item.key))
-            .map((item) => `${item.key}:added`),
-        ...before
-            .filter((item) => {
-            const candidate = afterByKey.get(item.key);
-            return candidate !== undefined && !same(item, candidate);
-        })
-            .map((item) => `${item.key}:changed`),
-    ].sort();
-}
-export function selectedRevisionReasons(entries) {
-    return entries
-        .filter(([, changed]) => Array.isArray(changed) ? changed.length > 0 : changed)
-        .map(([reason]) => reason);
-}

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

@@ -1,3 +0,0 @@
-import type { AuthorityRevisionApprovalSummaryV2, AuthorityRevisionChangeClassV2, AuthorityRevisionDecisionBriefV2, AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
-export declare function authorityRevisionDecisionNextAction(decision: AuthorityRevisionDecisionV2): string;
-export declare function buildAuthorityRevisionDecisionBrief(summary: AuthorityRevisionApprovalSummaryV2, changeClass: AuthorityRevisionChangeClassV2, approvalRequired: boolean): AuthorityRevisionDecisionBriefV2;

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

@@ -1,76 +0,0 @@
-export function authorityRevisionDecisionNextAction(decision) {
-    const brief = decision.decision_brief;
-    const outcomes = brief.affected_outcomes.length
-        ? brief.affected_outcomes.join(", ")
-        : "contract-wide or global authority";
-    if (!decision.user_decision_required)
-        return `Authority Revision brief: ${brief.overview} ${brief.headline} ${brief.approval_reason} Material changes: ${brief.material_changes.join(" ")} Affected Outcomes: ${outcomes}. ${brief.if_approved.join(" ")}`;
-    return `Authority Revision brief: ${brief.overview} ${brief.headline} ${brief.approval_reason} Material changes: ${brief.material_changes.join(" ")} Affected Outcomes: ${outcomes}. ${brief.if_approved.join(" ")} Present this brief first. If an explicit task-specific user instruction already covers every listed decision reason, mechanically relay that existing decision for exact Authority Revision ${decision.revision_identity} without asking again. A generic continue, blanket approval, recommendation or Agent inference does not count. Otherwise ask the user once to approve or reject this exact identity; keep the previous Authority active until approved and atomically adopted.`;
-}
-export function buildAuthorityRevisionDecisionBrief(summary, changeClass, approvalRequired) {
-    const categories = [];
-    const materialChanges = [];
-    addCategory(summary.product_semantics_changed, "product meaning", detail("Product Claims or semantics changed", summary.product_claim_changes));
-    addCategory(summary.global_or_technical_semantics_changed, "technical meaning", detail("Global or technical semantics changed", summary.semantic_fields_changed));
-    addCategory(summary.source_or_claims_changed, "Source/Claims", detail("Source or Claim authority changed", summary.source_claim_changes));
-    addCategory(summary.context_authority_changed, "Context authority", "Controlling Context authority changed.");
-    addCategory(summary.acceptance_or_proof_weakened, "acceptance/proof", detail("Acceptance or proof was reduced", summary.proof_reductions));
-    addCategory(summary.verifier_or_runner_changed, "verifier/runner", summary.verifier_content_changed
-        ? detail("Verifier content changed; prior evidence is invalid and semantic preservation is not independently established", summary.verifier_files_changed)
-        : "Verifier or runner authority changed.");
-    addCategory(summary.write_scope_expanded, "write scope", detail("Owner or allowed write scope expanded", uniqueSorted([
-        ...summary.expanded_owner_paths,
-        ...summary.expanded_expected_change_paths,
-        ...summary.expanded_allowed_support_paths,
-    ])));
-    addCategory(summary.risk_changed, "risk", "The effective risk authority changed.");
-    addCategory(summary.external_confirmations_changed, "external confirmations", detail("External-confirmation authority changed", summary.external_confirmation_changes));
-    if (summary.added_verification_dependencies.length)
-        materialChanges.push(detail("Verification dependencies were added", summary.added_verification_dependencies));
-    if (!materialChanges.length)
-        materialChanges.push(detail("Protected authority fields changed", summary.protected_reasons));
-    return {
-        overview: "An Authority Revision is a proposed replacement of the locked delivery contract or its protected inputs. It changes what future execution and proof are bound to, but adoption never completes delivery.",
-        headline: approvalRequired
-            ? `User decision required: ${categories.length ? categories.join(", ") : changeClass} changed.`
-            : "No user decision is required for this mechanically bounded Authority Revision.",
-        approval_reason: approvalRequired
-            ? changeClass === "scope_only_expansion"
-                ? "The candidate expands declared implementation ownership or write scope and cannot replace the active Authority without exact user approval."
-                : "The candidate changes protected delivery meaning, proof, risk, or execution authority and cannot replace the active Authority without exact user approval."
-            : changeClass === "scope_only_expansion"
-                ? "The candidate only expands repository-bound implementation scope; it changes no locked product Claim, target, acceptance capability, forbidden boundary or external confirmation."
-                : changeClass === "mechanically_bounded_repair"
-                    ? "The locked user-facing meaning and proof obligations are preserved; changed execution, Source/Context snapshot or equivalent failure interception must still be re-proven on the new snapshot."
-                    : "The change is a machine-proven monotonic strengthening.",
-        material_changes: materialChanges,
-        affected_outcomes: [...summary.affected_outcomes],
-        if_approved: approvalRequired
-            ? [
-                "The previous Authority remains active until exact approval and atomic adoption.",
-                "Approval and adoption do not complete delivery; execution returns to rolling implementation or repair.",
-                "A complete source-recompiled current-snapshot Final Gate remains mandatory.",
-            ]
-            : [
-                "The mechanically safe revision may be atomically adopted without user approval.",
-                "Adoption does not complete delivery; execution returns to rolling implementation or repair.",
-                "A complete source-recompiled current-snapshot Final Gate remains mandatory.",
-            ],
-    };
-    function addCategory(applies, category, materialChange) {
-        if (!applies)
-            return;
-        categories.push(category);
-        materialChanges.push(materialChange);
-    }
-}
-function detail(label, values) {
-    if (!values.length)
-        return `${label}.`;
-    const shown = values.slice(0, 3);
-    const remaining = values.length - shown.length;
-    return `${label}: ${shown.join(", ")}${remaining ? ` (+${remaining} more)` : ""}.`;
-}
-function uniqueSorted(values) {
-    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
-}

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

@@ -1,21 +0,0 @@
-import type { CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, DeliveryContractV2, DeliveryOutcomeV2, SourceClaimV2 } from "./long-task-delivery-types.js";
-export declare function checkIndex(globalChecks: CompiledCheckV2[], outcomes: CompiledOutcomeV2[]): Map<string, CompiledCheckV2>;
-export declare function changedRunnerFields(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function removedOrReplacedVerificationInputs(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function addedVerificationInputs(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function addedInputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function removedOrNarrowedInputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function removedOrWeakenedExpectedOutputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
-export declare function sourceClaimReductions(beforeClaims: SourceClaimV2[], afterClaims: SourceClaimV2[]): string[];
-export declare function removedGlobalForbiddenPaths(previous: CompiledDeliveryContractV2, next: DeliveryContractV2): string[];
-export declare function bindingReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
-export declare function obligationReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
-export declare function rollbackReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
-export declare function counterfactualReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
-export declare function globalCounterfactualReductions(before: CompiledDeliveryContractV2, after: DeliveryContractV2): string[];
-export declare function expandedPatterns(label: string, before: string[], after: string[]): string[];
-export declare function removedExactValues(label: string, before: string[], after: string[]): string[];
-export declare function removedStructuredValues(label: string, before: unknown[], after: unknown[]): string[];
-export declare function removedValues(before: Set<string>, after: Set<string>): string[];
-export declare function addedValues(before: Set<string>, after: Set<string>): string[];
-export declare function same(left: unknown, right: unknown): boolean;

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

@@ -1,205 +0,0 @@
-import { proveRepositoryPatternSubset } from "./long-task-paths.js";
-import { canonicalValueJson } from "./strict-codec.js";
-export function checkIndex(globalChecks, outcomes) {
-    return new Map([
-        ...globalChecks.map((check) => [`GLOBAL.${check.key}`, check]),
-        ...outcomes.flatMap((outcome) => outcome.acceptance.checks.map((check) => [`${outcome.key}.${check.key}`, check])),
-    ]);
-}
-export function changedRunnerFields(identity, before, after) {
-    const beforeRunner = declaredRunner(before);
-    const afterRunner = declaredRunner(after);
-    const changed = Object.keys(beforeRunner)
-        .filter((field) => !same(beforeRunner[field], afterRunner[field]))
-        .map((field) => `${identity}:${field}`);
-    if (before.runner.resolved_target !== after.runner.resolved_target)
-        changed.push(`${identity}:resolved_target`);
-    if (before.runner.resolved_cwd !== after.runner.resolved_cwd)
-        changed.push(`${identity}:resolved_cwd`);
-    if (before.runner.package_script !== after.runner.package_script)
-        changed.push(`${identity}:package_script`);
-    return changed;
-}
-export function removedOrReplacedVerificationInputs(identity, before, after) {
-    return Object.entries(before.verification_input_hashes)
-        .filter(([file, hash]) => after.verification_input_hashes[file] !== hash)
-        .map(([file]) => `${identity}:${file}`);
-}
-export function addedVerificationInputs(identity, before, after) {
-    return Object.keys(after.verification_input_hashes)
-        .filter((file) => before.verification_input_hashes[file] === undefined)
-        .map((file) => `${identity}:${file}`);
-}
-export function addedInputPaths(identity, before, after) {
-    return after.input_paths
-        .filter((pattern) => !before.input_paths.includes(pattern))
-        .map((pattern) => `${identity}:${pattern}`);
-}
-export function removedOrNarrowedInputPaths(identity, before, after) {
-    return before.input_paths
-        .filter((oldPattern) => !after.input_paths.some((newPattern) => proveRepositoryPatternSubset(oldPattern, newPattern).status ===
-        "proven_subset"))
-        .map((pattern) => `${identity}:${pattern}`);
-}
-export function removedOrWeakenedExpectedOutputPaths(identity, before, after) {
-    return before.expected_output_paths
-        .filter((oldPattern) => !after.expected_output_paths.some((newPattern) => proveRepositoryPatternSubset(newPattern, oldPattern).status ===
-        "proven_subset"))
-        .map((pattern) => `${identity}:${pattern}`);
-}
-export function sourceClaimReductions(beforeClaims, afterClaims) {
-    const after = new Map(afterClaims.map((claim) => [claim.key, claim]));
-    const changed = [];
-    for (const claim of beforeClaims) {
-        const candidate = after.get(claim.key);
-        if (!candidate) {
-            changed.push(`${claim.key}:removed`);
-            continue;
-        }
-        if (claim.statement !== candidate.statement ||
-            claim.source_ref !== candidate.source_ref ||
-            claim.disposition.type !== candidate.disposition.type ||
-            !same(claim.judgment_basis, candidate.judgment_basis)) {
-            changed.push(`${claim.key}:authority_changed`);
-            continue;
-        }
-        if ((claim.disposition.type === "claim" ||
-            claim.disposition.type === "global_constraint" ||
-            claim.disposition.type === "risk_fact") &&
-            (candidate.disposition.type === "claim" ||
-                candidate.disposition.type === "global_constraint" ||
-                candidate.disposition.type === "risk_fact")) {
-            const nextRefs = new Set(candidate.disposition.refs);
-            if (claim.disposition.refs.some((reference) => !nextRefs.has(reference)))
-                changed.push(`${claim.key}:disposition_refs_removed_or_replaced`);
-        }
-        else if (!same(claim.disposition, candidate.disposition))
-            changed.push(`${claim.key}:disposition_changed`);
-    }
-    return changed;
-}
-export function removedGlobalForbiddenPaths(previous, next) {
-    const after = new Map(next.global.technical.forbidden_paths.map((item) => [item.key, item.path]));
-    return previous.global.technical.forbidden_paths
-        .filter((item) => after.get(item.key) !== item.path)
-        .map((item) => `GLOBAL:${item.key}:${item.path}`);
-}
-export function bindingReductions(before, after) {
-    const nextBindings = new Map(after.technical.bindings.map((binding) => [binding.key, binding]));
-    const reductions = [];
-    for (const binding of before.technical.bindings) {
-        const candidate = nextBindings.get(binding.key);
-        if (!candidate) {
-            reductions.push(`${after.key}:${binding.key}:removed`);
-            continue;
-        }
-        if (binding.kind !== candidate.kind ||
-            binding.target !== candidate.target ||
-            binding.existence !== candidate.existence ||
-            binding.verification_check_key !== candidate.verification_check_key)
-            reductions.push(`${after.key}:${binding.key}:target_or_kind_changed`);
-        reductions.push(...expandedPatterns(`${after.key}:${binding.key}`, binding.carrier_paths, candidate.carrier_paths));
-    }
-    return reductions;
-}
-export function obligationReductions(before, after) {
-    const nextObligations = new Map(after.technical.obligations.map((obligation) => [
-        obligation.key,
-        obligation,
-    ]));
-    const reductions = [];
-    for (const obligation of before.technical.obligations) {
-        const candidate = nextObligations.get(obligation.key);
-        if (!candidate) {
-            reductions.push(`${after.key}:${obligation.key}:removed`);
-            continue;
-        }
-        if (obligation.statement !== candidate.statement)
-            reductions.push(`${after.key}:${obligation.key}:statement_changed`);
-        const nextSurfaces = new Set(candidate.required_proof_surfaces);
-        if (obligation.required_proof_surfaces.some((surface) => !nextSurfaces.has(surface)))
-            reductions.push(`${after.key}:${obligation.key}:proof_surface_removed`);
-    }
-    return reductions;
-}
-export function rollbackReductions(before, after) {
-    const previous = before.technical.rollback_and_recovery;
-    const next = after.technical.rollback_and_recovery;
-    if (!previous)
-        return [];
-    if (!next)
-        return [`${after.key}:removed`];
-    if (previous.rollback !== next.rollback ||
-        previous.recovery !== next.recovery)
-        return [`${after.key}:statement_changed`];
-    const nextChecks = new Set(next.verification_check_keys);
-    return previous.verification_check_keys.some((key) => !nextChecks.has(key))
-        ? [`${after.key}:verification_check_removed`]
-        : [];
-}
-export function counterfactualReductions(before, after) {
-    const next = after.acceptance.counterfactual_controls;
-    return before.acceptance.counterfactual_controls
-        .filter((control) => !counterfactualCoveragePreserved(control, next))
-        .map((control) => `${after.key}:${control.key}`);
-}
-export function globalCounterfactualReductions(before, after) {
-    const next = after.global.acceptance.counterfactual_controls;
-    return (before.global.acceptance.counterfactual_controls ?? [])
-        .filter((control) => !counterfactualCoveragePreserved(control, next))
-        .map((control) => `GLOBAL:${control.key}`);
-}
-function counterfactualCoveragePreserved(previous, next) {
-    return next.some((candidate) => same(candidate.binding_key, previous.binding_key) &&
-        same(candidate.binding_ref, previous.binding_ref) &&
-        candidate.check_key === previous.check_key &&
-        same(candidate.mutation, previous.mutation) &&
-        includesEvery(candidate.claims, previous.claims) &&
-        includesEvery(candidate.expected_assertion_failures, previous.expected_assertion_failures) &&
-        includesEvery(candidate.preserved_assertions ?? [], previous.preserved_assertions ?? []) &&
-        includesEvery(previous.allowed_fanout_assertions ?? [], candidate.allowed_fanout_assertions ?? []));
-}
-function includesEvery(values, required) {
-    const available = new Set(values);
-    return required.every((value) => available.has(value));
-}
-export function expandedPatterns(label, before, after) {
-    return after
-        .filter((candidate) => !before.some((existing) => proveRepositoryPatternSubset(candidate, existing).status ===
-        "proven_subset"))
-        .map((candidate) => `${label}:${candidate}`);
-}
-export function removedExactValues(label, before, after) {
-    const available = new Set(after);
-    return before
-        .filter((value) => !available.has(value))
-        .map((value) => `${label}:${value}`);
-}
-export function removedStructuredValues(label, before, after) {
-    const available = new Set(after.map(canonicalValueJson));
-    return before
-        .filter((value) => !available.has(canonicalValueJson(value)))
-        .map((value) => `${label}:${canonicalValueJson(value)}`);
-}
-export function removedValues(before, after) {
-    return [...before].filter((value) => !after.has(value)).sort();
-}
-export function addedValues(before, after) {
-    return [...after].filter((value) => !before.has(value)).sort();
-}
-export function same(left, right) {
-    return canonicalValueJson(left) === canonicalValueJson(right);
-}
-function declaredRunner(check) {
-    const runner = check.runner;
-    return {
-        type: runner.type,
-        target: runner.target,
-        argv: runner.argv,
-        cwd: runner.cwd,
-        timeout_ms: runner.timeout_ms,
-        effect: runner.effect,
-        retry_policy: runner.retry_policy,
-        idempotent: runner.idempotent,
-    };
-}

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

@@ -1,24 +0,0 @@
-import type { CheckExecutionResultV2, LongTaskFindingV2 } from "./long-task-delivery-types.js";
-import type { AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
-export interface AuthorityRevisionDiagnosisV2 {
-    schema_version: "long-task-authority-revision-diagnosis-v2";
-    status: "no_authority_change" | "monotonic_revision_available" | "automatic_revision_available" | "scope_candidate_exercised" | "scope_candidate_previewed" | "protected_change_previewed" | "candidate_stale";
-    active_compiled_identity: string;
-    candidate_compiled_identity: string;
-    revision: AuthorityRevisionDecisionV2 | null;
-    acceptance_authorized: false;
-    progress_written: false;
-    pending_revision_written: false;
-    diagnostics_executed: boolean;
-    selected_outcome: string | null;
-    selected_check: string | null;
-    skipped_candidate_checks: string[];
-    snapshot_sha256: string | null;
-    check_results: CheckExecutionResultV2[];
-    findings: LongTaskFindingV2[];
-    completed_at: string;
-}
-export declare function diagnoseAuthorityRevision(workdirInput: string, selection?: {
-    outcome?: string;
-    check?: string;
-}): Promise<AuthorityRevisionDiagnosisV2>;

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

@@ -1,149 +0,0 @@
-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 === "mechanically_bounded_repair")
-        return result({
-            status: "automatic_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,5 +0,0 @@
-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 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>;