project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-verification-preview.d.ts

@@ -1,65 +0,0 @@
-import type { CompiledCheckV2, CompiledDeliveryContractV2 } from "./long-task-delivery-types.js";
-export interface VerificationExecutionPreviewV1 {
-    schema_version: "long-task-verification-preview-v1";
-    compiled_identity: string;
-    authority_revision: number;
-    acceptance_authorized: false;
-    executes_checks: false;
-    writes_progress: false;
-    selected_outcome: string | null;
-    selected_check: string | null;
-    main_raw_executions: MainRawExecutionPreviewV1[];
-    counterfactual_executions: CounterfactualExecutionPreviewV1[];
-    summary: {
-        selected_checks: number;
-        unique_main_runner_invocations: number;
-        counterfactual_runner_invocation_upper_bound: number;
-        declared_runner_invocation_upper_bound: number;
-        declared_command_attempt_upper_bound: number;
-    };
-    limitations: string[];
-}
-interface MainRawExecutionPreviewV1 {
-    raw_execution_identity: string;
-    check_refs: string[];
-    execution_target: CompiledCheckV2["execution_target"];
-    execution_target_definition: CompiledCheckV2["execution_target_definition"];
-    runner: RunnerPreviewV1;
-    environment_requirements: CompiledCheckV2["environment_requirements"];
-}
-interface CounterfactualExecutionPreviewV1 {
-    scope: "global" | "outcome";
-    outcome_key: string | null;
-    control_key: string;
-    check_ref: string;
-    raw_execution_identity: string;
-    mutation: {
-        type: "remove_paths";
-        paths: string[];
-    } | {
-        type: "replace_file";
-        path: string;
-        fixture_path: string;
-    } | {
-        type: "replace_json_value";
-        path: string;
-        pointer: string;
-        value: unknown;
-    } | {
-        type: "replace_text";
-        path: string;
-        match: string;
-        replacement: string;
-    };
-    runner: RunnerPreviewV1;
-}
-type RunnerPreviewV1 = Pick<CompiledCheckV2["runner"], "type" | "target" | "argv" | "cwd" | "timeout_ms" | "effect" | "retry_policy" | "idempotent" | "resolved_cwd" | "resolved_target" | "definition_sha256">;
-export declare function previewVerificationExecution(workdirInput: string, selection?: {
-    outcome?: string;
-    check?: string;
-}): Promise<VerificationExecutionPreviewV1>;
-export declare function projectVerificationExecutionPreview(compiled: CompiledDeliveryContractV2, authorityRevision: number, selection?: {
-    outcome?: string;
-    check?: string;
-}): VerificationExecutionPreviewV1;
-export {};

package/dist/lib/long-task-verification-preview.js

