project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-static-observation-freeze.js

@@ -1,428 +0,0 @@
-import { createHash } from "node:crypto";
-import { constants, watch } from "node:fs";
-import { lstat, open, realpath } from "node:fs/promises";
-import path from "node:path";
-import { JSON_POINTER_EXACT_LIMITS, assertJsonTree, decodeUtf8Json, extractJsonPointerExactObservationFromBytes, normalizeObservationArtifactPath, parseJsonWithoutDuplicateKeys, resolveJsonPointer, } from "./long-task-json-pointer-observation.js";
-export class StaticObservationFreezeError extends Error {
-    code;
-    artifact_path;
-    cause_code;
-    constructor(code, artifactPath, causeCode = null) {
-        super([code, artifactPath, causeCode]
-            .filter((value) => value !== null && value !== "")
-            .join(":"));
-        this.name = "StaticObservationFreezeError";
-        this.code = code;
-        this.artifact_path = artifactPath;
-        this.cause_code = causeCode;
-    }
-}
-export function createObservationInputFreezeBudget(input) {
-    if (!Number.isSafeInteger(input.max_artifacts) ||
-        input.max_artifacts <= 0 ||
-        !Number.isSafeInteger(input.max_total_artifact_bytes) ||
-        input.max_total_artifact_bytes <= 0)
-        throw new Error("observation_input_freeze_budget_invalid");
-    return {
-        seen_artifact_paths: new Set(),
-        total_artifact_bytes: 0,
-        max_artifacts: input.max_artifacts,
-        max_total_artifact_bytes: input.max_total_artifact_bytes,
-    };
-}
-export async function freezeStaticObservationCarrier(input) {
-    const artifactPath = normalizeStaticArtifactPath(input.artifact_path);
-    assertArtifactCount(input.budget, artifactPath);
-    const prepared = await prepareFrozenObservationInput({
-        snapshot_root: input.snapshot_root,
-        workspace_manifest: input.workspace_manifest,
-        artifact_path: artifactPath,
-        max_file_bytes: JSON_POINTER_EXACT_LIMITS.max_file_bytes,
-        budget: input.input_freeze_budget,
-        retain_bytes: true,
-    });
-    accountForArtifact(input.budget, artifactPath, prepared.preRunIdentity.size);
-    const frozenBytes = prepared.frozenBytes;
-    if (!frozenBytes)
-        throw new Error("static_observation_frozen_bytes_missing");
-    return Object.freeze({
-        artifact_path: artifactPath,
-        manifest_membership: prepared.manifest,
-        pre_run_identity: prepared.preRunIdentity,
-        verifyPostRun: async () => {
-            try {
-                const postRunIdentity = await prepared.verifyPostRunIdentity();
-                return Object.freeze({
-                    artifact_path: artifactPath,
-                    manifest_membership: prepared.manifest,
-                    pre_run_identity: prepared.preRunIdentity,
-                    post_run_identity: postRunIdentity,
-                    copyFrozenBytes: () => Uint8Array.from(frozenBytes),
-                    extractJsonPointerExactObservation: (input) => extractJsonPointerExactObservationFromBytes({
-                        artifact_path: artifactPath,
-                        bytes: frozenBytes,
-                        locator: input.locator,
-                        sensitivity: input.sensitivity,
-                        budget: input.budget,
-                    }),
-                    extractJsonPointerExactValue: (input) => {
-                        const observation = extractJsonPointerExactObservationFromBytes({
-                            artifact_path: artifactPath,
-                            bytes: frozenBytes,
-                            locator: input.locator,
-                            sensitivity: input.sensitivity,
-                            budget: input.budget,
-                        });
-                        const parsed = parseJsonWithoutDuplicateKeys(decodeUtf8Json(frozenBytes));
-                        assertJsonTree(parsed, 0);
-                        return {
-                            raw_value: resolveJsonPointer(parsed, observation.locator.value),
-                            observation,
-                        };
-                    },
-                });
-            }
-            finally {
-                prepared.dispose();
-            }
-        },
-        dispose: prepared.dispose,
-    });
-}
-export async function freezeObservationInputFile(input) {
-    const prepared = await prepareFrozenObservationInput({
-        ...input,
-        retain_bytes: false,
-    });
-    return Object.freeze({
-        artifact_path: prepared.artifactPath,
-        manifest_membership: prepared.manifest,
-        pre_run_identity: prepared.preRunIdentity,
-        verifyPostRun: async () => {
-            try {
-                const postRunIdentity = await prepared.verifyPostRunIdentity();
-                return Object.freeze({
-                    artifact_path: prepared.artifactPath,
-                    manifest_membership: prepared.manifest,
-                    pre_run_identity: prepared.preRunIdentity,
-                    post_run_identity: postRunIdentity,
-                });
-            }
-            finally {
-                prepared.dispose();
-            }
-        },
-        dispose: prepared.dispose,
-    });
-}
-async function prepareFrozenObservationInput(input) {
-    const artifactPath = normalizeStaticArtifactPath(input.artifact_path);
-    const maxFileBytes = observationInputFileLimit(input.max_file_bytes);
-    const manifestEntry = manifestMembership(input.workspace_manifest, artifactPath);
-    assertObservationInputCount(input.budget, artifactPath);
-    const root = path.resolve(input.snapshot_root);
-    const captured = await captureStaticObservationFile(root, artifactPath, maxFileBytes, input.retain_bytes);
-    accountForObservationInput(input.budget, artifactPath, captured.identity.size);
-    const manifest = freezeManifestMembership(manifestEntry);
-    const preRunIdentity = freezeFileIdentity(captured.identity);
-    const frozenBytes = captured.bytes ? Buffer.from(captured.bytes) : null;
-    const mutationMonitor = monitorObservationInput(root, artifactPath);
-    return {
-        artifactPath,
-        manifest,
-        preRunIdentity,
-        frozenBytes,
-        verifyPostRunIdentity: async () => {
-            let post;
-            try {
-                await mutationMonitor.assertUnchanged();
-                post = await captureStaticObservationFile(root, artifactPath, maxFileBytes, false, preRunIdentity);
-                if (post.identity.content_sha256 !== preRunIdentity.content_sha256)
-                    throw freezeError("static_observation_changed_by_runner", artifactPath, "content_sha256");
-                await mutationMonitor.assertUnchanged();
-            }
-            catch (error) {
-                if (error instanceof StaticObservationFreezeError &&
-                    error.code === "static_observation_changed_by_runner")
-                    throw error;
-                throw freezeError("static_observation_changed_by_runner", artifactPath, freezeCause(error));
-            }
-            return freezeFileIdentity(post.identity);
-        },
-        dispose: mutationMonitor.dispose,
-    };
-}
-function monitorObservationInput(root, artifactPath) {
-    const absolute = path.resolve(root, ...artifactPath.split("/"));
-    let changedCause = null;
-    let disposed = false;
-    let watcher;
-    try {
-        watcher = watch(absolute, { persistent: false }, (eventType) => {
-            changedCause ??= `filesystem_event.${eventType}`;
-        });
-    }
-    catch (error) {
-        throw freezeError("static_observation_changed_by_runner", artifactPath, `monitor_unavailable.${nodeErrorCode(error)}`);
-    }
-    watcher.on("error", (error) => {
-        changedCause ??= `filesystem_monitor_error.${nodeErrorCode(error)}`;
-    });
-    return {
-        assertUnchanged: async () => {
-            await settleFilesystemEvents();
-            if (changedCause)
-                throw freezeError("static_observation_changed_by_runner", artifactPath, changedCause);
-        },
-        dispose: () => {
-            if (disposed)
-                return;
-            disposed = true;
-            watcher.close();
-        },
-    };
-}
-async function settleFilesystemEvents() {
-    await new Promise((resolve) => setImmediate(resolve));
-    await new Promise((resolve) => setImmediate(resolve));
-}
-const STATIC_OBSERVATION_METADATA_KEYS = Object.freeze([
-    "device",
-    "inode",
-    "mode",
-    "links",
-    "size",
-    "modified_time_ns",
-    "changed_time_ns",
-    "birth_time_ns",
-]);
-async function captureStaticObservationFile(root, artifactPath, maxFileBytes, retainBytes, expected) {
-    const rootInfo = await lstat(root, { bigint: true }).catch((error) => {
-        throw freezeError("static_observation_root_invalid", artifactPath, nodeErrorCode(error));
-    });
-    if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory())
-        throw freezeError("static_observation_root_invalid", artifactPath);
-    const canonicalRoot = await realpath(root);
-    const absolute = path.resolve(root, ...artifactPath.split("/"));
-    assertContained(root, absolute, artifactPath);
-    const pathInfo = await inspectNoFollowPath(root, artifactPath, expected);
-    const canonicalFile = await realpath(absolute).catch((error) => {
-        throw freezeError(expected
-            ? "static_observation_changed_by_runner"
-            : "static_observation_not_in_pre_run_snapshot", artifactPath, nodeErrorCode(error));
-    });
-    assertContained(canonicalRoot, canonicalFile, artifactPath);
-    const noFollow = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
-    const handle = await open(absolute, constants.O_RDONLY | noFollow).catch((error) => {
-        throw freezeError(expected
-            ? "static_observation_changed_by_runner"
-            : openFailureCode(error), artifactPath, nodeErrorCode(error));
-    });
-    try {
-        const opened = await handle.stat({ bigint: true });
-        assertRegularFile(opened, artifactPath);
-        const openedMetadata = fileMetadata(opened);
-        assertMetadataEqual(pathInfo, openedMetadata, artifactPath, expected);
-        if (expected)
-            assertMetadataEqual(expected, openedMetadata, artifactPath, expected);
-        if (openedMetadata.size > maxFileBytes)
-            throw freezeError("static_observation_size_limit", artifactPath);
-        const content = await readAndHashBounded(handle, artifactPath, maxFileBytes, retainBytes);
-        const afterRead = fileMetadata(await handle.stat({ bigint: true }));
-        assertMetadataEqual(openedMetadata, afterRead, artifactPath, expected);
-        const pathAfter = fileMetadata(await lstat(absolute, { bigint: true }).catch((error) => {
-            throw freezeError(expected
-                ? "static_observation_changed_by_runner"
-                : "static_observation_not_in_pre_run_snapshot", artifactPath, nodeErrorCode(error));
-        }));
-        assertMetadataEqual(afterRead, pathAfter, artifactPath, expected);
-        const canonicalAfter = await realpath(absolute);
-        assertContained(canonicalRoot, canonicalAfter, artifactPath);
-        if (canonicalAfter !== canonicalFile)
-            throw freezeError(expected
-                ? "static_observation_changed_by_runner"
-                : "static_observation_symlink_not_allowed", artifactPath, "realpath_changed");
-        return {
-            identity: {
-                ...openedMetadata,
-                content_sha256: content.sha256,
-            },
-            bytes: content.bytes,
-        };
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function inspectNoFollowPath(root, artifactPath, expected) {
-    let current = root;
-    const segments = artifactPath.split("/");
-    for (const [index, segment] of segments.entries()) {
-        current = path.join(current, segment);
-        const info = await lstat(current, { bigint: true }).catch((error) => {
-            throw freezeError(expected
-                ? "static_observation_changed_by_runner"
-                : "static_observation_not_in_pre_run_snapshot", artifactPath, nodeErrorCode(error));
-        });
-        if (info.isSymbolicLink())
-            throw freezeError(expected
-                ? "static_observation_changed_by_runner"
-                : "static_observation_symlink_not_allowed", artifactPath, "symbolic_link");
-        if (index < segments.length - 1) {
-            if (!info.isDirectory())
-                throw freezeError(expected
-                    ? "static_observation_changed_by_runner"
-                    : "static_observation_parent_not_directory", artifactPath);
-            continue;
-        }
-        assertRegularFile(info, artifactPath);
-        return fileMetadata(info);
-    }
-    throw freezeError("static_observation_path_escape", artifactPath);
-}
-function manifestMembership(manifest, artifactPath) {
-    const matches = manifest.files.filter((entry) => entry.path === artifactPath);
-    if (!matches.length)
-        throw freezeError("static_observation_not_in_pre_run_snapshot", artifactPath);
-    if (matches.length !== 1)
-        throw freezeError("static_observation_manifest_invalid", artifactPath);
-    const entry = matches[0];
-    if (!isManifestRegularFile(entry))
-        throw freezeError("static_observation_not_regular_file", artifactPath);
-    return {
-        path: entry.path,
-        mode: entry.mode,
-        declared_size: entry.size,
-        manifest_object_identity: entry.sha256,
-    };
-}
-function isManifestRegularFile(entry) {
-    return (entry.mode & 0o170000) === 0o100000;
-}
-function normalizeStaticArtifactPath(value) {
-    try {
-        return normalizeObservationArtifactPath(value);
-    }
-    catch {
-        throw freezeError("static_observation_path_escape", value);
-    }
-}
-function assertRegularFile(info, artifactPath) {
-    if (info.isSymbolicLink())
-        throw freezeError("static_observation_symlink_not_allowed", artifactPath);
-    if (!info.isFile())
-        throw freezeError("static_observation_not_regular_file", artifactPath);
-    if (info.nlink > 1n)
-        throw freezeError("static_observation_hardlink_not_allowed", artifactPath);
-}
-function fileMetadata(info) {
-    return {
-        device: info.dev.toString(),
-        inode: info.ino.toString(),
-        mode: Number(info.mode),
-        links: info.nlink.toString(),
-        size: Number(info.size),
-        modified_time_ns: info.mtimeNs.toString(),
-        changed_time_ns: info.ctimeNs.toString(),
-        birth_time_ns: info.birthtimeNs.toString(),
-    };
-}
-function assertMetadataEqual(left, right, artifactPath, postRunExpected) {
-    const mismatch = STATIC_OBSERVATION_METADATA_KEYS.find((key) => left[key] !== right[key]);
-    if (!mismatch)
-        return;
-    throw freezeError(postRunExpected
-        ? "static_observation_changed_by_runner"
-        : "static_observation_not_in_pre_run_snapshot", artifactPath, `file_identity.${mismatch}`);
-}
-async function readAndHashBounded(handle, artifactPath, limit, retainBytes) {
-    const buffer = Buffer.allocUnsafe(Math.min(65_536, limit + 1));
-    const chunks = [];
-    const hash = createHash("sha256");
-    let offset = 0;
-    while (true) {
-        const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, offset);
-        if (!bytesRead)
-            break;
-        offset += bytesRead;
-        if (offset > limit)
-            throw freezeError("static_observation_size_limit", artifactPath);
-        const chunk = buffer.subarray(0, bytesRead);
-        hash.update(chunk);
-        if (retainBytes)
-            chunks.push(Buffer.from(chunk));
-    }
-    return {
-        bytes: retainBytes ? Uint8Array.from(Buffer.concat(chunks, offset)) : null,
-        sha256: hash.digest("hex"),
-    };
-}
-function observationInputFileLimit(value) {
-    const limit = value;
-    if (!Number.isSafeInteger(limit) || limit <= 0)
-        throw new Error("observation_input_freeze_file_limit_invalid");
-    return limit;
-}
-function assertContained(root, target, artifactPath) {
-    const relative = path.relative(root, target);
-    if (relative === "" ||
-        relative === ".." ||
-        relative.startsWith(`..${path.sep}`) ||
-        path.isAbsolute(relative))
-        throw freezeError("static_observation_path_escape", artifactPath);
-}
-function assertArtifactCount(budget, artifactPath) {
-    if (budget &&
-        !budget.seen_artifact_paths.has(artifactPath) &&
-        budget.seen_artifact_paths.size >=
-            JSON_POINTER_EXACT_LIMITS.max_artifacts_per_check)
-        throw new Error("observation_artifact_count_limit");
-}
-function assertObservationInputCount(budget, artifactPath) {
-    if (budget &&
-        !budget.seen_artifact_paths.has(artifactPath) &&
-        budget.seen_artifact_paths.size >= budget.max_artifacts)
-        throw new Error("observation_input_freeze_artifact_count_limit");
-}
-function accountForObservationInput(budget, artifactPath, bytes) {
-    if (!budget || budget.seen_artifact_paths.has(artifactPath))
-        return;
-    if (budget.total_artifact_bytes + bytes > budget.max_total_artifact_bytes)
-        throw new Error("observation_input_freeze_total_size_limit");
-    budget.seen_artifact_paths.add(artifactPath);
-    budget.total_artifact_bytes += bytes;
-}
-function accountForArtifact(budget, artifactPath, bytes) {
-    if (!budget || budget.seen_artifact_paths.has(artifactPath))
-        return;
-    if (budget.total_artifact_bytes + bytes >
-        JSON_POINTER_EXACT_LIMITS.max_total_artifact_bytes)
-        throw new Error("observation_artifact_total_size_limit");
-    budget.seen_artifact_paths.add(artifactPath);
-    budget.total_artifact_bytes += bytes;
-}
-function freezeManifestMembership(value) {
-    return Object.freeze({ ...value });
-}
-function freezeFileIdentity(value) {
-    return Object.freeze({ ...value });
-}
-function freezeError(code, artifactPath, causeCode = null) {
-    return new StaticObservationFreezeError(code, artifactPath, causeCode);
-}
-function openFailureCode(error) {
-    return nodeErrorCode(error) === "ENOENT"
-        ? "static_observation_not_in_pre_run_snapshot"
-        : nodeErrorCode(error) === "ELOOP"
-            ? "static_observation_symlink_not_allowed"
-            : "static_observation_not_regular_file";
-}
-function freezeCause(error) {
-    if (error instanceof StaticObservationFreezeError)
-        return error.cause_code ?? error.code;
-    return nodeErrorCode(error);
-}
-function nodeErrorCode(error) {
-    return (error?.code ??
-        (error instanceof Error ? error.message : String(error)));
-}

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

