project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,204 +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) {
-            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>;

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

@@ -1,53 +0,0 @@
-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 { authorityRevisionUserDecisionReasons, 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) {
-    if (previous.effective_risk === "strict" && nextLevel !== "strict")
-        throw new Error("authority_risk_downgrade_rejected:strict_to_standard");
-    const next = new Set(nextReasons);
-    const removed = previous.risk_reasons.filter((reason) => !next.has(reason));
-    if (removed.length)
-        throw new Error(`authority_risk_downgrade_rejected:${removed.join(",")}`);
-}
-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);
-    const changeClass = classifyAuthorityRevision(diff);
-    const userDecisionReasons = authorityRevisionUserDecisionReasons(diff);
-    const userDecisionRequired = userDecisionReasons.length > 0;
-    const approvalSummary = summarizeAuthorityRevision(diff, nextContract.outcomes.map((outcome) => outcome.key));
-    const unsignedRevision = {
-        previous_hashes: previous.authority_hashes,
-        next_hashes: nextHashes,
-        previous_materials: previousMaterials,
-        next_materials: nextMaterials,
-        previous_material_hashes: authorityMaterialHashes(previousMaterials),
-        next_material_hashes: authorityMaterialHashes(nextMaterials),
-        changed_authority_sections: changedAuthoritySections(previous.authority_hashes, nextHashes),
-        revision_diff: diff,
-        new_risk_floor: riskFloor,
-        affected_outcomes_or_contracts: approvalSummary.affected_outcomes,
-        change_class: changeClass,
-        user_decision_required: userDecisionRequired,
-        user_decision_reasons: userDecisionReasons,
-        approval_required: userDecisionRequired,
-        approval_summary: approvalSummary,
-    };
-    const revisionIdentity = sha256Hex(canonicalValueJson(unsignedRevision));
-    return { ...unsignedRevision, revision_identity: revisionIdentity };
-}
-export async function enforceAuthorityRevision(proposal, workdir) {
-    if (!proposal.user_decision_required)
-        return;
-    if (!(await authorityRevisionApproved(workdir, proposal.revision_identity))) {
-        await writePendingAuthorityRevision(workdir, {
-            schema_version: "long-task-authority-revision-pending-v2",
-            ...proposal,
-            created_at: new Date().toISOString(),
-        });
-        throw new Error(`authority_change_requires_user_decision:${proposal.revision_identity}`);
-    }
-}

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

@@ -1,14 +0,0 @@
-import type { AuthorityRevisionApprovalSummaryV2, AuthorityRevisionChangeClassV2, AuthorityRevisionDecisionV2, AuthorityRevisionDiffV2 } from "./long-task-authority-revision-types.js";
-export declare function classifyAuthorityRevision(diff: AuthorityRevisionDiffV2): AuthorityRevisionChangeClassV2;
-export declare function authorityRevisionUserDecisionReasons(diff: AuthorityRevisionDiffV2): string[];
-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;
-    user_decision_required?: boolean;
-    user_decision_reasons?: string[];
-    approval_required?: boolean;
-    approval_summary?: AuthorityRevisionApprovalSummaryV2;
-}): AuthorityRevisionDecisionV2;