project-tiny-context-harness 0.2.85 → 0.6.0

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

@@ -0,0 +1,124 @@
+import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
+import { activeAuthorityIdentityMatches, assertMatchingActiveBinding, loadActiveLongTaskAuthority, writeFinalReceipt, } from "./long-task-state.js";
+import { assertVerifierAuthorityCurrent } from "./long-task-freshness.js";
+import { allCompiledChecks, runDeliveryChecks, } from "./long-task-verifier-v2.js";
+import { captureWorkspaceFingerprint, createWorkspaceSnapshot, currentGitState, repositoryRoot, } from "./long-task-workspace.js";
+export async function runDeliveryFinalGate(workdirInput) {
+    const startedAt = new Date().toISOString();
+    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(workdirInput)))
+        throw new Error("active_task_workdir_mismatch");
+    await assertVerifierAuthorityCurrent(repository, active.verifier_identity);
+    const acceptedAuthority = {
+        task_id: active.task_id,
+        authority_revision: active.authority_revision,
+        compiled_identity: active.active_authority_identity,
+        worktree_identity: active.worktree_identity,
+    };
+    const candidate = await currentGitState(repository);
+    if (candidate.dirty.length)
+        throw new Error(`final_gate_requires_clean_candidate_commit:${candidate.dirty.join(",")}`);
+    const compiled = await compileDeliveryContract(active.workdir, repository, {
+        live_gate: true,
+        initial_task_base: active.initial_task_base,
+        authority_revision: active.authority_revision,
+        require_completion_gate: true,
+    });
+    await assertMatchingActiveBinding(compiled);
+    const before = await captureWorkspaceFingerprint(repository);
+    const snapshot = await createWorkspaceSnapshot(repository, active.workdir, `final-${compiled.task.id}`);
+    try {
+        const run = await runDeliveryChecks(compiled, snapshot, allCompiledChecks(compiled), true, true);
+        const after = await captureWorkspaceFingerprint(repository);
+        const gitAfter = await currentGitState(repository);
+        if (after.identity !== before.identity ||
+            gitAfter.head !== candidate.head ||
+            gitAfter.tree !== candidate.tree ||
+            gitAfter.dirty.length)
+            run.findings.push({
+                code: "workspace_changed_during_final_gate",
+                outcome_key: null,
+                check_key: null,
+                message: "The workspace changed while Live Final Gate was running.",
+                next_action: "Stop concurrent mutation and rerun the complete Live Final Gate.",
+            });
+        let activeAuthorityChanged = false;
+        try {
+            const currentActive = (await loadActiveLongTaskAuthority(repository))
+                .authority;
+            activeAuthorityChanged =
+                !currentActive ||
+                    !activeAuthorityIdentityMatches(currentActive, acceptedAuthority);
+        }
+        catch {
+            activeAuthorityChanged = true;
+        }
+        if (activeAuthorityChanged)
+            run.findings.push({
+                code: "active_authority_changed_during_final_gate",
+                outcome_key: null,
+                check_key: null,
+                message: "Active Authority changed while Live Final Gate was running.",
+                next_action: "Review the new Authority Revision and rerun the complete Live Final Gate.",
+            });
+        const outcomeResults = projectOutcomes(compiled.outcomes.map((outcome) => outcome.key), run.check_results, run.findings);
+        const globalChecks = run.check_results.filter((check) => check.outcome_key === null);
+        const globalHardFailure = globalChecks.some((check) => check.status !== "passed" && check.status !== "blocked_external");
+        const globalBlocked = globalChecks.some((check) => check.status === "blocked_external");
+        const failed = globalHardFailure ||
+            Object.values(outcomeResults).includes("failed") ||
+            run.findings.some((finding) => finding.code !== "blocked_external");
+        const blocked = globalBlocked ||
+            Object.values(outcomeResults).includes("blocked_external") ||
+            run.findings.some((finding) => finding.code === "blocked_external");
+        const workflowStatus = failed
+            ? "needs_work"
+            : blocked
+                ? "blocked_external"
+                : compiled.global.acceptance.external_confirmations.length
+                    ? "machine_accepted_external_pending"
+                    : "machine_accepted";
+        return writeFinalReceipt(repository, active.workdir, {
+            schema_version: "long-task-final-receipt-v2",
+            authority_scope: "audit_only",
+            reusable_for_acceptance: false,
+            workflow_status: workflowStatus,
+            compiled_identity: compiled.compiled_identity,
+            contract_sha256: compiled.contract_sha256,
+            snapshot_sha256: snapshot.manifest.snapshot_sha256,
+            git_head: candidate.head,
+            git_tree: candidate.tree,
+            source_hashes: compiled.source_hashes,
+            context_hashes: compiled.context_snapshot.sha256,
+            verifier_identity: compiled.verifier_identity,
+            check_results: run.check_results,
+            outcome_results: outcomeResults,
+            external_confirmations: compiled.global.acceptance.external_confirmations,
+            findings: run.findings,
+            snapshot_preparation_ms: snapshot.preparation_ms,
+            started_at: startedAt,
+            completed_at: new Date().toISOString(),
+        });
+    }
+    finally {
+        await snapshot.dispose();
+    }
+}
+function projectOutcomes(outcomeKeys, checks, findings) {
+    return Object.fromEntries(outcomeKeys.map((outcomeKey) => {
+        const owned = checks.filter((check) => check.outcome_key === outcomeKey);
+        const ownFindings = findings.filter((finding) => finding.outcome_key === outcomeKey || finding.outcome_key === null);
+        const status = owned.some((check) => check.status !== "passed" && check.status !== "blocked_external") || ownFindings.some((finding) => finding.code !== "blocked_external")
+            ? "failed"
+            : owned.some((check) => check.status === "blocked_external")
+                ? "blocked_external"
+                : "passed";
+        return [outcomeKey, status];
+    }));
+}
+async function resolved(workdir) {
+    return (await import("node:path")).default.resolve(workdir);
+}