@@ -1,24 +0,0 @@
-import type { CompiledDeliveryContractV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2, ProgressRecordV2, StageStatusV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-interface StatusProjectionInputV2 {
-    compiled: CompiledDeliveryContractV2;
-    manifest: WorkspaceManifestV2;
-    stale: string[];
-    progress: Record<string, ProgressRecordV2>;
-    receipt: FinalReceiptV2 | null;
-    receiptError: string | null;
-}
-export type AuditGateStatusV2 = "no_final_gate" | "last_gate_passed" | "last_gate_failed" | "last_gate_blocked" | "last_gate_inputs_stale";
-export declare function projectDeliveryStatus(input: StatusProjectionInputV2): {
-    finalResult: AuditGateStatusV2;
-    finalWorkflowStatus: FinalReceiptV2["workflow_status"] | null;
-    targetState: FinalReceiptV2["target_state"];
-    outcomes: Record<string, OutcomeStatusV2>;
-    stages: Record<string, StageStatusV2>;
-    readyStages: string[];
-    readyOutcomes: string[];
-    needsReverify: string[];
-    progressPassing: string[];
-    progressFailing: string[];
-    findings: LongTaskFindingV2[];
-};
-export {};

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

@@ -1,180 +0,0 @@
-import { outcomeResultExternallyBlocked } from "./long-task-claims.js";
-import { progressRecordFresh } from "./long-task-progress.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 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"
-            : outcomeResultExternallyBlocked(input.compiled, outcome.key) ||
-                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, 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 === "machine_accepted_external_pending")
-        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 === "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