@@ -1,120 +0,0 @@
-import path from "node:path";
-import { loadActiveLongTaskAuthority } from "./long-task-state.js";
-import { selectChecks } from "./long-task-verifier-v2.js";
-import { repositoryRoot } from "./long-task-workspace.js";
-export async function previewVerificationExecution(workdirInput, selection = {}) {
-    const repository = await repositoryRoot(process.cwd());
-    const active = (await loadActiveLongTaskAuthority(repository, { migrate_legacy: true })).authority;
-    if (!active)
-        throw new Error("active_task_missing");
-    if (active.workdir !== path.resolve(workdirInput))
-        throw new Error("active_task_workdir_mismatch");
-    return projectVerificationExecutionPreview(active.authority_snapshot, active.authority_revision, selection);
-}
-export function projectVerificationExecutionPreview(compiled, authorityRevision, selection = {}) {
-    const selected = selectChecks(compiled, selection);
-    const mainRawExecutions = mainExecutionPreviews(selected);
-    const counterfactualExecutions = counterfactualExecutionPreviews(compiled, selected);
-    const declaredRunnerInvocationUpperBound = mainRawExecutions.length + counterfactualExecutions.length;
-    return {
-        schema_version: "long-task-verification-preview-v1",
-        compiled_identity: compiled.compiled_identity,
-        authority_revision: authorityRevision,
-        acceptance_authorized: false,
-        executes_checks: false,
-        writes_progress: false,
-        selected_outcome: selection.outcome ?? null,
-        selected_check: selection.check ?? null,
-        main_raw_executions: mainRawExecutions,
-        counterfactual_executions: counterfactualExecutions,
-        summary: {
-            selected_checks: selected.length,
-            unique_main_runner_invocations: mainRawExecutions.length,
-            counterfactual_runner_invocation_upper_bound: counterfactualExecutions.length,
-            declared_runner_invocation_upper_bound: declaredRunnerInvocationUpperBound,
-            declared_command_attempt_upper_bound: [
-                ...mainRawExecutions.map((entry) => entry.runner),
-                ...counterfactualExecutions.map((entry) => entry.runner),
-            ].reduce((total, runner) => total + maximumAttempts(runner), 0),
-        },
-        limitations: [
-            "This preview does not evaluate current-snapshot pre-run findings; verification may stop before invoking a runner.",
-            "Counts describe Harness runner invocations and declared retry attempts, not subprocesses, builds, elapsed time, or work performed internally by a project runner.",
-            "The preview is not verification evidence and cannot authorize acceptance.",
-        ],
-    };
-}
-function mainExecutionPreviews(checks) {
-    const groups = new Map();
-    for (const check of checks) {
-        const existing = groups.get(check.raw_execution_identity) ?? [];
-        existing.push(check);
-        groups.set(check.raw_execution_identity, existing);
-    }
-    return [...groups.entries()]
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([rawExecutionIdentity, groupedChecks]) => {
-        const check = groupedChecks[0];
-        return {
-            raw_execution_identity: rawExecutionIdentity,
-            check_refs: groupedChecks.map(checkRef).sort(),
-            execution_target: check.execution_target,
-            execution_target_definition: check.execution_target_definition,
-            runner: runnerPreview(check),
-            environment_requirements: check.environment_requirements,
-        };
-    });
-}
-function counterfactualExecutionPreviews(compiled, checks) {
-    const selected = new Map(checks.map((check) => [checkRef(check), check]));
-    const result = [];
-    for (const control of compiled.global.acceptance.counterfactual_controls) {
-        const check = selected.get(`GLOBAL:${control.check_key}`);
-        if (check)
-            result.push({
-                scope: "global",
-                outcome_key: null,
-                control_key: control.key,
-                check_ref: checkRef(check),
-                raw_execution_identity: check.raw_execution_identity,
-                mutation: control.mutation,
-                runner: runnerPreview(check),
-            });
-    }
-    for (const outcome of compiled.outcomes)
-        for (const control of outcome.acceptance.counterfactual_controls) {
-            const check = selected.get(`${outcome.key}:${control.check_key}`);
-            if (check)
-                result.push({
-                    scope: "outcome",
-                    outcome_key: outcome.key,
-                    control_key: control.key,
-                    check_ref: checkRef(check),
-                    raw_execution_identity: check.raw_execution_identity,
-                    mutation: control.mutation,
-                    runner: runnerPreview(check),
-                });
-        }
-    return result.sort((left, right) => `${left.check_ref}:${left.control_key}`.localeCompare(`${right.check_ref}:${right.control_key}`));
-}
-function checkRef(check) {
-    return `${check.outcome_key ?? "GLOBAL"}:${check.key}`;
-}
-function runnerPreview(check) {
-    return {
-        type: check.runner.type,
-        target: check.runner.target,
-        argv: check.runner.argv,
-        cwd: check.runner.cwd,
-        timeout_ms: check.runner.timeout_ms,
-        effect: check.runner.effect,
-        retry_policy: check.runner.retry_policy,
-        idempotent: check.runner.idempotent,
-        resolved_cwd: check.runner.resolved_cwd,
-        resolved_target: check.runner.resolved_target,
-        definition_sha256: check.runner.definition_sha256,
-    };
-}
-function maximumAttempts(runner) {
-    return runner.retry_policy === "transient_once" ? 2 : 1;
-}

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

@@ -1,12 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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.bundle_sha256 !== next.bundle_sha256)
-        changed.push("<bundle>");
-    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-dependency-closure.d.ts

