project-tiny-context-harness 0.2.84 → 0.6.0

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

@@ -0,0 +1,116 @@
+import { progressRecordFresh } from "./long-task-progress.js";
+export function projectDeliveryStatus(input) {
+    const outcomes = projectOutcomes(input);
+    return {
+        finalResult: projectFinalResult(input),
+        finalWorkflowStatus: receiptFresh(input)
+            ? input.receipt.workflow_status
+            : null,
+        outcomes,
+        readyOutcomes: readyOutcomes(input.compiled, outcomes),
+        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 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")
+            ? "progress_failing"
+            : 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 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) {
+    return compiled.outcomes
+        .filter((outcome) => outcomes[outcome.key] !== "progress_passing" &&
+        outcome.depends_on.every((dependency) => outcomes[dependency] === "progress_passing"))
+        .map((outcome) => outcome.key);
+}
+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 === "needs_work")
+        return "last_gate_failed";
+    return "last_gate_passed";
+}
+function receiptFresh(input) {
+    return Boolean(input.receipt &&
+        !input.receiptError &&
+        !input.stale.length &&
+        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);
+}

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

@@ -0,0 +1,37 @@
+import type { ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2 } 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";
+    final_result: AuditGateStatusV2;
+    final_workflow_status: FinalReceiptV2["workflow_status"] | null;
+    external_confirmations: ExternalConfirmationV2[];
+    outcomes: Record<string, OutcomeStatusV2>;
+    ready_outcomes: string[];
+    ready_for_implementation: string[];
+    needs_reverify: string[];
+    progress_passing: string[];
+    progress_failing: string[];
+    findings: LongTaskFindingV2[];
+}
+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[];
+    message?: string;
+}
+export interface CloseDeliveryResultV2 {
+    status: "closed";
+    workflow_status: Extract<FinalReceiptV2["workflow_status"], "machine_accepted" | "machine_accepted_external_pending">;
+    external_confirmations: ExternalConfirmationV2[];
+}
+export declare function closeDeliveryTask(workdir: string): Promise<CloseDeliveryResultV2>;

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

