project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,330 +0,0 @@
-import { deliveryCompileFreshness } from "./long-task-freshness.js";
-import { assertVerifierAuthorityCurrent } from "./long-task-freshness.js";
-import { enrichCheckResultFindings, enrichFinding, } from "./long-task-finding-context.js";
-import { executeCheckRunner } from "./long-task-check-runner.js";
-import { prepareExecutionObservationUniverse } from "./long-task-execution-observation.js";
-import { evaluateCheckEvidence, evaluateGlobalCounterfactuals, evaluateOutcomeCounterfactuals, } from "./long-task-evidence-v2.js";
-import { matchesRepoPattern } from "./long-task-paths.js";
-import { activeAuthorityIdentityMatches, loadActiveLongTaskAuthority, writeProgressRecord, } from "./long-task-state.js";
-import { createProgressRecord } from "./long-task-progress.js";
-import { changedWorkspacePaths, createWorkspaceSnapshot, repositoryRoot, } from "./long-task-workspace.js";
-import { classifyWorkspaceScope, protectedWorkspacePaths, } from "./long-task-workspace-scope.js";
-export async function verifyDeliveryContract(workdir, 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 !== (await resolved(workdir)))
-        throw new Error("active_task_workdir_mismatch");
-    await assertVerifierAuthorityCurrent(repository, active.verifier_identity);
-    const compiled = active.authority_snapshot;
-    const expectedAuthority = {
-        task_id: active.task_id,
-        authority_revision: active.authority_revision,
-        compiled_identity: active.active_authority_identity,
-        worktree_identity: active.worktree_identity,
-    };
-    const selected = selectChecks(compiled, selection);
-    const snapshot = await createWorkspaceSnapshot(compiled.repository_root, compiled.workdir, `verify-${compiled.task.id}`);
-    try {
-        const run = await runDeliveryChecks(compiled, snapshot, selected, true);
-        const records = run.check_results.map((result) => {
-            const check = selected.find((item) => item.internal_id === result.internal_id);
-            if (!check)
-                throw new Error(`compiled_check_not_found:${result.internal_id}`);
-            return createProgressRecord(compiled, snapshot.manifest, check, result);
-        });
-        let authorityChanged = false;
-        try {
-            const current = (await loadActiveLongTaskAuthority(repository)).authority;
-            authorityChanged =
-                !current || !activeAuthorityIdentityMatches(current, expectedAuthority);
-        }
-        catch {
-            authorityChanged = true;
-        }
-        if (authorityChanged) {
-            run.findings.push({
-                code: "active_authority_changed_during_verify",
-                outcome_key: null,
-                check_key: null,
-                message: "Active Authority changed while targeted verification was running.",
-                next_action: "Discard the stale progress and rerun verification against the active Authority Revision.",
-            });
-            return {
-                schema_version: "long-task-targeted-progress-v2",
-                compiled_identity: compiled.compiled_identity,
-                snapshot_sha256: snapshot.manifest.snapshot_sha256,
-                acceptance_authorized: false,
-                selected_outcome: selection.outcome ?? null,
-                selected_check: selection.check ?? null,
-                updated_progress_records: [],
-                check_results: run.check_results,
-                findings: run.findings,
-                completed_at: new Date().toISOString(),
-            };
-        }
-        await Promise.all(records.map((record) => writeProgressRecord(workdir, record)));
-        return {
-            schema_version: "long-task-targeted-progress-v2",
-            compiled_identity: compiled.compiled_identity,
-            snapshot_sha256: snapshot.manifest.snapshot_sha256,
-            acceptance_authorized: false,
-            selected_outcome: selection.outcome ?? null,
-            selected_check: selection.check ?? null,
-            updated_progress_records: records.map((record) => record.check_internal_id),
-            check_results: run.check_results,
-            findings: run.findings,
-            completed_at: new Date().toISOString(),
-        };
-    }
-    finally {
-        await snapshot.dispose();
-    }
-}
-async function resolved(workdir) {
-    return (await import("node:path")).default.resolve(workdir);
-}
-export async function runDeliveryChecks(compiled, snapshot, checks, includeCounterfactuals, finalGate = false) {
-    const observationAuthorityPaths = [
-        compiled.contract_file,
-        ...Object.keys(compiled.contract_files),
-        ...Object.keys(compiled.source_hashes),
-        ...compiled.context_snapshot.files,
-    ];
-    const findings = await preRunFindings(compiled, snapshot.manifest);
-    if (finalGate)
-        findings.push(...finalPathFindings(compiled, snapshot.manifest));
-    if (findings.length)
-        return {
-            snapshot: snapshot.manifest,
-            check_results: [],
-            findings: findings.map((finding) => enrichFinding(compiled, finding)),
-        };
-    const rawExecutions = new Map();
-    const completeChecks = allCompiledChecks(compiled);
-    const selectedExecutionGroups = rawExecutionGroups(checks);
-    const completeExecutionGroups = selectedExecutionGroups.map((group) => completeChecks.filter((check) => check.raw_execution_identity === group[0].raw_execution_identity));
-    const preparedExecutionGroups = await prepareExecutionObservationUniverse({
-        groups: completeExecutionGroups,
-        snapshot_root: snapshot.root,
-        workspace_manifest: snapshot.manifest,
-        protected_authority_paths: observationAuthorityPaths,
-    });
-    try {
-        const pending = [];
-        for (const [index, group] of selectedExecutionGroups.entries()) {
-            const prepared = preparedExecutionGroups[index];
-            if (!prepared)
-                throw new Error("raw_execution_group_prepare_missing");
-            pending.push({
-                raw_execution_identity: group[0].raw_execution_identity,
-                raw: await executeCheckRunner(group[0], prepared.execution_root, prepared.runner_context),
-                prepared,
-            });
-        }
-        const finalized = await Promise.all(pending.map(async (entry) => ({
-            raw_execution_identity: entry.raw_execution_identity,
-            raw: await entry.prepared.finalize(entry.raw),
-        })));
-        for (const entry of finalized)
-            rawExecutions.set(entry.raw_execution_identity, entry.raw);
-    }
-    finally {
-        await Promise.all(preparedExecutionGroups.map((prepared) => prepared.dispose()));
-    }
-    const mainCheckResults = [];
-    for (const check of checks) {
-        const raw = rawExecutions.get(check.raw_execution_identity);
-        if (!raw)
-            throw new Error("raw_execution_group_result_missing");
-        const outcome = check.outcome_key
-            ? compiled.outcomes.find((item) => item.key === check.outcome_key)
-            : undefined;
-        mainCheckResults.push(await evaluateCheckEvidence(check, raw, snapshot.root, outcome, observationAuthorityPaths));
-    }
-    const counterfactualFindings = [];
-    if (includeCounterfactuals) {
-        // Counterfactual sensitivity is a closure condition for an otherwise
-        // passing proof. A failed or externally blocked owning Check already
-        // blocks acceptance; rerunning its oracle in a mutated sandbox can only
-        // obscure that primary status (for example, by turning a typed external
-        // blocker into an integrity failure).
-        const passingCheckIds = new Set(mainCheckResults
-            .filter((result) => result.status === "passed")
-            .map((result) => result.internal_id));
-        const selectedGlobalCheckKeys = new Set(checks
-            .filter((check) => check.outcome_key === null &&
-            passingCheckIds.has(check.internal_id))
-            .map((check) => check.key));
-        if (selectedGlobalCheckKeys.size)
-            counterfactualFindings.push(...(await evaluateGlobalCounterfactuals(compiled, snapshot.root, selectedGlobalCheckKeys, snapshot.manifest, mainCheckResults, rawExecutions, completeChecks)));
-        const outcomeKeys = new Set(checks
-            .map((check) => check.outcome_key)
-            .filter((key) => Boolean(key)));
-        for (const outcome of compiled.outcomes.filter((item) => outcomeKeys.has(item.key))) {
-            const selectedKeys = new Set(checks
-                .filter((check) => check.outcome_key === outcome.key &&
-                passingCheckIds.has(check.internal_id))
-                .map((check) => check.key));
-            counterfactualFindings.push(...(await evaluateOutcomeCounterfactuals({
-                ...outcome,
-                acceptance: {
-                    ...outcome.acceptance,
-                    counterfactual_controls: outcome.acceptance.counterfactual_controls.filter((control) => selectedKeys.has(control.check_key)),
-                },
-            }, snapshot.root, snapshot.manifest, observationAuthorityPaths, mainCheckResults, rawExecutions, completeChecks)));
-        }
-    }
-    const unassignedCounterfactuals = counterfactualFindings.filter((finding) => !mainCheckResults.some((result) => findingBelongsToCheck(finding, result)));
-    const unassignedFinding = unassignedCounterfactuals.length
-        ? unassignedCounterfactualFinding(unassignedCounterfactuals)
-        : null;
-    const checkResults = applyCounterfactualFindings(mainCheckResults, counterfactualFindings, unassignedFinding).map((result) => enrichCheckResultFindings(compiled, result));
-    findings.push(...checkResults.flatMap((result) => result.findings));
-    if (unassignedFinding && !checkResults.length)
-        findings.push(unassignedFinding);
-    return {
-        snapshot: snapshot.manifest,
-        check_results: checkResults,
-        findings: findings.map((finding) => enrichFinding(compiled, finding)),
-    };
-}
-function rawExecutionGroups(checks) {
-    const groups = new Map();
-    for (const check of checks) {
-        const group = groups.get(check.raw_execution_identity);
-        if (group)
-            group.push(check);
-        else
-            groups.set(check.raw_execution_identity, [check]);
-    }
-    return [...groups.values()];
-}
-function applyCounterfactualFindings(checkResults, findings, unassignedFinding) {
-    return checkResults.map((result, index) => {
-        const projected = findings.filter((finding) => findingBelongsToCheck(finding, result));
-        const invariantFindings = unassignedFinding && index === 0 ? [unassignedFinding] : [];
-        const projectedFindings = [...projected, ...invariantFindings];
-        if (!projectedFindings.length)
-            return result;
-        return {
-            ...result,
-            status: result.status === "passed" ? "invalid_evidence" : result.status,
-            claim_proofs: [],
-            findings: [...result.findings, ...projectedFindings],
-        };
-    });
-}
-function findingBelongsToCheck(finding, result) {
-    return (finding.check_key !== null &&
-        finding.check_key === result.check_key &&
-        finding.outcome_key === result.outcome_key);
-}
-function unassignedCounterfactualFinding(actual) {
-    return {
-        code: "counterfactual_finding_unassigned",
-        outcome_key: null,
-        check_key: null,
-        message: "A Counterfactual Finding could not be assigned to its owning Check Result.",
-        actual,
-        next_action: "Repair the Counterfactual evaluator ownership invariant before trusting verification progress.",
-    };
-}
-function finalPathFindings(compiled, manifest) {
-    const findings = [];
-    for (const check of allCompiledChecks(compiled))
-        for (const pattern of check.expected_output_paths)
-            if (!manifest.files.some((file) => matchesRepoPattern(file.path, pattern)))
-                findings.push({
-                    code: "expected_output_path_missing",
-                    outcome_key: check.outcome_key,
-                    check_key: check.key,
-                    message: `Expected output path did not exist: ${pattern}`,
-                    expected: pattern,
-                    next_action: "Create the declared output and rerun verification.",
-                });
-    for (const outcome of compiled.outcomes)
-        for (const binding of outcome.technical.bindings)
-            if (binding.existence === "planned" &&
-                !plannedBindingRequiredPatterns(binding).every((pattern) => manifest.files.some((file) => matchesRepoPattern(file.path, pattern))) &&
-                !outcome.acceptance.checks.some((check) => (check.observation_authorities ?? []).some((authority) => authority.authority === "package_static_json_exact" &&
-                    authority.carrier_refs.some((carrier) => carrier.binding_ref === `${outcome.key}.${binding.key}`))))
-                findings.push({
-                    code: "binding_missing",
-                    outcome_key: outcome.key,
-                    check_key: null,
-                    claim_keys: outcome.generated_claims.some((claim) => claim.local_key === `obligation.${binding.key}`)
-                        ? [`obligation.${binding.key}`]
-                        : [],
-                    message: `Planned binding is missing: ${binding.target}`,
-                    expected: binding.carrier_paths,
-                    next_action: "Implement the declared binding and rerun verification.",
-                });
-    for (const check of allCompiledChecks(compiled))
-        for (const runtimePath of check.process_runtime_closure
-            ?.allowed_runtime_files ?? [])
-            if (!manifest.files.some((file) => file.path === runtimePath))
-                findings.push({
-                    code: "process_runtime_input_missing",
-                    outcome_key: check.outcome_key,
-                    check_key: check.key,
-                    message: `Declared process runtime input did not exist in the Final Gate candidate: ${runtimePath}`,
-                    expected: runtimePath,
-                    next_action: "Materialize the Source-backed product root and every declared production runtime input, then rerun Final Gate.",
-                });
-    return findings;
-}
-function plannedBindingRequiredPatterns(binding) {
-    return binding.kind === "file" || binding.kind === "path_glob"
-        ? [binding.target]
-        : binding.carrier_paths;
-}
-export function allCompiledChecks(compiled) {
-    return [
-        ...compiled.global.acceptance.checks,
-        ...compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-}
-export function selectChecks(compiled, selection) {
-    const checks = allCompiledChecks(compiled);
-    if (selection.outcome &&
-        !compiled.outcomes.some((outcome) => outcome.key === selection.outcome))
-        throw new Error(`outcome_not_found:${selection.outcome}`);
-    const filtered = checks.filter((check) => (!selection.outcome || check.outcome_key === selection.outcome) &&
-        (!selection.check || check.key === selection.check));
-    if (selection.check && !filtered.length)
-        throw new Error(`check_not_found:${selection.check}`);
-    return filtered;
-}
-async function preRunFindings(compiled, current) {
-    const stale = await deliveryCompileFreshness(compiled);
-    if (stale.length)
-        return stale.map((code) => ({
-            code,
-            outcome_key: null,
-            check_key: null,
-            message: "A compiled Contract input changed.",
-            next_action: "Run ty-context long-task compile --revise after reviewing the Contract change.",
-        }));
-    const changed = changedWorkspacePaths(compiled.initial_task_base.workspace_manifest, current);
-    const classification = classifyWorkspaceScope(compiled, changed, protectedWorkspacePaths({
-        contract_files: compiled.contract_files,
-        source_hashes: compiled.source_hashes,
-        context_hashes: compiled.context_snapshot.sha256,
-        checks: allCompiledChecks(compiled),
-    }));
-    const escaped = classification.blocking_paths;
-    return escaped.length
-        ? [
-            {
-                code: "scope_escape",
-                outcome_key: null,
-                check_key: null,
-                message: `Changed paths escape the Contract boundary (forbidden: ${classification.forbidden.join(",") || "none"}; unclassified: ${classification.unclassified.join(",") || "none"}).`,
-                actual: escaped,
-                next_action: "Review risk/ownership, revise declared change paths and recompile in the same Goal.",
-            },
-        ]
-        : [];
-}

package/dist/lib/long-task-worker-selection.d.ts

@@ -1,2 +0,0 @@
-export declare const LONG_TASK_IMPLEMENTATION_AGENT = "long_task_implementation";
-export declare function selectedAgentType(toolInput: unknown): string | null;

package/dist/lib/long-task-worker-selection.js

@@ -1,7 +0,0 @@
-export const LONG_TASK_IMPLEMENTATION_AGENT = "long_task_implementation";
-export function selectedAgentType(toolInput) {
-    if (!toolInput || typeof toolInput !== "object" || Array.isArray(toolInput))
-        return null;
-    const value = toolInput.agent_type;
-    return typeof value === "string" && value.length > 0 ? value : null;
-}

package/dist/lib/long-task-workspace-manifest.d.ts

@@ -1,8 +0,0 @@
-import type { WorkspaceFingerprintV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function captureWorkspaceFingerprint(rootInput: string, excludedPrefixes?: string[]): Promise<WorkspaceFingerprintV2>;
-export declare function captureWorkspaceManifest(rootInput: string, workdirInput: string, _copyRoot?: string, additionalExcludedWorkdirs?: string[]): Promise<WorkspaceManifestV2>;
-export declare function changedWorkspacePaths(baseline: WorkspaceManifestV2, current: WorkspaceManifestV2): string[];
-export declare function changedWorkspacePathsFromHead(rootInput: string, workdirInput: string, additionalExcludedWorkdirs?: string[]): Promise<string[]>;
-export declare function workspaceFingerprintExcludedPrefixes(root: string, workdirs: string[]): string[];
-export declare function workspaceSnapshotExcludedPrefixes(root: string, workdirs: string[]): string[];
-export declare function workspacePathExcluded(relative: string, excluded: string[]): boolean;

package/dist/lib/long-task-workspace-manifest.js

@@ -1,173 +0,0 @@
-import { readFile, stat } from "node:fs/promises";
-import path from "node:path";
-import { gitBuffer, gitBufferInput, gitOutput, repoRelative, splitGitZero, } from "./long-task-git.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export async function captureWorkspaceFingerprint(rootInput, excludedPrefixes = []) {
-    const root = path.resolve(rootInput);
-    const indexTree = await gitOutput(root, ["write-tree"]);
-    const [head, headTree, staged, unstaged, statusBytes, untracked] = await Promise.all([
-        gitOutput(root, ["rev-parse", "HEAD"]),
-        gitOutput(root, ["rev-parse", "HEAD^{tree}"]),
-        gitBuffer(root, scopedDiffArgs(["diff", "--cached", "--binary", "--no-ext-diff"], excludedPrefixes)),
-        gitBuffer(root, scopedDiffArgs(["diff", "--binary", "--no-ext-diff"], excludedPrefixes)),
-        Promise.all([
-            gitBuffer(root, scopedDiffArgs(["diff", "--cached", "--raw", "-z", "-M"], excludedPrefixes)),
-            gitBuffer(root, scopedDiffArgs(["diff", "--raw", "-z", "-M"], excludedPrefixes)),
-        ]).then((rows) => Buffer.concat(rows)),
-        untrackedIdentity(root, excludedPrefixes),
-    ]);
-    const unsigned = {
-        head,
-        head_tree: headTree,
-        index_tree: indexTree,
-        staged_diff_sha256: sha256Hex(staged),
-        unstaged_diff_sha256: sha256Hex(unstaged),
-        untracked_sha256: untracked,
-        status_sha256: sha256Hex(statusBytes),
-    };
-    return {
-        ...unsigned,
-        identity: sha256Hex(canonicalValueJson(unsigned)),
-    };
-}
-export async function captureWorkspaceManifest(rootInput, workdirInput, _copyRoot, additionalExcludedWorkdirs = []) {
-    const root = path.resolve(rootInput);
-    const workdir = path.resolve(workdirInput);
-    const workdirRelative = repoRelative(root, workdir);
-    if (!workdirRelative)
-        throw new Error("long_task_workdir_must_not_be_repository_root");
-    const excluded = workspaceFingerprintExcludedPrefixes(root, [
-        workdir,
-        ...additionalExcludedWorkdirs,
-    ]);
-    const fingerprint = await captureWorkspaceFingerprint(root, excluded);
-    const [indexBytes, modifiedBytes, untrackedBytes] = await Promise.all([
-        gitBuffer(root, ["ls-files", "--stage", "-z"]),
-        gitBuffer(root, ["diff", "--name-only", "-z"]),
-        gitBuffer(root, ["ls-files", "--others", "--exclude-standard", "-z"]),
-    ]);
-    const files = new Map();
-    for (const record of splitGitZero(indexBytes)) {
-        const tab = record.indexOf("\t");
-        if (tab < 0)
-            continue;
-        const [modeText, objectId, stage] = record.slice(0, tab).split(" ");
-        const relative = record.slice(tab + 1).replace(/\\/gu, "/");
-        if (stage !== "0" || workspacePathExcluded(relative, excluded))
-            continue;
-        files.set(relative, {
-            path: relative,
-            mode: Number.parseInt(modeText, 8),
-            size: 0,
-            sha256: `git:${objectId}`,
-        });
-    }
-    const overlays = new Set([
-        ...splitGitZero(modifiedBytes),
-        ...splitGitZero(untrackedBytes),
-    ]);
-    const overlayNames = [...overlays]
-        .map((raw) => raw.replace(/\\/gu, "/"))
-        .filter((relative) => !workspacePathExcluded(relative, excluded));
-    const overlayInfo = new Map(await Promise.all(overlayNames.map(async (relative) => [
-        relative,
-        await stat(path.join(root, ...relative.split("/")), {
-            bigint: true,
-        }).catch(() => null),
-    ])));
-    const overlayHashes = await gitObjectIds(root, overlayNames.filter((relative) => overlayInfo.get(relative)?.isFile()));
-    for (const relative of overlayNames) {
-        const absolute = path.join(root, ...relative.split("/"));
-        const info = overlayInfo.get(relative);
-        if (!info?.isFile()) {
-            files.delete(relative);
-            continue;
-        }
-        const bytes = await readFile(absolute);
-        files.set(relative, {
-            path: relative,
-            mode: gitFileMode(Number(info.mode)),
-            size: bytes.length,
-            sha256: `git:${overlayHashes.get(relative)}`,
-        });
-    }
-    return {
-        repository_root: root,
-        git_head: fingerprint.head,
-        files: [...files.values()].sort((a, b) => a.path.localeCompare(b.path)),
-        fingerprint,
-        snapshot_sha256: fingerprint.identity,
-    };
-}
-export function changedWorkspacePaths(baseline, current) {
-    const before = new Map(baseline.files.map((file) => [file.path, `${file.mode}:${file.sha256}`]));
-    const after = new Map(current.files.map((file) => [file.path, `${file.mode}:${file.sha256}`]));
-    return [...new Set([...before.keys(), ...after.keys()])]
-        .filter((file) => before.get(file) !== after.get(file))
-        .sort();
-}
-export async function changedWorkspacePathsFromHead(rootInput, workdirInput, additionalExcludedWorkdirs = []) {
-    const root = path.resolve(rootInput);
-    const workdir = path.resolve(workdirInput);
-    const excluded = workspaceFingerprintExcludedPrefixes(root, [
-        workdir,
-        ...additionalExcludedWorkdirs,
-    ]);
-    const [trackedBytes, untrackedBytes] = await Promise.all([
-        gitBuffer(root, scopedDiffArgs(["diff", "--name-only", "--no-renames", "--no-ext-diff", "-z", "HEAD"], excluded)),
-        gitBuffer(root, ["ls-files", "--others", "--exclude-standard", "-z"]),
-    ]);
-    return [
-        ...new Set([...splitGitZero(trackedBytes), ...splitGitZero(untrackedBytes)]
-            .map((raw) => raw.replace(/\\/gu, "/"))
-            .filter((relative) => !workspacePathExcluded(relative, excluded))),
-    ].sort();
-}
-export function workspaceFingerprintExcludedPrefixes(root, workdirs) {
-    return [
-        ...workspaceSnapshotExcludedPrefixes(root, workdirs),
-        "project_context",
-    ].filter(Boolean);
-}
-export function workspaceSnapshotExcludedPrefixes(root, workdirs) {
-    return [
-        ...workdirs.map((workdir) => repoRelative(root, path.resolve(workdir))),
-        "tmp/ty-context/long-task-runs",
-    ].filter(Boolean);
-}
-export function workspacePathExcluded(relative, excluded) {
-    const normalized = relative.replace(/\\/gu, "/");
-    return (normalized.split("/").includes("node_modules") ||
-        excluded.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix}/`)));
-}
-async function untrackedIdentity(root, excluded) {
-    const names = splitGitZero(await gitBuffer(root, ["ls-files", "--others", "--exclude-standard", "-z"]))
-        .map((name) => name.replace(/\\/gu, "/"))
-        .filter((name) => !workspacePathExcluded(name, excluded))
-        .sort();
-    const hashes = await gitObjectIds(root, names);
-    const rows = names.map((name) => [
-        name,
-        hashes.get(name) ?? "missing",
-    ]);
-    return sha256Hex(canonicalValueJson(rows));
-}
-async function gitObjectIds(root, names) {
-    if (!names.length)
-        return new Map();
-    const output = await gitBufferInput(root, ["hash-object", "--stdin-paths"], Buffer.from(`${names.join("\n")}\n`, "utf8"));
-    const ids = output.toString("utf8").trim().split(/\r?\n/u);
-    return new Map(names.map((name, index) => [name, ids[index]]));
-}
-function scopedDiffArgs(base, excluded) {
-    return [
-        ...base,
-        "--",
-        ".",
-        ...excluded.map((prefix) => `:(exclude)${prefix}/**`),
-        ":(exclude)**/node_modules/**",
-    ];
-}
-function gitFileMode(mode) {
-    return mode & 0o111 ? 0o100755 : 0o100644;
-}

package/dist/lib/long-task-workspace-runtime-types.d.ts

@@ -1,23 +0,0 @@
-export interface WorkspaceFileV2 {
-    path: string;
-    mode: number;
-    size: number;
-    sha256: string;
-}
-export interface WorkspaceFingerprintV2 {
-    head: string;
-    head_tree: string;
-    index_tree: string;
-    staged_diff_sha256: string;
-    unstaged_diff_sha256: string;
-    untracked_sha256: string;
-    status_sha256: string;
-    identity: string;
-}
-export interface WorkspaceManifestV2 {
-    repository_root: string;
-    git_head: string;
-    files: WorkspaceFileV2[];
-    fingerprint: WorkspaceFingerprintV2;
-    snapshot_sha256: string;
-}

package/dist/lib/long-task-workspace-runtime-types.js

@@ -1 +0,0 @@
-export {};

package/dist/lib/long-task-workspace-scope.d.ts

@@ -1,38 +0,0 @@
-interface WorkspaceScopeAuthority {
-    global: {
-        technical: {
-            forbidden_paths: Array<{
-                path: string;
-            }>;
-        };
-    };
-    outcomes: Array<{
-        technical: {
-            expected_change_paths: string[];
-            allowed_support_paths: string[];
-            forbidden_paths: string[];
-        };
-    }>;
-}
-export interface WorkspaceScopeClassificationV2 {
-    protected: string[];
-    expected_change: string[];
-    allowed_support: string[];
-    forbidden: string[];
-    unclassified: string[];
-    blocking_paths: string[];
-}
-export declare function classifyWorkspaceScope(authority: WorkspaceScopeAuthority, changedPaths: string[], protectedPaths: string[]): WorkspaceScopeClassificationV2;
-export declare function protectedWorkspacePaths(input: {
-    contract_files?: Record<string, string> | null;
-    source_hashes?: Record<string, string> | null;
-    context_hashes?: Record<string, string> | null;
-    checks?: Array<{
-        verification_input_hashes: Record<string, string>;
-    }>;
-    additional_files?: string[];
-}): string[];
-export declare function firstLockManagedWorkspacePaths(repository: string, changedPaths: string[]): Promise<string[]>;
-export declare function workspaceScopeErrors(classification: WorkspaceScopeClassificationV2): string[];
-export declare function assertWorkspaceScope(classification: WorkspaceScopeClassificationV2): void;
-export {};