package/dist/lib/long-task-finding-context.d.ts

@@ -0,0 +1,3 @@
+import type { CheckExecutionResultV2, CompiledDeliveryContractV2, LongTaskFindingV2 } from "./long-task-delivery-types.js";
+export declare function enrichCheckResultFindings(compiled: CompiledDeliveryContractV2, result: CheckExecutionResultV2): CheckExecutionResultV2;
+export declare function enrichFinding(compiled: CompiledDeliveryContractV2, finding: LongTaskFindingV2): LongTaskFindingV2;

package/dist/lib/long-task-finding-context.js

@@ -0,0 +1,63 @@
+import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
+export function enrichCheckResultFindings(compiled, result) {
+    return {
+        ...result,
+        findings: result.findings.map((finding) => enrichFinding(compiled, finding)),
+    };
+}
+export function enrichFinding(compiled, finding) {
+    const outcome = finding.outcome_key
+        ? compiled.outcomes.find((item) => item.key === finding.outcome_key)
+        : null;
+    const sourceClaims = sourceClaimsForFinding(compiled, finding);
+    const sourceTargets = compiled.source_claims
+        .filter((source) => sourceClaims.includes(source.key))
+        .flatMap((source) => dispositionTargetRefs(source.disposition))
+        .filter((reference, index, all) => all.indexOf(reference) === index)
+        .sort();
+    return {
+        ...finding,
+        ...(sourceClaims.length ? { source_claim_keys: sourceClaims } : {}),
+        ...(sourceTargets.length ? { source_target_refs: sourceTargets } : {}),
+        ...(outcome && !finding.owner_paths
+            ? { owner_paths: outcome.product.owner.path_globs }
+            : {}),
+    };
+}
+function dispositionTargetRefs(disposition) {
+    if (disposition.type === "outcome_result")
+        return [disposition.ref];
+    if (disposition.type === "claim" ||
+        disposition.type === "acceptance" ||
+        disposition.type === "global_constraint" ||
+        disposition.type === "risk_fact" ||
+        disposition.type === "external_confirmation")
+        return disposition.refs;
+    return [];
+}
+function sourceClaimsForFinding(compiled, finding) {
+    const acceptanceRef = finding.check_key && finding.assertion_key
+        ? `${finding.outcome_key ?? "GLOBAL"}.${finding.check_key}.${finding.assertion_key}`
+        : null;
+    const resolvedAcceptance = acceptanceRef
+        ? resolveAcceptanceAssertion(compiled, acceptanceRef)
+        : null;
+    const productRefs = new Set((finding.claim_keys ?? []).map((claim) => finding.outcome_key ? `${finding.outcome_key}.${claim}` : claim));
+    return compiled.source_claims
+        .filter((source) => {
+        if (source.disposition.type === "acceptance" &&
+            resolvedAcceptance &&
+            source.disposition.refs.includes(resolvedAcceptance.ref))
+            return true;
+        if (source.disposition.type === "claim" &&
+            source.disposition.refs.some((reference) => productRefs.has(reference)))
+            return true;
+        if (source.disposition.type === "outcome_result" &&
+            productRefs.has(source.disposition.ref))
+            return true;
+        return (source.disposition.type === "global_constraint" &&
+            source.disposition.refs.some((reference) => productRefs.has(reference)));
+    })
+        .map((source) => source.key)
+        .sort();
+}