@@ -0,0 +1,306 @@
+import path from "node:path";
+import { compileDeliveryContract } from "./long-task-delivery-compiler.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 { 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 = await readProgressRecords(active.workdir);
+    let receipt = null;
+    let receiptError = null;
+    try {
+        receipt = await readFinalReceipt(compiled.repository_root, compiled.workdir);
+    }
+    catch (error) {
+        receiptError = message(error);
+    }
+    const projection = projectDeliveryStatus({
+        compiled,
+        manifest: current,
+        stale,
+        progress,
+        receipt,
+        receiptError,
+    });
+    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",
+        final_result: projection.finalResult,
+        final_workflow_status: projection.finalWorkflowStatus,
+        external_confirmations: compiled.global.acceptance.external_confirmations,
+        outcomes: projection.outcomes,
+        ready_outcomes: projection.readyOutcomes,
+        ready_for_implementation: projection.readyOutcomes,
+        needs_reverify: projection.needsReverify,
+        progress_passing: projection.progressPassing,
+        progress_failing: projection.progressFailing,
+        findings: [
+            ...projection.findings,
+            ...(cacheStatus === "compiled_cache_matching"
+                ? []
+                : [cacheDiagnostic(cacheStatus)]),
+        ],
+    };
+}
+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;
+    const [status, git] = await Promise.all([
+        readDeliveryStatusForAuthority(active),
+        currentGitState(compiled.repository_root),
+    ]);
+    return {
+        schema_version: "long-task-resume-v2",
+        task: {
+            id: compiled.task.id,
+            title: compiled.task.title,
+            goal: compiled.task.goal,
+        },
+        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",
+        last_gate: status.final_result,
+        final_workflow_status: status.final_workflow_status,
+        external_confirmations: status.external_confirmations,
+        outcomes: status.outcomes,
+        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,
+        recent_findings: status.findings,
+        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);
+        if (result.workflow_status === "machine_accepted" ||
+            result.workflow_status === "machine_accepted_external_pending") {
+            try {
+                await clearActiveBindingCas({
+                    repository_root: root,
+                    workdir: active.workdir,
+                    task_id: active.task_id,
+                    authority_revision: active.authority_revision,
+                    compiled_identity: active.active_authority_identity,
+                    worktree_identity: active.worktree_identity,
+                });
+            }
+            catch (error) {
+                if (message(error).includes("active_authority_clear_compare_and_swap_failed"))
+                    return {
+                        continue: false,
+                        reason: "active_authority_changed_after_final_gate",
+                        workflow_status: result.workflow_status,
+                        external_confirmations: result.external_confirmations,
+                        message: "Active Authority changed after the Live Final Gate; the accepted identity was not cleared.",
+                    };
+                throw error;
+            }
+            return {
+                continue: true,
+                reason: result.workflow_status,
+                workflow_status: result.workflow_status,
+                external_confirmations: result.external_confirmations,
+                ...(result.workflow_status === "machine_accepted_external_pending"
+                    ? {
+                        message: externalPendingMessage(result.external_confirmations),
+                    }
+                    : {}),
+            };
+        }
+        return {
+            continue: false,
+            reason: `live_final_gate_${result.workflow_status}`,
+            workflow_status: result.workflow_status,
+            external_confirmations: result.external_confirmations,
+            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);
+    if (result.workflow_status !== "machine_accepted" &&
+        result.workflow_status !== "machine_accepted_external_pending")
+        throw new Error(`close_live_final_gate_failed:${result.workflow_status}`);
+    await clearActiveBindingCas({
+        repository_root: root,
+        workdir: active.workdir,
+        task_id: active.task_id,
+        authority_revision: active.authority_revision,
+        compiled_identity: active.active_authority_identity,
+        worktree_identity: active.worktree_identity,
+    });
+    return {
+        status: "closed",
+        workflow_status: result.workflow_status,
+        external_confirmations: result.external_confirmations,
+    };
+}
+function externalPendingMessage(confirmations) {
+    const pending = confirmations
+        .map((confirmation) => `${confirmation.key} (${confirmation.owner})`)
+        .join(", ");
+    return `Machine-verifiable scope accepted. Complete external delivery remains pending: ${pending}. Do not report complete external delivery.`;
+}
+function nextAction(status) {
+    if (status.findings.length)
+        return status.findings.at(-1).next_action;
+    if (status.ready_outcomes.length)
+        return `Implement and verify ready Outcome: ${status.ready_outcomes[0]}.`;
+    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-technical-shape.d.ts

@@ -0,0 +1,3 @@
+import type { DeliveryBindingV2, RollbackRecoveryV2 } from "./long-task-delivery-types.js";
+export declare function parseBindings(value: unknown, label: string): DeliveryBindingV2[];
+export declare function parseRollback(value: unknown, label: string): RollbackRecoveryV2;

package/dist/lib/long-task-technical-shape.js

@@ -0,0 +1,44 @@
+import { array, fail, key, literal, object, repositoryFile, repositoryPattern, repositoryPatterns, string, strings, } from "./long-task-shape-primitives.js";
+export function parseBindings(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, ["key", "kind", "target", "carrier_paths"], ["existence", "verification_check_key"]);
+        const kindValue = literal(row.kind, ["path_glob", "file", "verified"], `${itemLabel}.kind`);
+        const verificationCheckKey = Object.hasOwn(row, "verification_check_key")
+            ? key(row.verification_check_key, `${itemLabel}.verification_check_key`)
+            : undefined;
+        if (kindValue === "verified" && !verificationCheckKey)
+            fail(`${itemLabel}.verification_check_key`, "is required for verified");
+        if (kindValue !== "verified" && verificationCheckKey)
+            fail(`${itemLabel}.verification_check_key`, "is only allowed for verified");
+        const target = kindValue === "file"
+            ? repositoryFile(row.target, `${itemLabel}.target`)
+            : kindValue === "path_glob"
+                ? repositoryPattern(row.target, `${itemLabel}.target`)
+                : string(row.target, `${itemLabel}.target`);
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            kind: kindValue,
+            target,
+            carrier_paths: repositoryPatterns(row.carrier_paths, `${itemLabel}.carrier_paths`),
+            existence: Object.hasOwn(row, "existence")
+                ? literal(row.existence, ["existing", "planned"], `${itemLabel}.existence`)
+                : "existing",
+            ...(verificationCheckKey
+                ? { verification_check_key: verificationCheckKey }
+                : {}),
+        };
+    });
+}
+export function parseRollback(value, label) {
+    const row = object(value, label, [
+        "rollback",
+        "recovery",
+        "verification_check_keys",
+    ]);
+    return {
+        rollback: string(row.rollback, `${label}.rollback`),
+        recovery: string(row.recovery, `${label}.recovery`),
+        verification_check_keys: strings(row.verification_check_keys, `${label}.verification_check_keys`),
+    };
+}

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

