project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,211 +0,0 @@
-import { progressRecordFresh } from "./long-task-progress.js";
-import { blockingExternalRows } from "./long-task-external-confirmation-identity.js";
-export function projectDeliveryStatus(input) {
-    const outcomes = projectOutcomes(input);
-    const stages = projectStages(input.compiled, outcomes);
-    return {
-        finalResult: projectFinalResult(input),
-        finalWorkflowStatus: receiptFresh(input)
-            ? input.receipt.workflow_status
-            : null,
-        targetState: receiptFresh(input)
-            ? (input.receipt.target_state ?? legacyTargetState(input.receipt))
-            : "not_accepted",
-        outcomes,
-        stages,
-        readyStages: Object.entries(stages)
-            .filter(([, status]) => status === "ready")
-            .map(([key]) => key),
-        readyOutcomes: readyOutcomes(input.compiled, outcomes, stages),
-        needsReverify: Object.entries(outcomes)
-            .filter(([, status]) => ["unverified", "progress_stale", "progress_failing"].includes(status))
-            .map(([key]) => key),
-        progressPassing: Object.entries(outcomes)
-            .filter(([, status]) => status === "progress_passing")
-            .map(([key]) => key),
-        progressFailing: Object.entries(outcomes)
-            .filter(([, status]) => status === "progress_failing")
-            .map(([key]) => key),
-        findings: projectFindings(input),
-    };
-}
-function projectOutcomes(input) {
-    const outcomes = {};
-    for (const outcome of input.compiled.outcomes) {
-        const external = input.externalConfirmations.filter((evaluation) => evaluation.blocks_target &&
-            externalConfirmationImpactsOutcome(input.compiled, evaluation, outcome.key));
-        const states = outcome.acceptance.checks.map((check) => {
-            const record = input.progress[check.internal_id];
-            if (!record)
-                return "unverified";
-            if (input.stale.length ||
-                !progressRecordFresh(record, input.compiled, input.manifest, check))
-                return "progress_stale";
-            if (record.result === "passed")
-                return "progress_passing";
-            if (record.result === "blocked_external")
-                return "blocked_external";
-            return "progress_failing";
-        });
-        outcomes[outcome.key] =
-            states.includes("progress_failing") ||
-                external.some((evaluation) => evaluation.state !== "fulfilled" && evaluation.state !== "pending")
-                ? "progress_failing"
-                : external.some((evaluation) => evaluation.state === "pending") ||
-                    states.includes("blocked_external")
-                    ? "blocked_external"
-                    : states.includes("progress_stale")
-                        ? "progress_stale"
-                        : states.length > 0 &&
-                            states.every((state) => state === "progress_passing")
-                            ? "progress_passing"
-                            : "unverified";
-    }
-    return outcomes;
-}
-function externalConfirmationImpactsOutcome(compiled, evaluation, outcomeKey) {
-    return blockingExternalRows(compiled, evaluation.confirmation_ref).some((row) => row.outcome_key === outcomeKey ||
-        row.claim_ref === outcomeKey ||
-        row.claim_ref.startsWith(`${outcomeKey}.`) ||
-        row.local_claim_ref === outcomeKey ||
-        row.local_claim_ref.startsWith(`${outcomeKey}.`));
-}
-function projectFindings(input) {
-    const findings = input.stale.map((code) => ({
-        code,
-        outcome_key: null,
-        check_key: null,
-        message: "A compiled authority input changed.",
-        next_action: "Review the change and recompile the Delivery Contract.",
-    }));
-    if (input.receiptError)
-        findings.push({
-            code: input.receiptError,
-            outcome_key: null,
-            check_key: null,
-            message: "The last audit Receipt is invalid; it has no acceptance authority.",
-            next_action: "Run a new Live Final Gate.",
-        });
-    const checks = [
-        ...input.compiled.global.acceptance.checks,
-        ...input.compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-    for (const record of Object.values(input.progress)) {
-        const check = checks.find((candidate) => candidate.internal_id === record.check_internal_id);
-        if (!check)
-            continue;
-        if (progressRecordFresh(record, input.compiled, input.manifest, check)) {
-            findings.push(...record.findings);
-            continue;
-        }
-        if (check.outcome_key === null)
-            findings.push({
-                code: "global_progress_stale",
-                outcome_key: null,
-                check_key: check.key,
-                message: `Targeted progress for Global Check ${check.key} is stale.`,
-                next_action: "Rerun the Global Check against the current carrier snapshot.",
-            });
-    }
-    return findings;
-}
-function readyOutcomes(compiled, outcomes, stages) {
-    return compiled.outcomes
-        .filter((outcome) => stages[outcome.stage] !== "locked" &&
-        stages[outcome.stage] !== "blocked_external" &&
-        stages[outcome.stage] !== "progress_passing" &&
-        outcomes[outcome.key] !== "blocked_external" &&
-        outcomes[outcome.key] !== "progress_passing" &&
-        outcome.depends_on.every((dependency) => outcomes[dependency] === "progress_passing"))
-        .map((outcome) => outcome.key);
-}
-function legacyTargetState(receipt) {
-    if (receipt.workflow_status === "machine_accepted" ||
-        receipt.workflow_status === "delivery_accepted")
-        return receipt.target_profile.required_state;
-    return receipt.workflow_status === "blocked_external"
-        ? "blocked_external"
-        : "not_accepted";
-}
-function projectStages(compiled, outcomes) {
-    const result = {};
-    const remaining = new Set(compiled.stages.map((stage) => stage.key));
-    while (remaining.size) {
-        let advanced = false;
-        for (const stage of compiled.stages) {
-            if (!remaining.has(stage.key))
-                continue;
-            if (stage.depends_on.some((dependency) => remaining.has(dependency)))
-                continue;
-            const prerequisitesPassing = stage.depends_on.every((dependency) => result[dependency] === "progress_passing");
-            if (!prerequisitesPassing)
-                result[stage.key] = "locked";
-            else {
-                const owned = compiled.outcomes
-                    .filter((outcome) => outcome.stage === stage.key)
-                    .map((outcome) => outcomes[outcome.key]);
-                const gate = outcomes[stage.gate_outcome];
-                result[stage.key] = owned.includes("progress_failing")
-                    ? "progress_failing"
-                    : owned.includes("blocked_external")
-                        ? "blocked_external"
-                        : owned.includes("progress_stale")
-                            ? "progress_stale"
-                            : gate === "progress_passing" &&
-                                owned.every((status) => status === "progress_passing")
-                                ? "progress_passing"
-                                : owned.every((status) => status === "unverified")
-                                    ? "ready"
-                                    : "unverified";
-            }
-            remaining.delete(stage.key);
-            advanced = true;
-        }
-        if (!advanced) {
-            for (const stage of remaining)
-                result[stage] = "locked";
-            break;
-        }
-    }
-    return result;
-}
-function projectFinalResult(input) {
-    if (!input.receipt)
-        return "no_final_gate";
-    if (!receiptFresh(input))
-        return "last_gate_inputs_stale";
-    if (input.receipt.workflow_status === "blocked_external")
-        return "last_gate_blocked";
-    if (input.receipt.workflow_status === "machine_accepted_external_pending")
-        return "last_gate_blocked";
-    if (input.receipt.workflow_status === "needs_work")
-        return "last_gate_failed";
-    return "last_gate_passed";
-}
-function receiptFresh(input) {
-    return Boolean(input.receipt &&
-        !input.receiptError &&
-        input.finalizationIdentitySha256 !== null &&
-        input.receipt.finalization_identity_sha256 ===
-            input.finalizationIdentitySha256 &&
-        !input.stale.length &&
-        blockingExternalInputsFresh(input) &&
-        input.receipt.compiled_identity === input.compiled.compiled_identity &&
-        input.receipt.snapshot_sha256 === input.manifest.snapshot_sha256 &&
-        input.receipt.git_head === input.manifest.git_head &&
-        input.receipt.git_tree === input.manifest.fingerprint.head_tree);
-}
-function blockingExternalInputsFresh(input) {
-    if (!input.receipt)
-        return false;
-    const project = (rows) => rows
-        .filter((row) => row.blocks_target)
-        .map((row) => ({
-        confirmation_ref: row.confirmation_ref,
-        state: row.state,
-        record_sha256: row.record_sha256,
-        relevant_input_identity: row.relevant_input_identity,
-    }))
-        .sort((left, right) => left.confirmation_ref.localeCompare(right.confirmation_ref));
-    return (JSON.stringify(project(input.receipt.external_confirmation_results ?? [])) === JSON.stringify(project(input.externalConfirmations)));
-}

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

@@ -1,61 +0,0 @@
-import type { AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
-import type { ExternalConfirmationV2, ExternalConfirmationEvaluationV1, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2, RepairFrontierV1, StageStatusV2, TargetProfileV2 } from "./long-task-delivery-types.js";
-import { type AuditGateStatusV2 } from "./long-task-status-projection.js";
-export interface DeliveryStatusV2 {
-    schema_version: "long-task-status-v2";
-    task_id: string;
-    compiled_identity: string;
-    effective_risk: "standard" | "strict";
-    workspace_snapshot_sha256: string;
-    acceptance_authority: "live_final_gate_required";
-    acceptance_scope: "declared_delivery_authority";
-    native_goal_effect: "none";
-    final_result: AuditGateStatusV2;
-    final_workflow_status: FinalReceiptV2["workflow_status"] | null;
-    external_confirmations: ExternalConfirmationV2[];
-    external_confirmation_results: ExternalConfirmationEvaluationV1[];
-    target_profile: TargetProfileV2;
-    target_state: FinalReceiptV2["target_state"];
-    outcomes: Record<string, OutcomeStatusV2>;
-    stages: Record<string, StageStatusV2>;
-    ready_stages: string[];
-    ready_outcomes: string[];
-    /** Compatibility alias for the advisory acceptance/verification frontier; never an implementation gate. */
-    ready_for_implementation: string[];
-    needs_reverify: string[];
-    progress_passing: string[];
-    progress_failing: string[];
-    findings: LongTaskFindingV2[];
-    repair_frontier: RepairFrontierV1;
-    pending_authority_revision: AuthorityRevisionDecisionV2 | null;
-}
-export declare function readDeliveryStatus(workdir: string): Promise<DeliveryStatusV2>;
-export declare function resumeDeliveryTask(workdir: string): Promise<Record<string, unknown>>;
-export declare function doctorDeliveryTask(workdirInput: string): Promise<Record<string, unknown>>;
-export declare function stopCheckDeliveryTask(workdirInput: string, messageText?: string): Promise<StopCheckDeliveryResultV2>;
-export interface StopCheckDeliveryResultV2 {
-    continue: boolean;
-    reason: string;
-    workflow_status?: FinalReceiptV2["workflow_status"];
-    external_confirmations?: ExternalConfirmationV2[];
-    external_confirmation_results?: ExternalConfirmationEvaluationV1[];
-    target_profile?: TargetProfileV2;
-    target_state?: FinalReceiptV2["target_state"];
-    stage_results?: FinalReceiptV2["stage_results"];
-    acceptance_scope?: "declared_delivery_authority";
-    native_goal_effect?: "none";
-    message?: string;
-}
-export interface CloseDeliveryResultV2 {
-    status: "closed";
-    workflow_status: Extract<FinalReceiptV2["workflow_status"], "machine_accepted" | "delivery_accepted">;
-    external_confirmations: ExternalConfirmationV2[];
-    external_confirmation_results: ExternalConfirmationEvaluationV1[];
-    target_profile: TargetProfileV2;
-    target_state: FinalReceiptV2["target_state"];
-    stage_results: FinalReceiptV2["stage_results"];
-    acceptance_scope: "declared_delivery_authority";
-    closed_scope: "complete_long_task_authority";
-    native_goal_effect: "none";
-}
-export declare function closeDeliveryTask(workdir: string): Promise<CloseDeliveryResultV2>;

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

@@ -1,363 +0,0 @@
-import path from "node:path";
-import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
-import { authorityRevisionDecisionNextAction } from "./long-task-authority-revision-brief.js";
-import { projectAuthorityRevisionDecision } from "./long-task-authority-revision-summary.js";
-import { externalConfirmationFindings, runDeliveryFinalGate, } from "./long-task-final-v2.js";
-import { evaluateExternalConfirmations } from "./long-task-external-confirmation-plan.js";
-import { captureFinalizationIdentity, finalizationIdentityDigest, } from "./long-task-finalization-identity.js";
-import { enrichFinding } from "./long-task-finding-context.js";
-import { deriveRepairFrontier } from "./long-task-repair-frontier.js";
-import { deliveryCompileFreshness } from "./long-task-freshness.js";
-import { activeAuthorityLockExists, 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) {
-    const root = await repositoryRoot(process.cwd());
-    const loaded = await loadActiveLongTaskAuthority(root);
-    const active = loaded.authority;
-    if (!active)
-        throw new Error("active_task_missing");
-    if (active.workdir !== path.resolve(workdir))
-        throw new Error("active_task_workdir_mismatch");
-    return readDeliveryStatusForAuthority(active);
-}
-async function readDeliveryStatusForAuthority(active) {
-    const compiled = active.authority_snapshot;
-    const cacheStatus = await inspectCompiledCache(active);
-    const current = await captureWorkspaceManifest(compiled.repository_root, compiled.workdir);
-    const stale = await deliveryCompileFreshness(compiled);
-    const [progress, pending] = await Promise.all([
-        readProgressRecords(active.workdir),
-        readPendingAuthorityRevision(active.workdir),
-    ]);
-    let receipt = null;
-    let receiptError = null;
-    try {
-        receipt = await readFinalReceipt(compiled.repository_root, compiled.workdir);
-    }
-    catch (error) {
-        receiptError = message(error);
-    }
-    const externalConfirmationResults = await evaluateExternalConfirmations(compiled, compiled.repository_root, compiled.workdir, current, {
-        git_head: current.git_head,
-        git_tree: current.fingerprint.head_tree,
-        snapshot_sha256: current.snapshot_sha256,
-    });
-    let finalizationIdentitySha256 = null;
-    try {
-        finalizationIdentitySha256 = finalizationIdentityDigest(await captureFinalizationIdentity({
-            repository: compiled.repository_root,
-            active,
-            compiled,
-            candidate: {
-                git_head: current.git_head,
-                git_tree: current.fingerprint.head_tree,
-                snapshot_sha256: current.snapshot_sha256,
-            },
-            workspace_fingerprint: current.fingerprint,
-        }));
-    }
-    catch (error) {
-        receiptError ??= `finalization_identity_invalid:${message(error)}`;
-    }
-    const projection = projectDeliveryStatus({
-        compiled,
-        manifest: current,
-        stale,
-        progress,
-        receipt,
-        receiptError,
-        finalizationIdentitySha256,
-        externalConfirmations: externalConfirmationResults,
-    });
-    const findings = [
-        ...projection.findings,
-        ...externalConfirmationFindings(compiled, externalConfirmationResults),
-        ...(cacheStatus === "compiled_cache_matching"
-            ? []
-            : [cacheDiagnostic(cacheStatus)]),
-    ].map((finding) => enrichFinding(compiled, finding));
-    const repairFrontier = deriveRepairFrontier({
-        compiled,
-        manifest: current,
-        progress,
-        findings,
-    });
-    return {
-        schema_version: "long-task-status-v2",
-        task_id: compiled.task.id,
-        compiled_identity: compiled.compiled_identity,
-        effective_risk: compiled.effective_risk,
-        workspace_snapshot_sha256: current.snapshot_sha256,
-        acceptance_authority: "live_final_gate_required",
-        acceptance_scope: "declared_delivery_authority",
-        native_goal_effect: "none",
-        final_result: projection.finalResult,
-        final_workflow_status: projection.finalWorkflowStatus,
-        external_confirmations: compiled.global.acceptance.external_confirmations,
-        external_confirmation_results: externalConfirmationResults,
-        target_profile: compiled.task.target_profile,
-        target_state: projection.targetState,
-        outcomes: projection.outcomes,
-        stages: projection.stages,
-        ready_stages: projection.readyStages,
-        ready_outcomes: projection.readyOutcomes,
-        ready_for_implementation: projection.readyOutcomes,
-        needs_reverify: projection.needsReverify,
-        progress_passing: projection.progressPassing,
-        progress_failing: projection.progressFailing,
-        pending_authority_revision: pending
-            ? projectAuthorityRevisionDecision(pending)
-            : null,
-        findings,
-        repair_frontier: repairFrontier,
-    };
-}
-export async function resumeDeliveryTask(workdir) {
-    const root = await repositoryRoot(process.cwd());
-    const loaded = await loadActiveLongTaskAuthority(root);
-    const active = loaded.authority;
-    if (!active)
-        throw new Error("active_task_missing");
-    if (active.workdir !== path.resolve(workdir))
-        throw new Error("active_task_workdir_mismatch");
-    const compiled = active.authority_snapshot;
-    // Status capture runs git write-tree; finish it before git status can refresh
-    // the same repository index inside currentGitState.
-    const status = await readDeliveryStatusForAuthority(active);
-    const git = await currentGitState(compiled.repository_root);
-    return {
-        schema_version: "long-task-resume-v2",
-        task: {
-            id: compiled.task.id,
-            title: compiled.task.title,
-            goal: compiled.task.goal,
-            target_profile: compiled.task.target_profile,
-            execution_targets: compiled.task.execution_targets,
-        },
-        contract_identity: compiled.compiled_identity,
-        authority_revision: compiled.authority_revision,
-        effective_risk: compiled.effective_risk,
-        context_refs: compiled.task.context_refs,
-        git,
-        acceptance_authority: "live_final_gate_required",
-        acceptance_scope: "declared_delivery_authority",
-        native_goal_effect: "none",
-        last_gate: status.final_result,
-        final_workflow_status: status.final_workflow_status,
-        external_confirmations: status.external_confirmations,
-        external_confirmation_results: status.external_confirmation_results,
-        target_profile: status.target_profile,
-        target_state: status.target_state,
-        outcomes: status.outcomes,
-        stages: status.stages,
-        ready_stages: status.ready_stages,
-        ready_outcomes: status.ready_outcomes,
-        ready_for_implementation: status.ready_for_implementation,
-        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,
-        repair_frontier: status.repair_frontier,
-        next_safe_action: nextAction(status),
-    };
-}
-export async function doctorDeliveryTask(workdirInput) {
-    const root = await repositoryRoot(process.cwd());
-    let loaded;
-    try {
-        loaded = await loadActiveLongTaskAuthority(root);
-    }
-    catch (error) {
-        const finding = doctorAuthorityFinding(message(error));
-        return {
-            schema_version: "long-task-doctor-v2",
-            status: finding,
-            healthy: false,
-            findings: [finding],
-            next_action: `ty-context long-task abandon ${path.resolve(workdirInput)} --force-corrupt-state`,
-        };
-    }
-    const active = loaded.authority;
-    if (!active)
-        return { status: "no_active_task", healthy: true };
-    if (active.workdir !== path.resolve(workdirInput))
-        throw new Error("active_task_workdir_mismatch");
-    const findings = [
-        "active_authority_valid",
-        await inspectCompiledCache(active),
-    ];
-    if (await activeAuthorityLockExists(root))
-        findings.push("active_authority_lock_present");
-    let currentAuthorityIdentity = null;
-    try {
-        const compiled = await compileDeliveryContract(active.workdir, root, {
-            live_gate: true,
-            initial_task_base: active.initial_task_base,
-            authority_revision: active.authority_revision,
-            require_completion_gate: true,
-        });
-        currentAuthorityIdentity = compiled.compiled_identity;
-        if (compiled.compiled_identity !== active.active_authority_identity)
-            findings.push("active_authority_source_mismatch");
-    }
-    catch (error) {
-        findings.push(`active_authority_source_invalid:${message(error)}`);
-    }
-    return {
-        schema_version: "long-task-doctor-v2",
-        status: findings[0],
-        healthy: !findings.some((finding) => finding === "active_authority_lock_present" ||
-            finding === "active_authority_source_mismatch" ||
-            finding.startsWith("active_authority_source_invalid:")),
-        task_id: active.task_id,
-        authority_revision: active.authority_revision,
-        marker_and_record: "matched",
-        contract: "available",
-        current_authority_identity: currentAuthorityIdentity,
-        active_authority_identity: active.active_authority_identity,
-        verifier_identity: active.verifier_identity.bundle_sha256,
-        hook: "available",
-        source_context_fresh: !findings.some((finding) => finding.startsWith("active_authority_source_")),
-        compiled_cache: findings.find((finding) => finding.startsWith("compiled_cache_")),
-        findings,
-        ...(findings.includes("active_authority_lock_present")
-            ? {
-                next_action: `ty-context long-task abandon ${path.resolve(workdirInput)} --force-corrupt-state`,
-            }
-            : {}),
-    };
-}
-export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
-    const root = await repositoryRoot(process.cwd());
-    let active;
-    try {
-        active = await readActiveLongTaskBinding(root);
-    }
-    catch (error) {
-        return {
-            continue: false,
-            reason: "long_task_state_invalid",
-            message: message(error),
-        };
-    }
-    if (!active)
-        return { continue: true, reason: "no_active_task" };
-    if (active.workdir !== path.resolve(workdirInput))
-        return { continue: false, reason: "active_task_workdir_mismatch" };
-    try {
-        const result = await runDeliveryFinalGate(active.workdir, {
-            close_on_accept: true,
-        });
-        if (result.workflow_status === "machine_accepted" ||
-            result.workflow_status === "delivery_accepted") {
-            return {
-                continue: true,
-                reason: result.workflow_status,
-                workflow_status: result.workflow_status,
-                external_confirmations: result.external_confirmations,
-                external_confirmation_results: result.external_confirmation_results,
-                target_profile: result.target_profile,
-                target_state: result.target_state,
-                stage_results: result.stage_results,
-                acceptance_scope: "declared_delivery_authority",
-                native_goal_effect: "none",
-                message: acceptedScopeMessage(result.workflow_status, result.target_profile),
-            };
-        }
-        return {
-            continue: false,
-            reason: `live_final_gate_${result.workflow_status}`,
-            workflow_status: result.workflow_status,
-            external_confirmations: result.external_confirmations,
-            external_confirmation_results: result.external_confirmation_results,
-            target_profile: result.target_profile,
-            target_state: result.target_state,
-            stage_results: result.stage_results,
-            message: messageText ||
-                result.findings.at(-1)?.next_action ||
-                "Repair the failing Check and rerun Stop.",
-        };
-    }
-    catch (error) {
-        if (message(error).includes("verifier_authority_migration_required"))
-            return {
-                continue: false,
-                reason: "verifier_authority_migration_required",
-            };
-        return {
-            continue: false,
-            reason: "live_final_gate_error",
-            message: message(error),
-        };
-    }
-}
-export async function closeDeliveryTask(workdir) {
-    const root = await repositoryRoot(process.cwd());
-    const active = await readActiveLongTaskBinding(root);
-    if (!active || active.workdir !== path.resolve(workdir))
-        throw new Error("active_task_missing_or_mismatched");
-    const result = await runDeliveryFinalGate(active.workdir, {
-        close_on_accept: true,
-    });
-    if (result.workflow_status !== "machine_accepted" &&
-        result.workflow_status !== "delivery_accepted")
-        throw new Error(`close_live_final_gate_failed:${result.workflow_status}`);
-    return {
-        status: "closed",
-        workflow_status: result.workflow_status,
-        external_confirmations: result.external_confirmations,
-        external_confirmation_results: result.external_confirmation_results,
-        target_profile: result.target_profile,
-        target_state: result.target_state,
-        stage_results: result.stage_results,
-        acceptance_scope: "declared_delivery_authority",
-        closed_scope: "complete_long_task_authority",
-        native_goal_effect: "none",
-    };
-}
-function acceptedScopeMessage(workflowStatus, targetProfile) {
-    const route = workflowStatus === "machine_accepted"
-        ? "package-admitted machine evidence"
-        : "package-admitted machine evidence plus fresh exact external fulfillment records";
-    return `Declared complete-delivery Authority accepted for target ${targetProfile.key}:${targetProfile.required_state} through ${route} and cleared. This result has no direct effect on the platform-native Goal; before completing it, confirm current Goal/user meaning is fully represented by accepted Source and no revision, blocker, or omitted requirement remains.`;
-}
-function nextAction(status) {
-    if (status.pending_authority_revision)
-        return authorityRevisionDecisionNextAction(status.pending_authority_revision);
-    if (status.findings.length)
-        return status.findings.at(-1).next_action;
-    if (status.ready_outcomes.length) {
-        const outcome = status.ready_outcomes[0];
-        if (status.outcomes[outcome] === "progress_stale")
-            return `Targeted evidence for Outcome ${outcome} on the acceptance/verification frontier is stale. This is a freshness fact, not an implementation gate or immediate per-edit rerun instruction: coalesce relevant changes and refresh the cheapest reliable declared Check only before relying on this Progress. Implementation may continue, and Final Gate needs no targeted refresh because it reruns every Check.`;
-        return `Outcome ${outcome} is on the advisory acceptance/verification frontier. Implementation order remains Goal-owned; run its declared Check when the feedback value justifies the cost, or continue in-scope implementation before the complete Final Gate.`;
-    }
-    return "Create a clean candidate commit; Stop will run the authoritative Live Final Gate.";
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function cacheDiagnostic(code) {
-    return {
-        code,
-        outcome_key: null,
-        check_key: null,
-        message: code === "compiled_cache_missing_repairable"
-            ? "The compiled cache projection is missing; active authority remains valid."
-            : "The compiled cache projection does not match active authority and was ignored.",
-        next_action: "Run ty-context long-task compile to rebuild the cache projection from active authority.",
-    };
-}
-function doctorAuthorityFinding(error) {
-    if (error.includes("legacy_v2_active_authority_manual_required"))
-        return "legacy_v2_active_authority_manual_required";
-    if (error.includes("active_authority_continuity_unrecoverable"))
-        return "active_authority_continuity_unrecoverable";
-    if (error.includes("marker") ||
-        error.includes("active_binding_marker") ||
-        error.includes("active_binding_record_missing"))
-        return "marker_record_mismatch";
-    return "active_authority_invalid";
-}

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

@@ -1,11 +0,0 @@
-import type { CompiledClaimsV2 } from "./long-task-claims.js";
-import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
-import type { CompiledOutcomeV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-type Reporter = (message: string) => void;
-export declare function validateExecutionTargets(contract: DeliveryContractV2, report?: Reporter, options?: {
-    defer_completion_authority_closure?: boolean;
-    acceptance_reachability?: AcceptanceReachabilityV1 | null;
-    compiled_outcomes?: readonly CompiledOutcomeV2[];
-}): void;
-export declare function validateExternalConfirmationImpacts(contract: DeliveryContractV2, claims: CompiledClaimsV2, report?: Reporter): void;
-export {};