@@ -1,3 +0,0 @@
-import type { WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function freezeLocalVerifierDependencyClosure(repository: string, roots: Iterable<string>, manifest: WorkspaceManifestV2, runtimeOwnedPatterns?: readonly string[]): Promise<Record<string, string>>;
-export declare function packageScriptVerifierRoots(script: string, packageFile: string, manifest: WorkspaceManifestV2): string[];

package/dist/lib/long-task-verifier-dependency-closure.js

@@ -1,183 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { classifyRepositoryPatternOverlap, matchesRepoPattern, } from "./long-task-paths.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { sha256Hex } from "./strict-codec.js";
-const SCRIPT_EXTENSIONS = new Set([
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-]);
-const RESOLUTION_EXTENSIONS = [
-    "",
-    ".js",
-    ".mjs",
-    ".cjs",
-    ".jsx",
-    ".ts",
-    ".mts",
-    ".cts",
-    ".tsx",
-    ".json",
-];
-export async function freezeLocalVerifierDependencyClosure(repository, roots, manifest, runtimeOwnedPatterns = []) {
-    const available = new Set(manifest.files.map((file) => file.path));
-    const result = {};
-    const queued = [...new Set(roots)].filter((file) => SCRIPT_EXTENSIONS.has(path.posix.extname(file).toLowerCase()));
-    const visited = new Set();
-    while (queued.length) {
-        const relative = queued.shift();
-        if (visited.has(relative))
-            continue;
-        visited.add(relative);
-        if (!available.has(relative))
-            throw new Error(`verification_dependency_not_found:${relative}`);
-        const absolute = await assertProtectedRepositoryFile(repository, path.join(repository, ...relative.split("/")), "verification_dependency");
-        const bytes = await readFile(absolute);
-        result[relative] = sha256Hex(bytes);
-        const source = bytes.toString("utf8");
-        if (hasNonLiteralLoader(source))
-            throw new Error(`verification_dependency_dynamic_unresolved:${relative}`);
-        for (const specifier of staticSpecifiers(source)) {
-            if (!isLocalSpecifier(specifier))
-                continue;
-            const dependency = resolveLocalSpecifier(relative, specifier, available);
-            const unresolvedBase = localSpecifierBase(relative, specifier);
-            if ((dependency &&
-                runtimeOwnedPatterns.some((pattern) => matchesRepoPattern(dependency, pattern))) ||
-                (!dependency &&
-                    unresolvedBase &&
-                    runtimeOwnedPatterns.some((pattern) => runtimePatternOwns(unresolvedBase, pattern))))
-                continue;
-            if (!dependency)
-                throw new Error(`verification_dependency_not_found:${relative}:${specifier}`);
-            if (SCRIPT_EXTENSIONS.has(path.posix.extname(dependency).toLowerCase()))
-                queued.push(dependency);
-            else {
-                const dependencyFile = await assertProtectedRepositoryFile(repository, path.join(repository, ...dependency.split("/")), "verification_dependency");
-                result[dependency] = sha256Hex(await readFile(dependencyFile));
-            }
-        }
-    }
-    return sortRecord(result);
-}
-export function packageScriptVerifierRoots(script, packageFile, manifest) {
-    const tokens = staticPackageScriptTokens(script);
-    if (!tokens.length || !["node", "node.exe"].includes(tokens[0].toLowerCase()))
-        throw new Error("package_script_dependency_closure_unresolved:node_entry_required");
-    if (tokens.length < 2 || tokens[1].startsWith("-"))
-        throw new Error("package_script_dependency_closure_unresolved:static_entry_required");
-    const packageDirectory = path.posix.dirname(packageFile);
-    const candidate = path.posix.normalize(path.posix.join(packageDirectory === "." ? "" : packageDirectory, tokens[1]));
-    if (candidate === ".." ||
-        candidate.startsWith("../") ||
-        !manifest.files.some((file) => file.path === candidate) ||
-        !SCRIPT_EXTENSIONS.has(path.posix.extname(candidate).toLowerCase()))
-        throw new Error(`package_script_dependency_closure_unresolved:entry_not_found:${tokens[1]}`);
-    return [candidate];
-}
-function staticPackageScriptTokens(script) {
-    const tokens = [];
-    let current = "";
-    let quote = null;
-    for (let index = 0; index < script.length; index += 1) {
-        const character = script[index];
-        if (!quote && /\s/u.test(character)) {
-            if (current) {
-                tokens.push(current);
-                current = "";
-            }
-            continue;
-        }
-        if (character === "'" || character === '"') {
-            if (!quote) {
-                quote = character;
-                continue;
-            }
-            if (quote === character) {
-                quote = null;
-                continue;
-            }
-        }
-        if ((!quote && /[&|;<>()]/u.test(character)) ||
-            character === "`" ||
-            character === "$" ||
-            character === "%" ||
-            character === "!")
-            throw new Error("package_script_dependency_closure_unresolved:dynamic_shell_syntax");
-        current += character;
-    }
-    if (quote)
-        throw new Error("package_script_dependency_closure_unresolved:unterminated_quote");
-    if (current)
-        tokens.push(current);
-    return tokens;
-}
-function staticSpecifiers(source) {
-    const result = [];
-    const patterns = [
-        /\b(?:import|export)\s+(?:[^"'`]*?\s+from\s+)?["']([^"']+)["']/gu,
-        /\bimport\s*\(\s*["']([^"']+)["']\s*\)/gu,
-        /\brequire\s*\(\s*["']([^"']+)["']\s*\)/gu,
-        /\brequire\.resolve\s*\(\s*["']([^"']+)["']\s*\)/gu,
-        /\bmodule\.require\s*\(\s*["']([^"']+)["']\s*\)/gu,
-        /\bnew\s+URL\s*\(\s*["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)/gu,
-    ];
-    for (const pattern of patterns)
-        for (const match of source.matchAll(pattern))
-            result.push(match[1]);
-    return [...new Set(result)];
-}
-function hasNonLiteralLoader(source) {
-    return (/\b(?:import|require)\s*\(\s*(?!["'])[^)]/u.test(source) ||
-        /\brequire\.resolve\s*\(\s*(?!["'])[^)]/u.test(source) ||
-        /\bmodule\.require\s*\(\s*(?!["'])[^)]/u.test(source) ||
-        /\bnew\s+URL\s*\(\s*(?!["'])[^,]+,\s*import\.meta\.url\s*\)/u.test(source) ||
-        /\bcreateRequire\b/u.test(source));
-}
-function isLocalSpecifier(specifier) {
-    return (specifier.startsWith("./") ||
-        specifier.startsWith("../") ||
-        specifier.startsWith("/"));
-}
-function resolveLocalSpecifier(importer, specifier, available) {
-    const base = localSpecifierBase(importer, specifier);
-    if (!base)
-        return null;
-    if (base.startsWith("../") || base === "..")
-        return null;
-    for (const extension of RESOLUTION_EXTENSIONS) {
-        const candidate = `${base}${extension}`;
-        if (available.has(candidate))
-            return candidate;
-    }
-    for (const extension of RESOLUTION_EXTENSIONS.slice(1)) {
-        const candidate = `${base}/index${extension}`;
-        if (available.has(candidate))
-            return candidate;
-    }
-    return null;
-}
-function localSpecifierBase(importer, specifier) {
-    const base = specifier.startsWith("/")
-        ? specifier.slice(1)
-        : path.posix.normalize(path.posix.join(path.posix.dirname(importer), specifier));
-    const canonicalBase = base.replace(/\/+$/u, "") || ".";
-    return canonicalBase === ".." || canonicalBase.startsWith("../")
-        ? null
-        : canonicalBase;
-}
-function runtimePatternOwns(base, pattern) {
-    const directoryPattern = base === "." ? "**" : `${base}/**`;
-    return ((base !== "." && matchesRepoPattern(base, pattern)) ||
-        classifyRepositoryPatternOverlap(directoryPattern, pattern).status ===
-            "proven_overlap");
-}
-function sortRecord(value) {
-    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
-}

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

@@ -1,2 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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[];
-export declare function selectChecks(compiled: CompiledDeliveryContractV2, selection: {
-    outcome?: string;
-    check?: string;
-}): CompiledCheckV2[];