@@ -0,0 +1,12 @@
+import type { VerifierContentAuthority, VerifierIdentityV2, VerifierRuntimeLocator } from "./long-task-delivery-types.js";
+export interface VerifierAuthorityDiffV2 {
+    verifier_content_changed: boolean;
+    verifier_runtime_locator_changed: boolean;
+    verifier_files_changed: string[];
+    previous_verifier: VerifierIdentityV2;
+    next_verifier: VerifierIdentityV2;
+}
+export declare function verifierContentAuthority(identity: VerifierIdentityV2): VerifierContentAuthority;
+export declare function verifierRuntimeLocator(identity: VerifierIdentityV2): VerifierRuntimeLocator;
+export declare function verifierAuthorityDiff(previous: VerifierIdentityV2, next: VerifierIdentityV2): VerifierAuthorityDiffV2;
+export declare function verifierIdentityMatches(previous: VerifierIdentityV2, next: VerifierIdentityV2): boolean;

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

@@ -0,0 +1,47 @@
+import { canonicalValueJson } from "./strict-codec.js";
+export function verifierContentAuthority(identity) {
+    return {
+        package_name: identity.package_name,
+        bundle_sha256: identity.bundle_sha256,
+        schema_sha256: identity.schema_sha256,
+        hook_sha256: identity.hook_sha256,
+        bundle_files: identity.bundle_files,
+    };
+}
+export function verifierRuntimeLocator(identity) {
+    return {
+        package_version: identity.package_version,
+        package_root: identity.package_root,
+    };
+}
+export function verifierAuthorityDiff(previous, next) {
+    const contentChanged = canonicalValueJson(verifierContentAuthority(previous)) !==
+        canonicalValueJson(verifierContentAuthority(next));
+    const locatorChanged = canonicalValueJson(verifierRuntimeLocator(previous)) !==
+        canonicalValueJson(verifierRuntimeLocator(next));
+    return {
+        verifier_content_changed: contentChanged,
+        verifier_runtime_locator_changed: locatorChanged,
+        verifier_files_changed: changedVerifierFiles(previous, next),
+        previous_verifier: previous,
+        next_verifier: next,
+    };
+}
+export function verifierIdentityMatches(previous, next) {
+    const diff = verifierAuthorityDiff(previous, next);
+    return (!diff.verifier_content_changed && !diff.verifier_runtime_locator_changed);
+}
+function changedVerifierFiles(previous, next) {
+    const files = new Set([
+        ...Object.keys(previous.bundle_files),
+        ...Object.keys(next.bundle_files),
+    ]);
+    const changed = [...files].filter((file) => previous.bundle_files[file] !== next.bundle_files[file]);
+    if (previous.schema_sha256 !== next.schema_sha256)
+        changed.push("<schema>");
+    if (previous.hook_sha256 !== next.hook_sha256)
+        changed.push("<hook>");
+    if (previous.package_name !== next.package_name)
+        changed.push("<package-name>");
+    return [...new Set(changed)].sort();
+}

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