@@ -1,57 +0,0 @@
-import type { AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
-import type { ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2, 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_machine_authority";
-    native_goal_effect: "none";
-    final_result: AuditGateStatusV2;
-    final_workflow_status: FinalReceiptV2["workflow_status"] | null;
-    external_confirmations: ExternalConfirmationV2[];
-    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[];
-    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[];
-    target_profile?: TargetProfileV2;
-    target_state?: FinalReceiptV2["target_state"];
-    stage_results?: FinalReceiptV2["stage_results"];
-    acceptance_scope?: "declared_machine_authority";
-    native_goal_effect?: "none";
-    message?: string;
-}
-export interface CloseDeliveryResultV2 {
-    status: "closed";
-    workflow_status: Extract<FinalReceiptV2["workflow_status"], "machine_accepted" | "machine_accepted_external_pending">;
-    external_confirmations: ExternalConfirmationV2[];
-    target_profile: TargetProfileV2;
-    target_state: FinalReceiptV2["target_state"];
-    stage_results: FinalReceiptV2["stage_results"];
-    acceptance_scope: "declared_machine_authority";
-    closed_scope: "machine_authority";
-    native_goal_effect: "none";
-}
-export declare function closeDeliveryTask(workdir: string): Promise<CloseDeliveryResultV2>;