project-tiny-context-harness 0.8.11 → 0.8.12

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

@@ -1,8 +1,21 @@
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
 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 PRE_TOOL_USE_MATCHER = "^(spawn_agent|Agent)$";
+const LONG_TASK_IMPLEMENTATION_AGENT_MATCHER = "^long_task_implementation$";
+const MANAGED_HOOK_EVENTS = [
+    "PreToolUse",
+    "SessionStart",
+    "PostCompact",
+    "Stop",
+    "SubagentStart",
+];
+const MANAGED_MATCHERS = new Set([
+    PRE_TOOL_USE_MATCHER,
+    LONG_TASK_IMPLEMENTATION_AGENT_MATCHER,
+]);
 const LEGACY_MANAGED_STATUSES = new Set([
     "Tiny Context long-task live authority gate",
     "Tiny Context long-task authority gate",
@@ -17,94 +30,85 @@ const LEGACY_REPO_LOCAL_COMMANDS = new Set([
     "node .codex\\hooks\\long-task-hook.mjs",
     'node ".codex\\hooks\\long-task-hook.mjs"',
 ]);
-export async function installLongTaskHooks(projectRoot, report) {
+export const LONG_TASK_HOOK_TRUST_REVIEW_NOTICE = "Codex Hook review required: open /hooks and trust the current Tiny Context project Hook before relying on PreToolUse, SubagentStart, SessionStart or Stop behavior. Tiny Context cannot observe or persist Codex Hook trust.";
+const DEFAULT_FILE_OPERATIONS = {
+    lstat: (target) => fs.lstat(target),
+    readFile: (target, encoding) => fs.readFile(target, encoding),
+    mkdir: (target, options) => fs.mkdir(target, options),
+    writeFile: (target, content, options) => fs.writeFile(target, content, options),
+    rename: (source, destination) => fs.rename(source, destination),
+    rm: (target, options) => fs.rm(target, options),
+    randomId: () => randomUUID(),
+};
+export async function installLongTaskHooks(projectRoot, report, fileOperations = {}) {
+    const operations = operationsWith(fileOperations);
     const packageRoot = fileURLToPath(new URL("../../", import.meta.url));
     const entry = path.join(packageRoot, "dist", "long-task-hook.js");
-    if (!(await pathExists(entry))) {
+    const entryStatus = await lstatOrNull(entry, operations);
+    if (!entryStatus || entryStatus.isSymbolicLink() || !entryStatus.isFile()) {
         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"));
+    const legacyScript = path.join(projectRoot, ".codex", "hooks", "long-task-hook.mjs");
+    try {
+        const legacy = await inspectLegacyScript(projectRoot, operations);
+        const loaded = await readHookConfig(projectRoot, true, operations);
+        const command = packageOwnedCommand(entry);
+        const packageHooksWereCurrent = packageHooksAreCurrent(loaded.root, command);
+        const next = mergeManagedHooks(loaded.root, command);
+        const content = `${JSON.stringify(next, null, 2)}\n`;
+        if (loaded.snapshot.kind === "regular" &&
+            loaded.snapshot.content === content) {
+            report.skipped.push(".codex/hooks.json");
         }
-        catch {
-            report.blocked.push(".codex/hooks.json: invalid JSON");
-            return;
+        else {
+            await publishHookConfig(config, loaded.snapshot, content, operations);
+            report.changed.push(".codex/hooks.json");
+            if (!packageHooksWereCurrent)
+                addNotice(report);
         }
+        await removeLegacyScriptIfPresent(projectRoot, legacyScript, legacy, report, operations);
     }
-    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;
+    catch (error) {
+        report.blocked.push(`.codex/hooks.json: ${message(error)}`);
     }
-    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) {
+export async function uninstallLongTaskHooks(projectRoot, report, fileOperations = {}) {
+    const operations = operationsWith(fileOperations);
     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;
+    const legacyScript = path.join(projectRoot, ".codex", "hooks", "long-task-hook.mjs");
     try {
-        root = JSON.parse(await readFile(config, "utf8"));
-    }
-    catch {
-        report.skipped.push(".codex/hooks.json: invalid JSON");
-        return;
+        const legacy = await inspectLegacyScript(projectRoot, operations);
+        const loaded = await readHookConfig(projectRoot, false, operations);
+        let removed = 0;
+        const hooks = hookMap(loaded.root);
+        for (const event of MANAGED_HOOK_EVENTS) {
+            if (!Array.isArray(hooks[event]))
+                continue;
+            const cleaned = removeManagedHookEntries(hooks[event], command);
+            removed += cleaned.removed;
+            if (cleaned.groups.length)
+                hooks[event] = cleaned.groups;
+            else
+                delete hooks[event];
+        }
+        if (removed > 0 && loaded.snapshot.kind === "regular") {
+            loaded.root.hooks = hooks;
+            if (Object.keys(hooks).length === 0 &&
+                Object.keys(loaded.root).length === 1)
+                await removeHookConfig(config, loaded.snapshot, operations);
+            else
+                await publishHookConfig(config, loaded.snapshot, `${JSON.stringify(loaded.root, null, 2)}\n`, operations);
+            report.changed.push(".codex/hooks.json");
+        }
+        await removeLegacyScriptIfPresent(projectRoot, legacyScript, legacy, report, operations);
     }
-    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];
+    catch (error) {
+        report.blocked.push(`.codex/hooks.json: ${message(error)}`);
     }
-    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, '\\"')}"`;
@@ -129,8 +133,13 @@ export function removeManagedHookEntries(groups, currentPackageCommand = "") {
             retained.push({ ...groupValue, hooks });
             continue;
         }
-        if (Object.keys(groupValue).some((key) => key !== "hooks"))
-            retained.push({ ...groupValue, hooks });
+        const keys = Object.keys(groupValue);
+        if (keys.every((key) => key === "hooks"))
+            continue;
+        if (MANAGED_MATCHERS.has(String(groupValue.matcher ?? "")) &&
+            keys.every((key) => key === "matcher" || key === "hooks"))
+            continue;
+        retained.push({ ...groupValue, hooks });
     }
     return { groups: retained, removed };
 }
@@ -141,8 +150,7 @@ export function isManagedHookEntry(entry, currentPackageCommand = "") {
     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)
+    if (commands.some((command) => LEGACY_REPO_LOCAL_COMMANDS.has(command)))
         return true;
     const status = String(row.statusMessage ?? "");
     if (!LEGACY_MANAGED_STATUSES.has(status))
@@ -150,6 +158,201 @@ export function isManagedHookEntry(entry, currentPackageCommand = "") {
     return commands.some((command) => (Boolean(currentPackageCommand) && command === currentPackageCommand) ||
         isHistoricalPackageOwnedCommand(command));
 }
+function mergeManagedHooks(root, command) {
+    const hooks = hookMap(root);
+    root.hooks = hooks;
+    for (const event of MANAGED_HOOK_EVENTS) {
+        const current = hooks[event];
+        if (current !== undefined && !Array.isArray(current))
+            throw new Error(`hook_event_not_array:${event}`);
+        const cleaned = removeManagedHookEntries(current ?? [], command);
+        cleaned.groups.push(managedHookGroup(event, command));
+        hooks[event] = cleaned.groups;
+    }
+    return root;
+}
+function managedHookGroup(event, command) {
+    return {
+        ...(event === "PreToolUse" ? { matcher: PRE_TOOL_USE_MATCHER } : {}),
+        ...(event === "SubagentStart"
+            ? { matcher: LONG_TASK_IMPLEMENTATION_AGENT_MATCHER }
+            : {}),
+        hooks: [
+            {
+                type: "command",
+                command,
+                commandWindows: command,
+                timeout: event === "Stop" ? 3600 : 10,
+                statusMessage: MANAGED_STATUS,
+            },
+        ],
+    };
+}
+function packageHooksAreCurrent(root, command) {
+    let hooks;
+    try {
+        hooks = hookMap(root);
+    }
+    catch {
+        return false;
+    }
+    return MANAGED_HOOK_EVENTS.every((event) => {
+        const groups = hooks[event];
+        if (!Array.isArray(groups))
+            return false;
+        const matches = [];
+        for (const groupValue of groups) {
+            if (!isObject(groupValue) || !Array.isArray(groupValue.hooks))
+                continue;
+            for (const entryValue of groupValue.hooks) {
+                if (!isManagedHookEntry(entryValue, command))
+                    continue;
+                matches.push({ group: groupValue, entry: object(entryValue) });
+            }
+        }
+        if (matches.length !== 1)
+            return false;
+        const [{ group, entry }] = matches;
+        const expectedMatcher = event === "PreToolUse"
+            ? PRE_TOOL_USE_MATCHER
+            : event === "SubagentStart"
+                ? LONG_TASK_IMPLEMENTATION_AGENT_MATCHER
+                : undefined;
+        return (entry.type === "command" &&
+            entry.command === command &&
+            entry.commandWindows === command &&
+            entry.timeout === (event === "Stop" ? 3600 : 10) &&
+            entry.statusMessage === MANAGED_STATUS &&
+            (expectedMatcher === undefined
+                ? !Object.hasOwn(group, "matcher")
+                : group.matcher === expectedMatcher));
+    });
+}
+async function readHookConfig(projectRoot, createDirectory, operations) {
+    const directory = await inspectCodexDirectory(projectRoot, createDirectory, operations);
+    if (directory === "absent")
+        return { root: {}, snapshot: { kind: "absent" } };
+    const config = path.join(projectRoot, ".codex", "hooks.json");
+    const status = await lstatOrNull(config, operations);
+    if (!status)
+        return { root: {}, snapshot: { kind: "absent" } };
+    if (status.isSymbolicLink())
+        throw new Error("destination_symlink_or_junction");
+    if (!status.isFile())
+        throw new Error("destination_not_regular_file");
+    const content = await operations.readFile(config, "utf8");
+    let decoded;
+    try {
+        decoded = JSON.parse(content);
+    }
+    catch {
+        throw new Error("invalid JSON");
+    }
+    if (!isObject(decoded))
+        throw new Error("root_not_object");
+    hookMap(decoded);
+    return { root: decoded, snapshot: { kind: "regular", content } };
+}
+function hookMap(root) {
+    if (root.hooks === undefined)
+        return {};
+    if (!isObject(root.hooks))
+        throw new Error("hooks_not_object");
+    return root.hooks;
+}
+async function inspectCodexDirectory(projectRoot, create, operations) {
+    const directory = path.join(projectRoot, ".codex");
+    let status = await lstatOrNull(directory, operations);
+    if (!status && create) {
+        await operations.mkdir(directory, { recursive: true });
+        status = await lstatOrNull(directory, operations);
+    }
+    if (!status)
+        return "absent";
+    if (status.isSymbolicLink())
+        throw new Error("parent_symlink_or_junction:.codex");
+    if (!status.isDirectory())
+        throw new Error("parent_not_directory:.codex");
+    return "regular";
+}
+async function inspectLegacyScript(projectRoot, operations) {
+    if ((await inspectCodexDirectory(projectRoot, false, operations)) === "absent")
+        return { kind: "absent" };
+    const parent = path.join(projectRoot, ".codex", "hooks");
+    const parentStatus = await lstatOrNull(parent, operations);
+    if (!parentStatus)
+        return { kind: "absent" };
+    if (parentStatus.isSymbolicLink())
+        throw new Error("legacy_parent_symlink_or_junction");
+    if (!parentStatus.isDirectory())
+        throw new Error("legacy_parent_not_directory");
+    const target = path.join(parent, "long-task-hook.mjs");
+    const targetStatus = await lstatOrNull(target, operations);
+    if (!targetStatus)
+        return { kind: "absent" };
+    if (targetStatus.isSymbolicLink())
+        throw new Error("legacy_hook_symlink_or_junction");
+    if (!targetStatus.isFile())
+        throw new Error("legacy_hook_not_regular_file");
+    return { kind: "regular" };
+}
+async function removeLegacyScriptIfPresent(projectRoot, target, initial, report, operations) {
+    if (initial.kind === "absent")
+        return;
+    const current = await inspectLegacyScript(projectRoot, operations);
+    if (current.kind !== "regular")
+        throw new Error("legacy_hook_changed_before_delete");
+    await operations.rm(target, { force: true });
+    report.changed.push(".codex/hooks/long-task-hook.mjs");
+}
+async function publishHookConfig(target, initial, content, operations) {
+    const temp = `${target}.tmp-${process.pid}-${operations.randomId()}`;
+    let renamed = false;
+    try {
+        await operations.writeFile(temp, content, { flag: "wx" });
+        await assertTargetUnchanged(target, initial, operations);
+        await operations.rename(temp, target);
+        renamed = true;
+    }
+    finally {
+        if (!renamed)
+            await operations.rm(temp, { force: true }).catch(() => { });
+    }
+}
+async function removeHookConfig(target, initial, operations) {
+    await assertTargetUnchanged(target, initial, operations);
+    await operations.rm(target, { force: true });
+}
+async function assertTargetUnchanged(target, initial, operations) {
+    const projectRoot = path.dirname(path.dirname(target));
+    await inspectCodexDirectory(projectRoot, false, operations);
+    const status = await lstatOrNull(target, operations);
+    if (initial.kind === "absent") {
+        if (status)
+            throw new Error("concurrent change: destination appeared");
+        return;
+    }
+    if (!status || status.isSymbolicLink() || !status.isFile())
+        throw new Error("concurrent change: destination type changed");
+    if ((await operations.readFile(target, "utf8")) !== initial.content)
+        throw new Error("concurrent change: destination content changed");
+}
+function addNotice(report) {
+    (report.notices ??= []).push(LONG_TASK_HOOK_TRUST_REVIEW_NOTICE);
+}
+function operationsWith(overrides) {
+    return { ...DEFAULT_FILE_OPERATIONS, ...overrides };
+}
+async function lstatOrNull(target, operations) {
+    try {
+        return await operations.lstat(target);
+    }
+    catch (error) {
+        if (code(error) === "ENOENT")
+            return null;
+        throw error;
+    }
+}
 function isHistoricalPackageOwnedCommand(command) {
     const match = /^node "([^"\r\n]+)"$/u.exec(command);
     if (!match)
@@ -163,22 +366,16 @@ function isHistoricalPackageOwnedCommand(command) {
     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
-        : {};
+    return isObject(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;
+function code(error) {
+    return typeof error === "object" && error !== null && "code" in error
+        ? String(error.code)
+        : "";
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
 }

package/dist/lib/long-task-playwright-capability-records.d.ts

@@ -3,3 +3,5 @@ import type { PlaywrightCase } from "./long-task-playwright-case-evidence.js";
 export declare function evidenceRecordsForPlaywrightCases(check: CompiledCheckV2, cases: PlaywrightCase[]): EvidenceCapabilityRecordV2[];
 export declare function semanticFactAttachmentName(proofRef: string): string;
 export declare function designMethodAttachmentName(target: string, method: string, condition: string, kind: "record" | "observation"): string;
+export declare function symbolicDesignMethodAttachmentName(target: string, method: string): string;
+export declare function symbolicDesignCertificateAttachmentName(target: string): string;

package/dist/lib/long-task-playwright-capability-records.js

@@ -8,7 +8,7 @@ export function evidenceRecordsForPlaywrightCases(check, cases) {
         ].find((candidate) => candidate.key === item.id);
         if (!assertion)
             continue;
-        records.push(...baseEvidenceRecords(check, item, assertion), ...designConformanceRecords(check, item, assertion), ...designMethodRecords(check, item, assertion), ...semanticFactRecords(check, item, assertion));
+        records.push(...baseEvidenceRecords(check, item, assertion), ...designConformanceRecords(check, item, assertion), ...designMethodRecords(check, item, assertion), ...symbolicDesignEvidenceRecords(check, item, assertion), ...semanticFactRecords(check, item, assertion));
     }
     return records;
 }
@@ -41,7 +41,8 @@ function designConformanceRecords(check, item, assertion) {
         return [];
     return (check.design_conformance_targets ?? [])
         .filter((candidate) => candidate.conformance_assertion_ref === assertion.key ||
-        candidate.verification_method_bindings.some((binding) => binding.assertion_ref === assertion.key))
+        candidate.verification_method_bindings.some((binding) => binding.assertion_ref === assertion.key) ||
+        (candidate.symbolic_method_bindings ?? []).some((binding) => binding.assertion_ref === assertion.key))
         .map((target) => ({
         assertion_key: assertion.key,
         capability: "design_conformance",
@@ -58,6 +59,8 @@ function designMethodRecords(check, item, assertion) {
         return [];
     const records = [];
     for (const target of check.design_conformance_targets ?? []) {
+        if (target.fact_model === "symbolic_rules_v2")
+            continue;
         const binding = target.verification_method_bindings.find((candidate) => candidate.assertion_ref === assertion.key);
         if (!binding)
             continue;
@@ -93,6 +96,69 @@ function designMethodRecords(check, item, assertion) {
     }
     return records;
 }
+function symbolicDesignEvidenceRecords(check, item, assertion) {
+    if (!item.executed)
+        return [];
+    const records = [];
+    for (const target of check.design_conformance_targets ?? []) {
+        if (target.fact_model !== "symbolic_rules_v2")
+            continue;
+        records.push(...symbolicMethodEvidenceRecords(target, item, assertion));
+        const certificate = symbolicCertificateEvidenceRecord(target, item, assertion);
+        if (certificate)
+            records.push(certificate);
+    }
+    return records;
+}
+function symbolicMethodEvidenceRecords(target, item, assertion) {
+    if (!assertion.evidence_capabilities.includes("design_method"))
+        return [];
+    const records = [];
+    for (const binding of target.symbolic_method_bindings ?? []) {
+        if (binding.assertion_ref !== assertion.key)
+            continue;
+        const attachmentName = symbolicDesignMethodAttachmentName(target.key, binding.method);
+        if (!item.attachment_names.includes(attachmentName))
+            continue;
+        const record = typedEvidenceAttachment(item.attachment_payloads[attachmentName], "design_method");
+        if (record?.capability === "design_method" &&
+            "fact_model" in record &&
+            record.assertion_key === assertion.key &&
+            record.design_target_ref === target.key &&
+            record.method === binding.method)
+            records.push(record);
+    }
+    return records;
+}
+function symbolicCertificateEvidenceRecord(target, item, assertion) {
+    const binding = target.symbolic_certificate_binding;
+    if (binding?.assertion_ref !== assertion.key ||
+        !assertion.evidence_capabilities.includes("design_symbolic_certificate"))
+        return null;
+    const attachmentName = symbolicDesignCertificateAttachmentName(target.key);
+    if (!item.attachment_names.includes(attachmentName))
+        return null;
+    const record = typedEvidenceAttachment(item.attachment_payloads[attachmentName], "design_symbolic_certificate");
+    return record?.capability === "design_symbolic_certificate" &&
+        record.assertion_key === assertion.key &&
+        record.design_target_ref === target.key
+        ? record
+        : null;
+}
+function typedEvidenceAttachment(payload, capability) {
+    if (!payload)
+        return null;
+    try {
+        const records = decodeEvidenceCapabilityRecords([JSON.parse(payload)]);
+        const record = records[0];
+        return records.length === 1 && record.capability === capability
+            ? record
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 function semanticFactRecords(check, item, assertion) {
     if (!item.executed ||
         !assertion.evidence_capabilities.includes("semantic_fact"))
@@ -144,3 +210,9 @@ function designFactResultAttachment(content, label) {
 export function designMethodAttachmentName(target, method, condition, kind) {
     return `ty-context-design-method:${target}:${method}:${condition}:${kind}`;
 }
+export function symbolicDesignMethodAttachmentName(target, method) {
+    return `ty-context-design-symbolic-method:${target}:${method}:record`;
+}
+export function symbolicDesignCertificateAttachmentName(target) {
+    return `ty-context-design-symbolic-certificate:${target}:record`;
+}

package/dist/lib/long-task-runner-freeze.d.ts

@@ -1,2 +1,2 @@
 import type { CompiledCheckV2, CompiledDesignTargetV2, DeliveryCheckV2, ExecutionTargetV2, SemanticFactExpectationV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[], designConformanceTargets: CompiledDesignTargetV2[], semanticFactExpectations: SemanticFactExpectationV2[]): Promise<CompiledCheckV2>;
+export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[], designConformanceTargets: CompiledDesignTargetV2[], semanticFactExpectations: SemanticFactExpectationV2[], protectedAuthorityPaths?: readonly string[]): Promise<CompiledCheckV2>;

package/dist/lib/long-task-runner-freeze.js

@@ -1,19 +1,21 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { computeRawExecutionIdentity } from "./long-task-check-execution-policy.js";
-import { assertRepositoryPattern, classifyRepositoryPatternOverlap, matchesRepoPattern, } from "./long-task-paths.js";
+import { assertRepositoryPattern, classifyRepositoryPatternOverlap, matchesRepoPattern, normalizeRepositoryFile, } from "./long-task-paths.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { nearestRunnerFile, npmCliPath, npxCliPath, } from "./long-task-runner-files.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
 import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
 import { freezeLocalVerifierDependencyClosure, packageScriptVerifierRoots, } from "./long-task-verifier-dependency-closure.js";
-export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets, designConformanceTargets, semanticFactExpectations) {
+export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets, designConformanceTargets, semanticFactExpectations, protectedAuthorityPaths = []) {
     const prefix = outcomeKey ? `CHECK.${outcomeKey}` : "CHECK.GLOBAL";
     const expectedOutputs = check.expected_output_paths.map((pattern, index) => assertRepositoryPattern(repository, pattern, `${check.key}.expected_output_paths[${index}]`));
+    const protectedAuthorityFiles = protectedAuthorityPaths.map((file, index) => normalizeRepositoryFile(file, `${check.key}.protected_authority_paths[${index}]`));
     for (const [index, pattern] of check.input_paths.entries()) {
         const normalized = assertRepositoryPattern(repository, pattern, `${check.key}.input_paths[${index}]`);
         if (!baseline.files.some((file) => matchesRepoPattern(file.path, normalized)) &&
+            !protectedAuthorityFiles.some((file) => matchesRepoPattern(file, normalized)) &&
             !expectedOutputs.some((output) => classifyRepositoryPatternOverlap(output, normalized).status ===
                 "proven_overlap"))
             throw new Error(`input_path_not_found:${check.key}:${pattern}`);

package/dist/lib/long-task-semantic-contract-types.d.ts

@@ -42,7 +42,7 @@ export interface ClaimApplicabilityV2 {
     given_refs: string[];
     when_refs: string[];
 }
-export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "external_side_effect" | "failure_injection" | "visual_render" | "design_conformance" | "design_method" | "semantic_fact" | "target_runtime" | "input_variation";
+export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "external_side_effect" | "failure_injection" | "visual_render" | "design_conformance" | "design_method" | "design_symbolic_certificate" | "semantic_fact" | "target_runtime" | "input_variation";
 export interface CheckExecutionTargetV2 {
     target_ref: string;
     entrypoint: "root" | "internal";

package/dist/lib/long-task-semantic-fact-binding-types.d.ts

@@ -8,11 +8,13 @@ export interface SemanticFactManifestRefV2 {
 }
 export interface SemanticFactBindingV2 {
     fact_ref: string;
+    fact_revision_digest?: string;
     claim_ref: string;
     applicability_ref: string;
 }
 export type SemanticFactProofBindingV2 = {
     proof_ref: string;
+    obligation_revision_digest?: string;
     fact_ref: string;
     method: string;
     proof_surface: ProofSurface;
@@ -22,6 +24,7 @@ export type SemanticFactProofBindingV2 = {
     assertion_ref: string;
 } | {
     proof_ref: string;
+    obligation_revision_digest?: string;
     fact_ref: string;
     method: string;
     proof_surface: ProofSurface;
@@ -37,6 +40,11 @@ export interface SemanticFactOutcomeBindingsV2 {
 export interface SemanticFactExpectationV2 {
     manifest_ref: string;
     manifest_sha256: string;
+    fact_key: string;
+    fact_revision_digest: string;
+    obligation_key: string;
+    obligation_revision_digest: string;
+    revision_identity_required: boolean;
     fact_ref: string;
     proof_ref: string;
     method: string;

package/dist/lib/long-task-semantic-fact-closure.js

@@ -14,7 +14,10 @@ export async function validateLongTaskSemanticFactClosure(contract, repository,
     await validateSemanticFactInputInventory(repository, sourceItems, contextFiles, manifest, designOwnedSourceItems);
     validateSemanticFactBasisClosure(manifest, sourceItems);
     await validateSemanticFactLocatedValues(repository, manifest, sourceItems);
-    const expectations = validateSemanticFactContractProjection(contract, manifest, index);
+    const expectations = validateSemanticFactContractProjection(contract, manifest, index, new Map(parsed.fact_revisions.map((item) => [item.key, item.revision_digest])), new Map(parsed.obligation_revisions.map((item) => [
+        item.key,
+        item.revision_digest,
+    ])), parsed.carrier === "compact_v1");
     return {
         manifest,
         manifest_sha256: parsed.sha256,

package/dist/lib/long-task-semantic-fact-contract-closure.d.ts

@@ -1,4 +1,4 @@
 import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
 import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
 import type { SemanticFactExpectationV2, SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function validateSemanticFactContractProjection(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1): Map<string, SemanticFactExpectationV2[]>;
+export declare function validateSemanticFactContractProjection(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, factRevisions: Map<string, string>, obligationRevisions: Map<string, string>, sourceRequiresRevisions: boolean): Map<string, SemanticFactExpectationV2[]>;