project-tiny-context-harness 0.8.12 → 0.8.13

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

@@ -0,0 +1,117 @@
+import { assertJsonTree, decodeUtf8Json, JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, observationErrorMessage, parseJsonWithoutDuplicateKeys, resolveJsonPointer, validateJsonPointerExactLocator, } from "./long-task-json-pointer-observation.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export const PRODUCT_OBSERVATION_SCHEMA_VERSION = "ty-context-product-observation-v1";
+export function decodeProductObservationEnvelope(input) {
+    let artifactSha256;
+    let parsed;
+    try {
+        if (input.bytes.byteLength > JSON_POINTER_EXACT_LIMITS.max_file_bytes)
+            throw new Error("observation_artifact_size_limit");
+        const strict = parseJsonWithoutDuplicateKeys(decodeUtf8Json(input.bytes));
+        assertJsonTree(strict, 0);
+        parsed = record(strict);
+        artifactSha256 = sha256Hex(input.bytes);
+    }
+    catch (error) {
+        throw invalid(`process_observation_decode_invalid:${observationErrorMessage(error)}`);
+    }
+    requireExactKeys(parsed, ["observations", "schema_version"]);
+    if (parsed.schema_version !== PRODUCT_OBSERVATION_SCHEMA_VERSION)
+        throw invalid("process_observation_schema_invalid");
+    const observations = record(parsed.observations);
+    const expectedIdentities = expectedObservationIdentities(input.authorities);
+    const actualIdentities = Object.keys(observations).sort();
+    if (!sameStrings(actualIdentities, expectedIdentities))
+        throw invalid(`process_observation_identity_set_mismatch:expected=${expectedIdentities.join(",")}:actual=${actualIdentities.join(",")}`);
+    if (expectedIdentities.length >
+        JSON_POINTER_EXACT_LIMITS.max_artifacts_per_check)
+        throw invalid("process_observation_identity_count_limit");
+    const valueSha256 = {};
+    const packageObservations = [];
+    for (const observationIdentity of expectedIdentities) {
+        const pointer = observationPointer(observationIdentity);
+        try {
+            validateJsonPointerExactLocator({ kind: "json_pointer", value: pointer });
+        }
+        catch (error) {
+            throw invalid(`process_observation_decode_invalid:${observationErrorMessage(error)}`);
+        }
+        for (const authority of input.authorities)
+            if (authority.observation_identity === observationIdentity &&
+                (authority.authority !== "package_process_json_exact" ||
+                    authority.locator_policy.kind !== "fixed_json_pointer" ||
+                    authority.locator_policy.value !== pointer))
+                throw invalid("process_observation_authority_invalid");
+        let rawValue;
+        try {
+            rawValue = resolveJsonPointer(parsed, pointer);
+        }
+        catch (error) {
+            throw invalid(`process_observation_decode_invalid:${observationErrorMessage(error)}`);
+        }
+        const canonical = canonicalValueJson(rawValue);
+        if (Buffer.byteLength(canonical, "utf8") >
+            JSON_POINTER_EXACT_LIMITS.max_canonical_value_bytes)
+            throw invalid("process_observation_value_size_limit");
+        valueSha256[observationIdentity] = sha256Hex(canonical);
+        for (const authority of input.authorities.filter((candidate) => candidate.observation_identity === observationIdentity))
+            packageObservations.push({
+                authority: "package_process_json_exact",
+                observation_identity: observationIdentity,
+                assertion_ref: authority.assertion_ref,
+                obligation_ref: authority.obligation_ref,
+                method: authority.method,
+                raw_value: rawValue,
+                observation: {
+                    capability: JSON_POINTER_EXACT_CAPABILITY,
+                    artifact_path: "process.stdout.json",
+                    artifact_sha256: artifactSha256,
+                    locator: { kind: "json_pointer", value: pointer },
+                    value_sha256: valueSha256[observationIdentity],
+                    canonical_value_bytes: Buffer.byteLength(canonical, "utf8"),
+                    sensitivity: "plain",
+                },
+                reason: null,
+            });
+    }
+    return {
+        schema_version: PRODUCT_OBSERVATION_SCHEMA_VERSION,
+        artifact_sha256: artifactSha256,
+        observations,
+        value_sha256_by_identity: valueSha256,
+        package_observations: packageObservations,
+    };
+}
+function expectedObservationIdentities(authorities) {
+    if (!authorities.length)
+        throw invalid("process_observation_authority_required");
+    const identities = new Set();
+    for (const authority of authorities) {
+        if (authority.authority !== "package_process_json_exact")
+            throw invalid("process_observation_authority_invalid");
+        if (!authority.observation_identity)
+            throw invalid("process_observation_identity_invalid");
+        identities.add(authority.observation_identity);
+    }
+    return [...identities].sort();
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw invalid("process_observation_object_required");
+    return value;
+}
+function requireExactKeys(value, expected) {
+    const actual = Object.keys(value).sort();
+    if (!sameStrings(actual, [...expected].sort()))
+        throw invalid("process_observation_envelope_fields_invalid");
+}
+function observationPointer(identityValue) {
+    return `/observations/${identityValue.replace(/~/gu, "~0").replace(/\//gu, "~1")}`;
+}
+function sameStrings(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}
+function invalid(code) {
+    return new Error(code);
+}