package/dist/lib/long-task-freshness.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledDeliveryContractV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
+export declare function deliveryCompileFreshness(compiled: CompiledDeliveryContractV2): Promise<string[]>;
+export declare function assertVerifierAuthorityCurrent(repositoryRoot: string, expected: VerifierIdentityV2): Promise<void>;

package/dist/lib/long-task-freshness.js

@@ -0,0 +1,80 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { captureContextGraphSnapshot } from "./context-graph-snapshot.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+import { captureVerifierIdentity } from "./long-task-verifier-identity.js";
+import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
+import { parseDeliveryContractBundle } from "./long-task-delivery-parser.js";
+export async function deliveryCompileFreshness(compiled) {
+    const findings = [];
+    try {
+        const currentContract = await parseDeliveryContractBundle(compiled.workdir);
+        if (sha256Hex(canonicalValueJson(currentContract.contract)) !==
+            compiled.contract_sha256)
+            findings.push(`contract_changed_after_compile:${compiled.contract_file}`);
+    }
+    catch {
+        findings.push(`contract_changed_after_compile:${compiled.contract_file}`);
+    }
+    for (const [file, hash] of Object.entries(compiled.contract_files))
+        await compareFile(path.join(compiled.repository_root, file), hash, `contract_changed_after_compile:${file}`, findings);
+    for (const [file, hash] of Object.entries(compiled.source_hashes))
+        await compareFile(path.join(compiled.repository_root, file), hash, `source_changed_after_compile:${file}`, findings);
+    try {
+        const current = await captureContextGraphSnapshot(compiled.repository_root, compiled.task.context_refs, compiled.context_snapshot.mode);
+        if (current.topology_sha256 !== compiled.context_snapshot.topology_sha256)
+            findings.push("context_changed_after_compile:topology");
+        if (canonicalValueJson(current.files) !==
+            canonicalValueJson(compiled.context_snapshot.files))
+            findings.push("context_changed_after_compile:file_set");
+        for (const [file, hash] of Object.entries(compiled.context_snapshot.sha256))
+            if (current.sha256[file] !== hash)
+                findings.push(`context_changed_after_compile:${file}`);
+    }
+    catch (error) {
+        findings.push(`context_changed_after_compile:${message(error)}`);
+    }
+    try {
+        const currentVerifier = await captureVerifierIdentity(compiled.repository_root, compiled.verifier_identity.hook_sha256 !== "not-required");
+        const verifierDiff = verifierAuthorityDiff(compiled.verifier_identity, currentVerifier);
+        if (verifierDiff.verifier_content_changed)
+            findings.push("verifier_changed_after_compile:bundle");
+        if (verifierDiff.verifier_runtime_locator_changed)
+            findings.push("verifier_changed_after_compile:runtime_locator");
+    }
+    catch {
+        findings.push("verifier_changed_after_compile:bundle");
+    }
+    const checks = [
+        ...compiled.global.acceptance.checks,
+        ...compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
+    ];
+    for (const check of checks)
+        for (const [file, hash] of Object.entries(check.runner.frozen_files))
+            await compareFile(path.join(compiled.repository_root, file), hash, `runner_changed_after_compile:${check.internal_id}:${file}`, findings);
+    return [...new Set(findings)].sort();
+}
+export async function assertVerifierAuthorityCurrent(repositoryRoot, expected) {
+    let current;
+    try {
+        current = await captureVerifierIdentity(repositoryRoot, expected.hook_sha256 !== "not-required");
+    }
+    catch {
+        throw new Error("verifier_authority_migration_required");
+    }
+    const diff = verifierAuthorityDiff(expected, current);
+    if (diff.verifier_content_changed || diff.verifier_runtime_locator_changed)
+        throw new Error("verifier_authority_migration_required");
+}
+async function compareFile(file, expected, finding, findings) {
+    try {
+        if (sha256Hex(await readFile(file)) !== expected)
+            findings.push(finding);
+    }
+    catch {
+        findings.push(finding);
+    }
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/long-task-hook-install.d.ts

@@ -0,0 +1,9 @@
+import type { SyncReport } from "./sync-engine.js";
+export declare function installLongTaskHooks(projectRoot: string, report: SyncReport): Promise<void>;
+export declare function uninstallLongTaskHooks(projectRoot: string, report: SyncReport): Promise<void>;
+export declare function packageOwnedCommand(entry: string): string;
+export declare function removeManagedHookEntries(groups: unknown, currentPackageCommand?: string): {
+    groups: unknown[];
+    removed: number;
+};
+export declare function isManagedHookEntry(entry: unknown, currentPackageCommand?: string): boolean;

package/dist/lib/long-task-hook-install.js

@@ -0,0 +1,184 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathExists } from "./fs.js";
+const MANAGED_STATUS = "Tiny Context long-task live authority gate";
+const LEGACY_MANAGED_STATUSES = new Set([
+    "Tiny Context long-task live authority gate",
+    "Tiny Context long-task authority gate",
+    "Tiny Context long-task completion gate",
+    "Tiny Context composite completion gate",
+]);
+const LEGACY_REPO_LOCAL_COMMANDS = new Set([
+    'node "$(git rev-parse --show-toplevel)/.codex/hooks/long-task-hook.mjs"',
+    "powershell -NoProfile -Command \"$r=(git rev-parse --show-toplevel); node (Join-Path $r '.codex/hooks/long-task-hook.mjs')\"",
+    "node .codex/hooks/long-task-hook.mjs",
+    'node ".codex/hooks/long-task-hook.mjs"',
+    "node .codex\\hooks\\long-task-hook.mjs",
+    'node ".codex\\hooks\\long-task-hook.mjs"',
+]);
+export async function installLongTaskHooks(projectRoot, report) {
+    const packageRoot = fileURLToPath(new URL("../../", import.meta.url));
+    const entry = path.join(packageRoot, "dist", "long-task-hook.js");
+    if (!(await pathExists(entry))) {
+        report.blocked.push("package-owned dist/long-task-hook.js is missing");
+        return;
+    }
+    const legacyScript = path.join(projectRoot, ".codex", "hooks", "long-task-hook.mjs");
+    if (await pathExists(legacyScript)) {
+        await rm(legacyScript, { force: true });
+        report.changed.push(".codex/hooks/long-task-hook.mjs");
+    }
+    const command = packageOwnedCommand(entry);
+    const config = path.join(projectRoot, ".codex", "hooks.json");
+    let root = {};
+    if (await pathExists(config)) {
+        try {
+            root = JSON.parse(await readFile(config, "utf8"));
+        }
+        catch {
+            report.blocked.push(".codex/hooks.json: invalid JSON");
+            return;
+        }
+    }
+    const hooks = object(root.hooks);
+    root.hooks = hooks;
+    for (const event of ["SessionStart", "PostCompact", "Stop"]) {
+        const groups = Array.isArray(hooks[event]) ? hooks[event] : [];
+        const cleaned = removeManagedHookEntries(groups, command);
+        cleaned.groups.push({
+            hooks: [
+                {
+                    type: "command",
+                    command,
+                    commandWindows: command,
+                    timeout: event === "Stop" ? 3600 : 10,
+                    statusMessage: MANAGED_STATUS,
+                },
+            ],
+        });
+        hooks[event] = cleaned.groups;
+    }
+    if (await writeIfChanged(config, `${JSON.stringify(root, null, 2)}\n`))
+        report.changed.push(".codex/hooks.json");
+    else
+        report.skipped.push(".codex/hooks.json");
+}
+export async function uninstallLongTaskHooks(projectRoot, report) {
+    const packageRoot = fileURLToPath(new URL("../../", import.meta.url));
+    const command = packageOwnedCommand(path.join(packageRoot, "dist", "long-task-hook.js"));
+    const legacyScript = path.join(projectRoot, ".codex", "hooks", "long-task-hook.mjs");
+    if (await pathExists(legacyScript)) {
+        await rm(legacyScript, { force: true });
+        report.changed.push(".codex/hooks/long-task-hook.mjs");
+    }
+    const config = path.join(projectRoot, ".codex", "hooks.json");
+    if (!(await pathExists(config)))
+        return;
+    let root;
+    try {
+        root = JSON.parse(await readFile(config, "utf8"));
+    }
+    catch {
+        report.skipped.push(".codex/hooks.json: invalid JSON");
+        return;
+    }
+    const hooks = object(root.hooks);
+    let changed = false;
+    for (const event of ["SessionStart", "PostCompact", "Stop"]) {
+        if (!Array.isArray(hooks[event]))
+            continue;
+        const cleaned = removeManagedHookEntries(hooks[event], command);
+        if (cleaned.removed === 0)
+            continue;
+        changed = true;
+        if (cleaned.groups.length)
+            hooks[event] = cleaned.groups;
+        else
+            delete hooks[event];
+    }
+    if (!changed)
+        return;
+    root.hooks = hooks;
+    if (Object.keys(hooks).length === 0 && Object.keys(root).length === 1)
+        await rm(config, { force: true });
+    else
+        await writeIfChanged(config, `${JSON.stringify(root, null, 2)}\n`);
+    report.changed.push(".codex/hooks.json");
+}
+export function packageOwnedCommand(entry) {
+    return `node "${path.resolve(entry).replace(/"/gu, '\\"')}"`;
+}
+export function removeManagedHookEntries(groups, currentPackageCommand = "") {
+    if (!Array.isArray(groups))
+        return { groups: [], removed: 0 };
+    const retained = [];
+    let removed = 0;
+    for (const groupValue of groups) {
+        if (!isObject(groupValue) || !Array.isArray(groupValue.hooks)) {
+            retained.push(groupValue);
+            continue;
+        }
+        const hooks = groupValue.hooks.filter((entry) => {
+            if (!isManagedHookEntry(entry, currentPackageCommand))
+                return true;
+            removed += 1;
+            return false;
+        });
+        if (hooks.length > 0) {
+            retained.push({ ...groupValue, hooks });
+            continue;
+        }
+        if (Object.keys(groupValue).some((key) => key !== "hooks"))
+            retained.push({ ...groupValue, hooks });
+    }
+    return { groups: retained, removed };
+}
+export function isManagedHookEntry(entry, currentPackageCommand = "") {
+    const row = object(entry);
+    if (row.type !== "command")
+        return false;
+    const commands = [row.command, row.commandWindows]
+        .filter((value) => typeof value === "string")
+        .map((value) => value.trim());
+    const repoLocal = commands.some((command) => LEGACY_REPO_LOCAL_COMMANDS.has(command));
+    if (repoLocal)
+        return true;
+    const status = String(row.statusMessage ?? "");
+    if (!LEGACY_MANAGED_STATUSES.has(status))
+        return false;
+    return commands.some((command) => (Boolean(currentPackageCommand) && command === currentPackageCommand) ||
+        isHistoricalPackageOwnedCommand(command));
+}
+function isHistoricalPackageOwnedCommand(command) {
+    const match = /^node "([^"\r\n]+)"$/u.exec(command);
+    if (!match)
+        return false;
+    const absolute = match[1];
+    if (!path.isAbsolute(absolute) &&
+        !path.win32.isAbsolute(absolute) &&
+        !path.posix.isAbsolute(absolute))
+        return false;
+    const normalized = absolute.replace(/\\/gu, "/");
+    return (/\/node_modules\/project-tiny-context-harness\/dist\/long-task-hook\.js$/u.test(normalized) || /\/packages\/ty-context\/dist\/long-task-hook\.js$/u.test(normalized));
+}
+function object(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function isObject(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+async function writeIfChanged(file, content) {
+    try {
+        if ((await readFile(file, "utf8")) === content)
+            return false;
+    }
+    catch { }
+    await mkdir(path.dirname(file), { recursive: true });
+    const temp = `${file}.tmp-${process.pid}-${Date.now()}`;
+    await writeFile(temp, content, { flag: "wx" });
+    await rename(temp, file);
+    return true;
+}

package/dist/lib/long-task-hook-preflight.d.ts

@@ -0,0 +1,7 @@
+export interface CompletionGateCheck {
+    status: "available" | "completion_gate_unavailable";
+    bundle_sha256: string;
+    hook_sha256: string;
+    findings: string[];
+}
+export declare function checkLongTaskCompletionGate(repositoryRoot: string, packageRoot: string): Promise<CompletionGateCheck>;

package/dist/lib/long-task-hook-preflight.js

@@ -0,0 +1,58 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { packageOwnedCommand } from "./long-task-hook-install.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { sha256Hex } from "./strict-codec.js";
+export async function checkLongTaskCompletionGate(repositoryRoot, packageRoot) {
+    const config = path.join(path.resolve(repositoryRoot), ".codex", "hooks.json");
+    const entry = path.join(path.resolve(packageRoot), "dist", "long-task-hook.js");
+    const expectedCommand = packageOwnedCommand(entry);
+    const findings = [];
+    let configHash = "missing";
+    let hookHash = "missing";
+    try {
+        hookHash = sha256Hex(await readFile(await assertProtectedRepositoryFile(packageRoot, entry, "package_owned_hook")));
+    }
+    catch {
+        findings.push("package_owned_hook_missing");
+    }
+    try {
+        const content = await readFile(await assertProtectedRepositoryFile(repositoryRoot, config, "completion_hook_config"), "utf8");
+        configHash = sha256Hex(content);
+        const value = JSON.parse(content);
+        for (const event of ["SessionStart", "PostCompact", "Stop"]) {
+            const handlers = managedHandlers(value.hooks?.[event], expectedCommand);
+            if (handlers.length !== 1)
+                findings.push(`completion_hook_event_missing:${event}`);
+            else {
+                const timeout = handlers[0].timeout;
+                const expected = event === "Stop" ? 3600 : 10;
+                if (timeout !== expected)
+                    findings.push(`completion_hook_timeout_invalid:${event}`);
+            }
+        }
+    }
+    catch {
+        findings.push("hooks_config_missing_or_invalid");
+    }
+    const bundle_sha256 = sha256Hex(`${configHash}:${hookHash}`);
+    return {
+        status: findings.length ? "completion_gate_unavailable" : "available",
+        bundle_sha256,
+        hook_sha256: hookHash,
+        findings,
+    };
+}
+function managedHandlers(value, expectedCommand) {
+    if (Array.isArray(value))
+        return value.flatMap((item) => managedHandlers(item, expectedCommand));
+    if (value && typeof value === "object") {
+        const item = value;
+        if (item.type === "command" &&
+            item.command === expectedCommand &&
+            item.commandWindows === expectedCommand)
+            return [item];
+        return Object.values(item).flatMap((child) => managedHandlers(child, expectedCommand));
+    }
+    return [];
+}

package/dist/lib/long-task-observation-ownership.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
+export declare function validateRawExecutionObservationOwnership(checks: CompiledCheckV2[]): void;

package/dist/lib/long-task-observation-ownership.js

@@ -0,0 +1,22 @@
+export function validateRawExecutionObservationOwnership(checks) {
+    const byExecution = new Map();
+    for (const check of checks) {
+        let observations = byExecution.get(check.raw_execution_identity);
+        if (!observations) {
+            observations = new Map();
+            byExecution.set(check.raw_execution_identity, observations);
+        }
+        for (const assertion of [
+            ...check.positive_assertions,
+            ...check.negative_assertions,
+        ]) {
+            if (!assertion.claims.length)
+                continue;
+            const owner = `${check.outcome_key ?? "GLOBAL"}.${check.key}.${assertion.key}`;
+            const previous = observations.get(assertion.observation);
+            if (previous)
+                throw new Error(`raw_execution_observation_reused:${check.raw_execution_identity}:${assertion.observation}:${previous}:${owner}`);
+            observations.set(assertion.observation, owner);
+        }
+    }
+}

package/dist/lib/long-task-outcome-parser.d.ts

@@ -0,0 +1,4 @@
+import type { DeliveryOutcomeV2 } from "./long-task-delivery-types.js";
+export declare function parseOutcome(value: unknown, label: string): DeliveryOutcomeV2;
+export declare function parseOutcomeFragment(raw: string, relative: string): DeliveryOutcomeV2[];
+export declare function safeFragmentPath(value: string, index: number): string;