project-tiny-context-harness 0.8.1 → 0.8.2

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

@@ -319,8 +319,8 @@ function nextAction(status) {
     if (status.ready_outcomes.length) {
         const outcome = status.ready_outcomes[0];
         if (status.outcomes[outcome] === "progress_stale")
-            return `Targeted evidence for ready Outcome ${outcome} is stale. This is a freshness fact, not an immediate per-edit rerun instruction: coalesce relevant changes, use the cheapest reliable project-owned feedback, and refresh the declared Check before relying on this Outcome or entering Final Gate.`;
-        return `Implement and verify ready Outcome: ${outcome}.`;
+            return `Targeted evidence for Outcome ${outcome} on the acceptance/verification frontier is stale. This is a freshness fact, not an implementation gate or immediate per-edit rerun instruction: coalesce relevant changes and refresh the cheapest reliable declared Check only before relying on this Progress. Implementation may continue, and Final Gate needs no targeted refresh because it reruns every Check.`;
+        return `Outcome ${outcome} is on the advisory acceptance/verification frontier. Implementation order remains Goal-owned; run its declared Check when the feedback value justifies the cost, or continue in-scope implementation before the complete Final Gate.`;
     }
     return "Create a clean candidate commit; Stop will run the authoritative Live Final Gate.";
 }

package/dist/lib/long-task-target-policy.js

@@ -1,3 +1,11 @@
+const FAMILY_CAPABILITY = {
+    browser: "browser-runtime",
+    native: "native-runtime",
+    desktop: "desktop-runtime",
+    service: "service-runtime",
+    process: "process-runtime",
+    external: "external-runtime",
+};
 export function validateExecutionTargets(contract, report) {
     const targets = indexExecutionTargets(contract, report);
     const requiredTargetRefs = contract.task.target_profile.required_target_refs;
@@ -12,6 +20,13 @@ function indexExecutionTargets(contract, report) {
         if (targets.has(target.key))
             issue(report, "execution_target_key_duplicate", target.key);
         targets.set(target.key, target);
+        if (!target.capabilities.length)
+            issue(report, "execution_target_capability_required", target.key);
+        if (new Set(target.capabilities).size !== target.capabilities.length)
+            issue(report, "execution_target_capability_duplicate", target.key);
+        const familyCapability = FAMILY_CAPABILITY[target.runtime_family];
+        if (!target.capabilities.includes(familyCapability))
+            issue(report, "execution_target_family_capability_required", `${target.key}:${familyCapability}`);
     }
     if (![...targets.values()].some((target) => target.role === "product"))
         issue(report, "product_execution_target_required", contract.task.id);
@@ -29,6 +44,11 @@ function validateRequiredTargetRefs(contract, targets, report) {
             issue(report, "target_profile_required_target_ref_unknown", targetRef);
         else if (target.role !== "product")
             issue(report, "target_profile_required_target_must_be_product", targetRef);
+        else {
+            for (const capability of ["cold-start", "production-root"])
+                if (!target.capabilities.includes(capability))
+                    issue(report, "required_target_capability_missing", `${targetRef}:${capability}`);
+        }
     }
 }
 function validateCheckTarget(outcomeKey, check, targets, report) {

package/dist/lib/long-task-ui-design-policy.js

@@ -18,6 +18,7 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
         unique(target.verification_method_bindings.map((item) => item.assertion_ref), "ui_design_target_verification_assertion_duplicate", label, report);
         if (!target.verification_method_bindings.length)
             issue(report, "ui_design_target_verification_methods_required", label);
+        const methodArtifactPaths = new Set();
         for (const [name, values] of [
             ["source_paths", target.source_paths],
             ["condition_keys", target.condition_keys],
@@ -49,12 +50,37 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
                 issue(report, "ui_design_target_assertion_duplicate", `${label}:${methodBinding.assertion_ref}`);
             if (methodBinding.assertion_ref !== target.conformance_assertion_ref)
                 designAssertionRefs.add(identity);
-            if (!check.positive_assertions.some((item) => item.key === methodBinding.assertion_ref))
+            const methodAssertion = check.positive_assertions.find((item) => item.key === methodBinding.assertion_ref);
+            if (!methodAssertion)
                 issue(report, "ui_design_target_verification_assertion_unknown", `${label}:${methodBinding.method}:${methodBinding.assertion_ref}`);
+            else if (!methodAssertion.evidence_capabilities.includes("design_method"))
+                issue(report, "ui_design_target_verification_capability_required", `${label}:${methodBinding.method}:design_method`);
+            const conditionKeys = methodBinding.evidence_artifacts.map((item) => item.condition_key);
+            unique(conditionKeys, "ui_design_method_evidence_condition_duplicate", `${label}:${methodBinding.method}`, report);
+            if (!sameSet(conditionKeys, target.condition_keys))
+                issue(report, "ui_design_method_evidence_conditions_mismatch", `${label}:${methodBinding.method}`);
+            for (const artifact of methodBinding.evidence_artifacts) {
+                for (const [kind, artifactPath] of [
+                    ["record", artifact.path],
+                    ["observation", artifact.observation_path],
+                ]) {
+                    if (methodArtifactPaths.has(artifactPath))
+                        issue(report, "ui_design_method_evidence_artifact_reused", `${label}:${kind}:${artifactPath}`);
+                    methodArtifactPaths.add(artifactPath);
+                    if (!check.artifact_globs.some((pattern) => matchesRepoPattern(artifactPath, pattern)))
+                        issue(report, "ui_design_method_evidence_artifact_glob_missing", `${label}:${methodBinding.method}:${kind}:${artifactPath}`);
+                }
+            }
         }
         validateDesignFiles(target, check, label, report);
     }
 }