@@ -0,0 +1,2 @@
+import type { VerifierIdentityV2 } from "./long-task-delivery-types.js";
+export declare function captureVerifierIdentity(repositoryRoot: string, requireHook: boolean): Promise<VerifierIdentityV2>;

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

@@ -0,0 +1,55 @@
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import DELIVERY_SCHEMA from "../schemas/long-task-delivery-v2/long-task-delivery-v2.schema.json" with { type: "json" };
+import OUTCOMES_SCHEMA from "../schemas/long-task-delivery-v2/long-task-outcomes-v2.schema.json" with { type: "json" };
+import { checkLongTaskCompletionGate } from "./long-task-hook-preflight.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+const REQUIRED_ENTRYPOINTS = [
+    "cli.js",
+    "long-task-hook.js",
+    "commands/long-task.js",
+    "commands/delivery-set.js",
+    "lib/context-graph-snapshot.js",
+    "lib/strict-codec.js",
+];
+export async function captureVerifierIdentity(repositoryRoot, requireHook) {
+    const packageRoot = fileURLToPath(new URL("../../", import.meta.url));
+    const packageFile = await assertProtectedRepositoryFile(packageRoot, path.join(packageRoot, "package.json"), "package_owned_verifier_package");
+    const packageJson = JSON.parse(await readFile(packageFile, "utf8"));
+    const files = await verifierBundleFiles(packageRoot);
+    const hook = requireHook
+        ? await checkLongTaskCompletionGate(repositoryRoot, packageRoot)
+        : null;
+    if (hook && hook.status !== "available")
+        throw new Error(`completion_gate_unavailable:${hook.findings.join(",")}`);
+    return {
+        package_name: "project-tiny-context-harness",
+        package_version: packageJson.version,
+        package_root: packageRoot,
+        bundle_sha256: sha256Hex(canonicalValueJson(files)),
+        bundle_files: files,
+        schema_sha256: sha256Hex(canonicalValueJson({
+            delivery: DELIVERY_SCHEMA,
+            outcomes: OUTCOMES_SCHEMA,
+        })),
+        hook_sha256: hook?.hook_sha256 ?? "not-required",
+    };
+}
+async function verifierBundleFiles(packageRoot) {
+    const distRoot = path.join(packageRoot, "dist");
+    const relativeFiles = new Set(REQUIRED_ENTRYPOINTS);
+    for (const file of await readdir(path.join(distRoot, "lib")))
+        if (/^long-task-.*\.js$/u.test(file))
+            relativeFiles.add(`lib/${file}`);
+    relativeFiles.add("schemas/long-task-delivery-v2/long-task-delivery-v2.schema.json");
+    relativeFiles.add("schemas/long-task-delivery-v2/long-task-outcomes-v2.schema.json");
+    const rows = await Promise.all([...relativeFiles]
+        .sort()
+        .map(async (relative) => [
+        relative,
+        sha256Hex(await readFile(await assertProtectedRepositoryFile(packageRoot, path.join(distRoot, ...relative.split("/")), `package_owned_verifier:${relative}`))),
+    ]));
+    return Object.fromEntries(rows);
+}

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

@@ -0,0 +1,13 @@
+import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, LongTaskFindingV2, TargetedVerificationResultV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+import { type WorkspaceSnapshotV2 } from "./long-task-workspace.js";
+export interface DeliveryRunV2 {
+    snapshot: WorkspaceManifestV2;
+    check_results: CheckExecutionResultV2[];
+    findings: LongTaskFindingV2[];
+}
+export declare function verifyDeliveryContract(workdir: string, selection?: {
+    outcome?: string;
+    check?: string;
+}): 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[];