package/dist/lib/long-task-process-runtime-closure.d.ts

@@ -0,0 +1,13 @@
+import type { CompiledObservationAuthorityV2, CompiledProcessRuntimeClosureV2, DeliveryCheckV2, ExecutionTargetV2, FrozenRunnerV2, SourceBackedExecutionTargetV2 } from "./long-task-delivery-types.js";
+import type { ScopedDeliveryBindingV2 } from "./long-task-scoped-binding.js";
+export interface CompileProcessRuntimeClosureInput {
+    check: DeliveryCheckV2;
+    runner: FrozenRunnerV2;
+    execution_target: ExecutionTargetV2;
+    observation_authorities: readonly CompiledObservationAuthorityV2[];
+    production_bindings: readonly ScopedDeliveryBindingV2[];
+    production_owner_paths: readonly string[];
+    source_backed_execution_target: SourceBackedExecutionTargetV2 | null;
+    protected_authority_paths: readonly string[];
+}
+export declare function compileProcessRuntimeClosure(input: CompileProcessRuntimeClosureInput): CompiledProcessRuntimeClosureV2 | null;

package/dist/lib/long-task-process-runtime-closure.js

@@ -0,0 +1,175 @@
+import path from "node:path";
+import { matchesRepoPattern, normalizeRepositoryFile, } from "./long-task-paths.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function compileProcessRuntimeClosure(input) {
+    const processAuthorities = input.observation_authorities.filter((authority) => authority.authority === "package_process_json_exact");
+    if (!processAuthorities.length)
+        return null;
+    const targetRef = input.execution_target.key;
+    const sourceTarget = input.source_backed_execution_target;
+    if (!sourceTarget || sourceTarget.target_ref !== targetRef)
+        fail("process_root_source_binding_required", targetRef);
+    const rootTarget = normalizeRepositoryFile(input.execution_target.root_entrypoint, `${input.check.key}.process_root`);
+    const productionBindings = [...input.production_bindings];
+    requireProductionOwnership(input, rootTarget, targetRef);
+    const rootBindings = bindingsContaining(productionBindings, rootTarget);
+    if (!rootBindings.length)
+        fail("process_root_production_binding_required", `${targetRef}:${rootTarget}`);
+    const rootArgvFiles = argvAttributedRepositoryFiles(input.execution_target.root_argv ?? [], input.runner.resolved_cwd, productionBindings, targetRef);
+    const selectedBindings = new Map();
+    for (const binding of rootBindings)
+        selectBinding(selectedBindings, binding);
+    for (const argvFile of rootArgvFiles) {
+        requireProductionOwnership(input, argvFile, targetRef);
+        const bindings = bindingsContaining(productionBindings, argvFile);
+        if (!bindings.length)
+            fail("process_root_production_binding_required", `${targetRef}:${argvFile}`);
+        for (const binding of bindings)
+            selectBinding(selectedBindings, binding);
+    }
+    const productionCarrierFiles = new Set();
+    for (const carrierRef of processAuthorities.flatMap((authority) => authority.carrier_refs)) {
+        const matchingBindings = productionBindings.filter((scoped) => scoped.binding_ref === carrierRef.binding_ref &&
+            carrierRef.carrier_paths.every((carrierPath) => scoped.binding.carrier_paths.includes(carrierPath)));
+        if (!matchingBindings.length)
+            fail("process_root_production_binding_required", `${targetRef}:${carrierRef.binding_ref}`);
+        for (const binding of matchingBindings) {
+            selectBinding(selectedBindings, binding);
+            for (const carrierPath of carrierRef.carrier_paths) {
+                let carrierFile;
+                try {
+                    carrierFile = normalizeRepositoryFile(carrierPath, `${input.check.key}.process_carrier`);
+                }
+                catch {
+                    fail("process_runtime_carrier_exact_path_required", `${targetRef}:${carrierRef.binding_ref}:${carrierPath}`);
+                }
+                productionCarrierFiles.add(carrierFile);
+            }
+        }
+    }
+    const allowedRuntimeFiles = new Set([rootTarget, ...rootArgvFiles]);
+    for (const file of productionCarrierFiles)
+        allowedRuntimeFiles.add(file);
+    for (const file of allowedRuntimeFiles) {
+        requireProductionOwnership(input, file, targetRef);
+        validateConcreteRoleSeparation(input, file);
+    }
+    const projection = {
+        target_ref: targetRef,
+        source_target: sourceTarget,
+        root_target: rootTarget,
+        root_argv_files: [...new Set(rootArgvFiles)].sort(),
+        production_carrier_files: [...productionCarrierFiles].sort(),
+        allowed_runtime_files: [...allowedRuntimeFiles].sort(),
+        production_binding_refs: [...selectedBindings.keys()].sort(),
+        forbidden_role_matches: [],
+    };
+    return {
+        ...projection,
+        closure_identity: sha256Hex(canonicalValueJson(runtimeExecutionClosureProjection(projection))),
+    };
+}
+function runtimeExecutionClosureProjection(closure) {
+    return {
+        target_ref: closure.target_ref,
+        source_target: closure.source_target,
+        root_target: closure.root_target,
+        root_argv_files: closure.root_argv_files,
+        production_carrier_files: closure.production_carrier_files,
+        allowed_runtime_files: closure.allowed_runtime_files,
+        forbidden_role_matches: closure.forbidden_role_matches,
+    };
+}
+function validateConcreteRoleSeparation(input, file) {
+    const expected = firstMatchingPattern(file, input.protected_authority_paths);
+    if (expected)
+        fail("process_runtime_input_expected_authority_forbidden", `${input.check.key}:${file}:${expected}`);
+    const verification = firstMatchingPattern(file, input.check.verification_inputs);
+    if (verification)
+        fail("process_runtime_input_verification_role_forbidden", `${input.check.key}:${file}:${verification}`);
+    const evidence = firstMatchingPattern(file, [
+        ...input.check.expected_output_paths,
+        ...input.check.artifact_globs,
+    ]);
+    if (evidence)
+        fail("process_runtime_input_evidence_role_forbidden", `${input.check.key}:${file}:${evidence}`);
+}
+function requireProductionOwnership(input, file, targetRef) {
+    if (!input.production_owner_paths.some((pattern) => matchesRepoPattern(file, pattern)))
+        fail("process_root_production_binding_required", `${targetRef}:${file}:production_owner`);
+}
+function bindingsContaining(bindings, file) {
+    return bindings.filter((scoped) => scoped.binding.carrier_paths.some((pattern) => matchesRepoPattern(file, pattern)));
+}
+function selectBinding(selected, scoped) {
+    const existing = selected.get(scoped.binding_ref);
+    if (existing && canonicalValueJson(existing) !== canonicalValueJson(scoped))
+        fail("process_root_production_binding_required", `${scoped.binding_ref}:ambiguous`);
+    selected.set(scoped.binding_ref, scoped);
+}
+function argvAttributedRepositoryFiles(argv, cwd, bindings, targetRef) {
+    const result = new Set();
+    for (const argument of argv) {
+        const value = rootArgvPathValue(argument);
+        if (!value)
+            continue;
+        if (unsafeArgvPathValue(value))
+            fail("process_root_argv_unsafe", `${targetRef}:${argument}`);
+        const candidate = path.posix.join(cwd === "." ? "" : cwd, value);
+        let normalized;
+        try {
+            normalized = normalizeRepositoryFile(candidate, "process_root_argv");
+        }
+        catch {
+            fail("process_root_argv_unsafe", `${targetRef}:${argument}`);
+        }
+        if (bindingsContaining(bindings, normalized).length)
+            result.add(normalized);
+    }
+    return [...result].sort();
+}
+function rootArgvPathValue(argument) {
+    const parsedArgument = unwrapCompleteQuoteLayer(argument.replace(/\\/gu, "/"));
+    const portable = parsedArgument.value;
+    if (!portable)
+        return null;
+    // A compound shell command is not one finite argv file token. In
+    // particular, do not search inside it for a path-shaped substring.
+    if (!parsedArgument.quoted && /\s/u.test(portable))
+        return null;
+    // A single-letter slash switch is an argv label (for example cmd.exe /d),
+    // not a repository path. Longer slash-prefixed values remain absolute and
+    // fail closed below.
+    if (/^\/[A-Za-z?]$/u.test(portable))
+        return null;
+    if (!portable.startsWith("--"))
+        return portable;
+    const separator = portable.indexOf("=");
+    if (separator <= 2 || separator === portable.length - 1)
+        return null;
+    const parsedValue = unwrapCompleteQuoteLayer(portable.slice(separator + 1));
+    if (!parsedValue.value)
+        return null;
+    if (!parsedValue.quoted && /\s/u.test(parsedValue.value))
+        return null;
+    return parsedValue.value;
+}
+function unwrapCompleteQuoteLayer(value) {
+    const quote = value[0];
+    if ((quote === '"' || quote === "'") && value.at(-1) === quote)
+        return { value: value.slice(1, -1), quoted: true };
+    return { value, quoted: false };
+}
+function unsafeArgvPathValue(value) {
+    return (/["']/u.test(value) ||
+        value.startsWith("/") ||
+        /^[A-Za-z]:\//u.test(value) ||
+        /^file:/iu.test(value) ||
+        /^[A-Za-z][A-Za-z0-9+.-]*:\/\//u.test(value));
+}
+function firstMatchingPattern(file, patterns) {
+    return patterns.find((pattern) => matchesRepoPattern(file, pattern)) ?? null;
+}
+function fail(code, detail) {
+    throw new Error(`${code}:${detail}`);
+}

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

@@ -81,6 +81,8 @@ export function checkIdentity(check) {
         execution_target_definition: check.execution_target_definition,
         scenario: check.scenario,
         environment_requirements: check.environment_requirements,
+        observation_authorities: check.observation_authorities,
+        process_runtime_closure: check.process_runtime_closure,
     }));
 }
 function runnerVerifierIdentity(compiled, check) {

package/dist/lib/long-task-protected-files.d.ts

@@ -1 +1 @@
-export declare function assertProtectedRepositoryFile(repositoryInput: string, fileInput: string, label: string): Promise<string>;
+export { assertProtectedRepositoryFile } from "./repository-path-safety.js";

package/dist/lib/long-task-protected-files.js

@@ -1,30 +1 @@
-import { lstat, realpath } from "node:fs/promises";
-import path from "node:path";
-export async function assertProtectedRepositoryFile(repositoryInput, fileInput, label) {
-    const repositoryPath = path.resolve(repositoryInput);
-    const repository = await realpath(repositoryPath);
-    const candidate = path.resolve(fileInput);
-    assertInside(repositoryPath, candidate, label, fileInput);
-    const info = await lstat(candidate).catch(() => null);
-    if (!info)
-        throw new Error(`protected_input_not_found:${label}:${display(fileInput)}`);
-    if (info.isSymbolicLink())
-        throw new Error(`protected_input_symlink_not_allowed:${label}:${display(fileInput)}`);
-    if (!info.isFile())
-        throw new Error(`protected_input_not_regular_file:${label}:${display(fileInput)}`);
-    const resolved = await realpath(candidate);
-    assertInside(repository, resolved, label, fileInput);
-    if (typeof info.nlink === "number" && info.nlink > 1)
-        throw new Error(`protected_input_hardlink_not_allowed:${label}:${display(fileInput)}`);
-    return resolved;
-}
-function assertInside(repository, candidate, label, original) {
-    const relative = path.relative(repository, candidate);
-    if (relative === ".." ||
-        relative.startsWith(`..${path.sep}`) ||
-        path.isAbsolute(relative))
-        throw new Error(`protected_input_realpath_outside_repository:${label}:${display(original)}`);
-}
-function display(file) {
-    return file.replace(/\\/gu, "/");
-}
+export { assertProtectedRepositoryFile } from "./repository-path-safety.js";

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

@@ -1,3 +1,4 @@
+import { outcomeResultExternallyBlocked } from "./long-task-claims.js";
 const STRICT_FACTS = new Set([
     "public_api_or_schema_change",
     "persistent_data_change",
@@ -45,15 +46,16 @@ export function validateRiskProof(contract, decision) {
     for (const check of contract.global.acceptance.checks)
         validateCheck(check, "global", errors);
     for (const outcome of contract.outcomes)
-        validateOutcome(outcome, errors);
+        validateOutcome(contract, outcome, errors);
     if (decision.effective_level === "strict")
         validateStrict(contract, decision, errors);
     if (errors.length)
         throw new Error(`delivery_contract_preflight_failed:\n${errors.join("\n")}`);
 }
-function validateOutcome(outcome, errors) {
+function validateOutcome(contract, outcome, errors) {
     const checks = new Map(outcome.acceptance.checks.map((check) => [check.key, check]));
-    if (!checks.size)
+    const resultExternallyBlocked = outcomeResultExternallyBlocked(contract, outcome.key);
+    if (!checks.size && !resultExternallyBlocked)
         errors.push(`outcome_without_executable_check:${outcome.key}`);
     if (!outcome.technical.expected_change_paths.length)
         errors.push(`expected_change_paths_empty:${outcome.key}`);
@@ -61,6 +63,7 @@ function validateOutcome(outcome, errors) {
         validateCheck(check, outcome.key, errors);
     if ((outcome.product.owner_surfaces.length ||
         outcome.product.controls.length) &&
+        !resultExternallyBlocked &&
         ![...checks.values()].some((check) => check.proof_surface === "ui_browser"))
         errors.push(`ui_outcome_requires_ui_browser_proof:${outcome.key}`);
     const referenced = [
@@ -78,6 +81,8 @@ function validateOutcome(outcome, errors) {
 function validateStrict(contract, decision, errors) {
     const explicitStrictWithoutFacts = contract.risk.requested_level === "strict" && decision.reasons.length === 0;
     for (const outcome of contract.outcomes) {
+        if (outcomeResultExternallyBlocked(contract, outcome.key))
+            continue;
         const facts = new Set(decision.reasons_by_outcome[outcome.key]);
         const checks = outcome.acceptance.checks;
         const hasNegative = checks.some((check) => check.negative_assertions.length > 0);

package/dist/lib/long-task-root-shape.js

@@ -53,7 +53,7 @@ export function parseTask(value) {
                 "runtime_family",
                 "root_entrypoint",
                 "capabilities",
-            ]);
+            ], ["root_argv"]);
             return {
                 key: key(target.key, `${label}.key`),
                 description: string(target.description, `${label}.description`),
@@ -67,6 +67,15 @@ export function parseTask(value) {
                     "external",
                 ], `${label}.runtime_family`),
                 root_entrypoint: string(target.root_entrypoint, `${label}.root_entrypoint`),
+                ...(Object.hasOwn(target, "root_argv")
+                    ? {
+                        root_argv: strings(target.root_argv, `${label}.root_argv`).map((argument, argumentIndex) => {
+                            if (argument.includes("\0"))
+                                throw new Error(`delivery_contract_invalid:execution_target_root_argv_invalid:${label}:${argumentIndex}`);
+                            return argument;
+                        }),
+                    }
+                    : {}),
                 capabilities: strings(target.capabilities, `${label}.capabilities`).map((item, capabilityIndex) => literal(item, EXECUTION_TARGET_CAPABILITIES, `${label}.capabilities[${capabilityIndex}]`)),
             };
         }),

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

@@ -1,5 +1,5 @@
 import type { EnvironmentRequirementV2 } from "./long-task-delivery-types.js";
-export declare function runnerEnvironment(requirements: EnvironmentRequirementV2[]): NodeJS.ProcessEnv;
+export declare function runnerEnvironment(requirements: EnvironmentRequirementV2[], mode?: "legacy_check" | "product_observation"): NodeJS.ProcessEnv;
 export declare function declaredEnvironmentValues(requirements: EnvironmentRequirementV2[]): string[];
 export declare function outputContainsDeclaredEnvironmentValue(raw: {
     stdout: Buffer;

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

@@ -21,10 +21,10 @@ const BASE_ENVIRONMENT_KEYS = [
     "NO_COLOR",
     "FORCE_COLOR",
 ];
-export function runnerEnvironment(requirements) {
-    const environment = {
-        TY_CONTEXT_CHECK_PROTOCOL: "long-task-check-result-v3",
-    };
+export function runnerEnvironment(requirements, mode = "legacy_check") {
+    const environment = {};
+    if (mode === "legacy_check")
+        environment.TY_CONTEXT_CHECK_PROTOCOL = "long-task-check-result-v3";
     for (const key of BASE_ENVIRONMENT_KEYS)
         copyEnvironmentValue(environment, key);
     for (const requirement of requirements)

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

@@ -1,2 +1,4 @@
-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[], protectedAuthorityPaths?: readonly string[]): Promise<CompiledCheckV2>;
+import type { CompiledCheckV2, CompiledDesignTargetV2, DeliveryCheckV2, ExecutionTargetV2, SemanticFactExpectationV2, SourceBackedExecutionTargetV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+import type { ScopedDeliveryBindingV2 } from "./long-task-scoped-binding.js";
+export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[], designConformanceTargets: CompiledDesignTargetV2[], semanticFactExpectations: SemanticFactExpectationV2[], productionBindings: ScopedDeliveryBindingV2[], productionOwnerPaths: string[], sourceBackedExecutionTarget: SourceBackedExecutionTargetV2 | null, protectedAuthorityPaths?: readonly string[]): Promise<CompiledCheckV2>;
+export declare function playwrightConfigArgument(argv: readonly string[]): string | null;