+function sameSet(left, right) {
+    const leftSet = [...new Set(left)].sort();
+    const rightSet = [...new Set(right)].sort();
+    return (leftSet.length === rightSet.length &&
+        leftSet.every((value, index) => value === rightSet[index]));
+}
 function validateDesignAssertion(target, check, label, report) {
     const assertion = check.positive_assertions.find((item) => item.key === target.conformance_assertion_ref);
     if (!assertion) {

package/dist/lib/long-task-ui-surface-shape.js

@@ -1,4 +1,5 @@
 import { DESIGN_RESOURCE_VERIFICATION_METHODS } from "./design-resource-handoff-types.js";
+import { EXECUTION_TARGET_CAPABILITIES } from "./execution-target-capabilities.js";
 import { array, key, literal, object, repositoryFile, repositoryFiles, string, strings, } from "./long-task-shape-primitives.js";
 export function parseSurfaceBindings(value, label) {
     return array(value, label).map((item, index) => {
@@ -67,6 +68,7 @@ function parseAcceptanceBlockers(value, label) {
             "refs",
             "source_item_refs",
             "verification_methods",
+            "required_capabilities",
             "rationale",
         ]);
         return {
@@ -75,6 +77,7 @@ function parseAcceptanceBlockers(value, label) {
             refs: strings(row.refs, `${itemLabel}.refs`),
             source_item_refs: strings(row.source_item_refs, `${itemLabel}.source_item_refs`),
             verification_methods: array(row.verification_methods, `${itemLabel}.verification_methods`).map((method, methodIndex) => literal(method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${itemLabel}.verification_methods[${methodIndex}]`)),
+            required_capabilities: array(row.required_capabilities, `${itemLabel}.required_capabilities`).map((capability, capabilityIndex) => literal(capability, EXECUTION_TARGET_CAPABILITIES, `${itemLabel}.required_capabilities[${capabilityIndex}]`)),
             rationale: string(row.rationale, `${itemLabel}.rationale`),
         };
     });
@@ -82,10 +85,27 @@ function parseAcceptanceBlockers(value, label) {
 function parseVerificationMethodBindings(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["method", "assertion_ref"]);
+        const row = object(item, itemLabel, [
+            "method",
+            "assertion_ref",
+            "evidence_artifacts",
+        ]);
         return {
             method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${itemLabel}.method`),
             assertion_ref: key(row.assertion_ref, `${itemLabel}.assertion_ref`),
+            evidence_artifacts: array(row.evidence_artifacts, `${itemLabel}.evidence_artifacts`).map((artifact, artifactIndex) => {
+                const artifactLabel = `${itemLabel}.evidence_artifacts[${artifactIndex}]`;
+                const entry = object(artifact, artifactLabel, [
+                    "condition_key",
+                    "path",
+                    "observation_path",
+                ]);
+                return {
+                    condition_key: key(entry.condition_key, `${artifactLabel}.condition_key`),
+                    path: repositoryFile(entry.path, `${artifactLabel}.path`),
+                    observation_path: repositoryFile(entry.observation_path, `${artifactLabel}.observation_path`),
+                };
+            }),
         };
     });
 }

package/dist/lib/long-task-ui-surface-types.d.ts

@@ -1,8 +1,14 @@
 import type { DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
+import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
 export type DesignTargetInterpretationV2 = "exact_target" | "constraint";
 export interface DeliveryDesignVerificationBindingV2 {
     method: DesignResourceVerificationMethod;
     assertion_ref: string;
+    evidence_artifacts: Array<{
+        condition_key: string;
+        path: string;
+        observation_path: string;
+    }>;
 }
 export interface DeliveryDesignTargetV2 {
     key: string;
@@ -23,6 +29,7 @@ export interface DeliveryDesignAcceptanceBlockerV2 {
     refs: string[];
     source_item_refs: string[];
     verification_methods: DesignResourceVerificationMethod[];
+    required_capabilities: ExecutionTargetCapabilityV2[];
     rationale: string;
 }
 export interface DeliverySurfaceBindingV2 {

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

@@ -40,6 +40,16 @@ interface CounterfactualExecutionPreviewV1 {
         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;
 }

package/dist/lib/long-task-verifier-dependency-closure.d.ts

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

@@ -0,0 +1,179 @@
+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));
+    return base === ".." || base.startsWith("../") ? null : base;
+}
+function runtimePatternOwns(base, pattern) {
+    return (matchesRepoPattern(base, pattern) ||
+        classifyRepositoryPatternOverlap(`${base}/**`, 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-v2.js

@@ -109,8 +109,17 @@ export async function runDeliveryChecks(compiled, snapshot, checks, includeCount
     }
     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)
+            .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)));
@@ -119,7 +128,8 @@ export async function runDeliveryChecks(compiled, snapshot, checks, includeCount
             .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)
+                .filter((check) => check.outcome_key === outcome.key &&
+                passingCheckIds.has(check.internal_id))
                 .map((check) => check.key));
             counterfactualFindings.push(...(await evaluateOutcomeCounterfactuals({
                 ...outcome,

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

@@ -4,7 +4,11 @@ import os from "node:os";
 import path from "node:path";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 export async function repositoryRoot(start) {
-    return path.resolve(await gitOutput(path.resolve(start), ["rev-parse", "--show-toplevel"]));
+    const resolved = path.resolve(start);
+    const gitEntry = await stat(path.join(resolved, ".git")).catch(() => null);
+    if (gitEntry?.isDirectory() || gitEntry?.isFile())
+        return resolved;
+    return path.resolve(await gitOutput(resolved, ["rev-parse", "--show-toplevel"]));
 }
 export async function gitCommonDir(root) {
     return path.resolve(await gitOutput(root, [