project-tiny-context-harness 0.8.17 → 0.11.0

package/dist/lib/long-task-obligation-semantic-identity.js

@@ -0,0 +1,116 @@
+import { findDesignFactObligation } from "./long-task-design-obligation.js";
+import { canonicalApplicabilityIdentity, claimApplicabilityProfile, } from "./long-task-applicability-identity.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function objectiveClaimSemanticIdentity(input) {
+    const authority = input.observation_authority;
+    const applicability = claimApplicabilityProfile(input.contract, input.outcome_key, input.applicability_ref);
+    const requiredCapabilities = [
+        ...new Set(input.required_evidence_capabilities),
+    ].sort();
+    if (!applicability ||
+        authority.fact_ref !== null ||
+        authority.claim_refs.length !== 1 ||
+        authority.claim_refs[0] !== input.local_claim_ref ||
+        authority.target_ref !== applicability.target_ref ||
+        authority.method !== input.method ||
+        !requiredCapabilities.every((capability) => authority.evidence_capabilities.includes(capability)) ||
+        !exactObservationAuthorityShape(authority))
+        return null;
+    return sha256Hex(canonicalValueJson({
+        claim_ref: input.claim_ref,
+        local_claim_ref: input.local_claim_ref,
+        applicability_identity: canonicalApplicabilityIdentity(applicability),
+        target_ref: applicability.target_ref,
+        required_polarity: input.required_polarity,
+        expected_authority_ref: input.expected_authority_ref,
+        expected_value_sha256: authority.expected_value_sha256,
+        actual_projection: authority.actual_projection,
+        method: input.method,
+        required_evidence_capabilities: requiredCapabilities,
+        comparison: authority.comparison,
+    }));
+}
+export function effectiveExternalObligationSemanticIdentity(input, expected) {
+    if (expected.semantic_identity)
+        return expected.semantic_identity;
+    const applicability = claimApplicabilityProfile(input.contract, expected.outcome_key, expected.applicability_ref);
+    if (!applicability)
+        return null;
+    const common = {
+        source_obligation_ref: expected.source_obligation_ref,
+        claim_ref: expected.claim_ref,
+        local_claim_ref: expected.local_claim_ref,
+        applicability_identity: canonicalApplicabilityIdentity(applicability),
+        target_ref: applicability.target_ref,
+        required_polarity: expected.required_polarity,
+        expected_authority_ref: expected.expected_authority_ref,
+        method: expected.method,
+        required_evidence_capabilities: [
+            ...new Set(expected.evidence_capabilities),
+        ].sort(),
+    };
+    if (expected.fact_ref && expected.proof_ref) {
+        const design = findDesignFactObligation(input.contract, expected);
+        if (design)
+            return sha256Hex(canonicalValueJson({
+                kind: "design_fact",
+                ...common,
+                design_obligation_ref: design.source_obligation_ref,
+                design_target_ref: design.target_key,
+                fact_ref: design.fact_ref,
+                proof_ref: design.source_obligation_ref,
+                expected_design_sha256: design.expected.sha256,
+                actual_projection: "raw_exact",
+                comparison: {
+                    comparator: design.comparison.comparator,
+                    mode: design.comparison.mode,
+                    parameters_sha256: design.comparison.parameters.sha256,
+                    tolerance_sha256: design.comparison.tolerance?.sha256 ?? null,
+                    mask_sha256: design.comparison.mask?.sha256 ?? null,
+                },
+            }));
+        const fact = input.manifest.facts.find((candidate) => candidate.key === expected.fact_ref);
+        const proof = input.manifest.proof_obligations.find((candidate) => candidate.key === expected.proof_ref &&
+            candidate.fact_ref === expected.fact_ref);
+        if (fact && proof)
+            return sha256Hex(canonicalValueJson({
+                kind: "semantic_fact",
+                ...common,
+                fact_ref: fact.key,
+                proof_ref: proof.key,
+                expected_value_sha256: fact.expected.sha256,
+                actual_projection: "raw_exact",
+                comparison: {
+                    comparator: proof.comparison.comparator,
+                    mode: proof.comparison.mode,
+                    parameters_sha256: proof.comparison.parameters.sha256,
+                    tolerance_sha256: proof.comparison.tolerance?.sha256 ?? null,
+                    mask_sha256: proof.comparison.mask?.sha256 ?? null,
+                },
+            }));
+        return null;
+    }
+    if (expected.fact_ref || expected.proof_ref)
+        return null;
+    return sha256Hex(canonicalValueJson({
+        kind: "source_delegated_judgment",
+        ...common,
+        expected_value_sha256: null,
+        actual_projection: null,
+        comparison: null,
+    }));
+}
+function exactObservationAuthorityShape(authority) {
+    return Boolean(typeof authority.expected_value_sha256 === "string" &&
+        /^[a-f0-9]{64}$/u.test(authority.expected_value_sha256) &&
+        typeof authority.actual_projection === "string" &&
+        authority.comparison &&
+        typeof authority.comparison.comparator === "string" &&
+        typeof authority.comparison.mode === "string" &&
+        sha256OrNull(authority.comparison.parameters_sha256) &&
+        sha256OrNull(authority.comparison.tolerance_sha256) &&
+        sha256OrNull(authority.comparison.mask_sha256));
+}
+function sha256OrNull(value) {
+    return value === null || /^[a-f0-9]{64}$/u.test(value);
+}

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

@@ -12,6 +12,17 @@ interface CompileObservationAuthorityPlanInput {
     source_backed_execution_target: SourceBackedExecutionTargetV2 | null;
     workspace_manifest: WorkspaceManifestV2;
     protected_authority_paths?: readonly string[];
+    external_design_obligation_refs?: ReadonlySet<string>;
+    external_claim_obligation_refs_by_assertion?: ReadonlyMap<string, string>;
 }
 export declare function compileObservationAuthorityPlan(input: CompileObservationAuthorityPlanInput): CompiledObservationAuthorityV2[];
+export declare function projectExternallyOwnedDesignAssertions(check: DeliveryCheckV2, designTargets: CompiledDesignTargetV2[], machineAuthorities: CompiledObservationAuthorityV2[], externalDesignObligationRefs: ReadonlySet<string>): {
+    check: DeliveryCheckV2;
+    removed_assertion_refs: Set<string>;
+};
+export declare function projectExternallyOwnedClaimAssertions(check: DeliveryCheckV2, observationAuthorities: CompiledObservationAuthorityV2[], externalClaimObligationRefsByAssertion: ReadonlyMap<string, string>): {
+    check: DeliveryCheckV2;
+    removed_assertion_refs: Set<string>;
+};
+export declare function assertionObligationRef(outcomeKey: string | null, checkKey: string, assertionKey: string): string;
 export {};

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

@@ -1,5 +1,6 @@
 import { JSON_POINTER_EXACT_METHODS, isJsonPointerExactOracle, } from "./long-task-json-pointer-observation.js";
 import { classifyMachineObservationCarrierRoleConflict } from "./long-task-admitted-observation.js";
+import { designGroundObligationRef } from "./long-task-design-obligation.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 import { classifyRepositoryPatternOverlap, normalizeRepositoryFile, } from "./long-task-paths.js";
 const PROCESS_DERIVED_CAPABILITIES = new Set([
@@ -106,7 +107,8 @@ export function compileObservationAuthorityPlan(input) {
         if (factBoundAssertions.has(assertion.key))
             continue;
         const expected = exactAssertionExpected(assertion);
-        const obligationRef = assertionObligationRef(input.outcome_key, input.check.key, assertion.key);
+        const obligationRef = input.external_claim_obligation_refs_by_assertion?.get(assertion.key) ??
+            assertionObligationRef(input.outcome_key, input.check.key, assertion.key);
         candidates.push({
             obligation_ref: obligationRef,
             observation_identity: obligationRef,
@@ -115,6 +117,7 @@ export function compileObservationAuthorityPlan(input) {
             target_ref: input.check.execution_target.target_ref,
             method: "exact_value",
             expected_value_sha256: sha256Hex(canonicalValueJson(expected)),
+            expected_value: expected,
             actual_projection: assertionActualProjection(assertion),
             comparison: {
                 comparator: "exact_value",
@@ -127,10 +130,89 @@ export function compileObservationAuthorityPlan(input) {
             diagnostic_scope: "assertion",
         });
     }
-    const rows = candidates.map((candidate) => compileCandidate(input, candidate));
+    const rows = candidates.flatMap((candidate) => {
+        try {
+            return [compileCandidate(input, candidate)];
+        }
+        catch (error) {
+            const exactExternalDesign = candidate.diagnostic_scope === "design_fact" &&
+                input.external_design_obligation_refs?.has(candidate.obligation_ref);
+            const exactExternalClaim = candidate.diagnostic_scope === "assertion" &&
+                input.external_claim_obligation_refs_by_assertion?.get(candidate.assertion.key) === candidate.obligation_ref;
+            if ((exactExternalDesign || exactExternalClaim) &&
+                externalizableObservationError(error))
+                return [compileExternalCandidate(input, candidate)];
+            throw error;
+        }
+    });
     assertUniqueRows(rows);
     return rows.sort((left, right) => canonicalValueJson(left).localeCompare(canonicalValueJson(right)));
 }
+export function projectExternallyOwnedDesignAssertions(check, designTargets, machineAuthorities, externalDesignObligationRefs) {
+    const obligationsByAssertion = new Map();
+    const add = (assertionRef, obligationRef) => {
+        const refs = obligationsByAssertion.get(assertionRef) ?? [];
+        refs.push(obligationRef);
+        obligationsByAssertion.set(assertionRef, refs);
+    };
+    for (const target of designTargets) {
+        for (const binding of target.verification_method_bindings)
+            for (const artifact of binding.evidence_artifacts)
+                for (const expectation of artifact.fact_expectations)
+                    add(binding.assertion_ref, designGroundObligationRef(target.key, binding.method, artifact.condition_key, expectation.fact_ref));
+        for (const binding of target.symbolic_method_bindings ?? [])
+            for (const expectation of binding.rule_expectations)
+                add(binding.assertion_ref, expectation.obligation_ref);
+    }
+    const machineRefs = new Set(machineAuthorities
+        .filter((authority) => authority.authority !== "external_confirmation")
+        .map((authority) => authority.obligation_ref));
+    const removed = new Set();
+    for (const [assertionRef, refs] of obligationsByAssertion) {
+        const externalRefs = refs.filter((ref) => externalDesignObligationRefs.has(ref));
+        if (!externalRefs.length)
+            continue;
+        const admittedMachineRefs = refs.filter((ref) => machineRefs.has(ref));
+        if (admittedMachineRefs.length === refs.length)
+            continue;
+        if (!admittedMachineRefs.length && externalRefs.length === refs.length) {
+            removed.add(assertionRef);
+            continue;
+        }
+        fail("mixed_machine_external_design_assertion", `${check.key}:${assertionRef}:${refs.join(",")}`);
+    }
+    if (!removed.size)
+        return { check, removed_assertion_refs: removed };
+    return {
+        check: {
+            ...check,
+            positive_assertions: check.positive_assertions.filter((assertion) => !removed.has(assertion.key)),
+            negative_assertions: check.negative_assertions.filter((assertion) => !removed.has(assertion.key)),
+        },
+        removed_assertion_refs: removed,
+    };
+}
+export function projectExternallyOwnedClaimAssertions(check, observationAuthorities, externalClaimObligationRefsByAssertion) {
+    const removed = new Set();
+    for (const [assertionRef, obligationRef,] of externalClaimObligationRefsByAssertion) {
+        const authorities = observationAuthorities.filter((authority) => authority.assertion_ref === assertionRef &&
+            authority.obligation_ref === obligationRef);
+        if (authorities.some((authority) => authority.authority !== "external_confirmation"))
+            continue;
+        if (authorities.some((authority) => authority.authority === "external_confirmation"))
+            removed.add(assertionRef);
+    }
+    if (!removed.size)
+        return { check, removed_assertion_refs: removed };
+    return {
+        check: {
+            ...check,
+            positive_assertions: check.positive_assertions.filter((assertion) => !removed.has(assertion.key)),
+            negative_assertions: check.negative_assertions.filter((assertion) => !removed.has(assertion.key)),
+        },
+        removed_assertion_refs: removed,
+    };
+}
 function compileCandidate(input, candidate) {
     const unimplementedDerivedCapability = candidate.assertion.evidence_capabilities.find((capability) => PROCESS_CAPABILITIES_REQUIRING_A_SEPARATE_PACKAGE_DERIVATION.has(capability));
     if (unimplementedDerivedCapability)
@@ -198,6 +280,46 @@ function compileCandidate(input, candidate) {
         runtime_requirements: runtimeRequirements(input),
     };
 }
+function compileExternalCandidate(input, candidate) {
+    const carrierRefs = [];
+    const comparison = candidate.comparison;
+    const expectedIdentity = sha256Hex(canonicalValueJson({
+        obligation_ref: candidate.obligation_ref,
+        fact_ref: candidate.fact_ref,
+        method: candidate.method,
+        expected_value_sha256: candidate.expected_value_sha256,
+        comparison,
+        actual_projection: candidate.actual_projection,
+        carrier_refs: carrierRefs,
+    }));
+    return {
+        obligation_ref: candidate.obligation_ref,
+        fact_ref: candidate.fact_ref,
+        assertion_ref: candidate.assertion.key,
+        claim_refs: [...candidate.assertion.claims].sort(),
+        target_ref: candidate.target_ref,
+        proof_surface: input.check.proof_surface,
+        method: candidate.method,
+        evidence_capabilities: [
+            ...candidate.assertion.evidence_capabilities,
+        ].sort(),
+        authority: "external_confirmation",
+        expected_identity: expectedIdentity,
+        expected_value_sha256: candidate.expected_value_sha256,
+        ...(Object.hasOwn(candidate, "expected_value")
+            ? { expected_value: candidate.expected_value }
+            : {}),
+        actual_projection: candidate.actual_projection,
+        observation_identity: candidate.observation_identity,
+        comparison,
+        locator_policy: {
+            kind: "fixed_json_pointer",
+            value: observationPointer(candidate.observation_identity),
+        },
+        carrier_refs: carrierRefs,
+        runtime_requirements: runtimeRequirements(input),
+    };
+}
 function selectAuthority(input, candidate) {
     const target = input.execution_target;
     if (target.role !== "product")
@@ -325,11 +447,20 @@ function requiredAssertion(assertions, assertionRef, diagnostic) {
         throw new Error(diagnostic);
     return assertion;
 }
-function assertionObligationRef(outcomeKey, checkKey, assertionKey) {
-    return `assertion.${outcomeKey ?? "GLOBAL"}.${checkKey}.${assertionKey}`;
+function externalizableObservationError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return [
+        "unsupported_observer_requires_external_confirmation:",
+        "custom_oracle_machine_completion_forbidden:",
+        "machine_observer_not_admitted:",
+        "process_observer_direct_root_required:",
+        "process_observer_root_invocation_required:",
+        "process_observer_root_argv_mismatch:",
+    ].some((prefix) => error.message.startsWith(prefix));
 }
-function designGroundObligationRef(targetKey, method, conditionKey, factRef) {
-    return `design.${targetKey}.${method}.${conditionKey}.${factRef}`;
+export function assertionObligationRef(outcomeKey, checkKey, assertionKey) {
+    return `assertion.${outcomeKey ?? "GLOBAL"}.${checkKey}.${assertionKey}`;
 }
 function observationPointer(identity) {
     return `/observations/${identity.replace(/~/gu, "~0").replace(/\//gu, "~1")}`;

package/dist/lib/long-task-process-table.d.ts

@@ -1,12 +1,9 @@
 export interface ProcessInstance {
     pid: number;
     parent_pid: number;
-    start_identity: string | null;
 }
-export declare function processInstanceMatches(expected: Pick<ProcessInstance, "pid" | "start_identity">, current: Pick<ProcessInstance, "pid" | "start_identity">): boolean;
 export declare function processSnapshot(): Promise<ProcessInstance[]>;
 export declare function descendantsOf(rootPid: number, snapshot: readonly ProcessInstance[]): ProcessInstance[];
-export declare function liveProcessInstances(candidates: readonly ProcessInstance[], snapshot: readonly ProcessInstance[]): ProcessInstance[];
-export declare function rootProcessAlive(rootPid: number, rootInstance: ProcessInstance | null, snapshot: readonly ProcessInstance[]): boolean;
+export declare function liveProcessInstances(candidates: readonly ProcessInstance[]): ProcessInstance[];
+export declare function rootProcessAlive(rootPid: number): boolean;
 export declare function uniqueProcessInstances(instances: readonly ProcessInstance[]): ProcessInstance[];
-export declare function processInstanceKey(instance: ProcessInstance): string;

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

@@ -2,34 +2,15 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const PROCESS_TABLE_OUTPUT_LIMIT = 2 * 1024 * 1024;
 const execFileAsync = promisify(execFile);
-export function processInstanceMatches(expected, current) {
-    if (expected.pid !== current.pid)
-        return false;
-    if (expected.start_identity === null || current.start_identity === null)
-        return true;
-    return expected.start_identity === current.start_identity;
-}
 export async function processSnapshot() {
+    assertNonWindowsProcessTree();
     let stdout;
     try {
-        const result = process.platform === "win32"
-            ? await execFileAsync("powershell.exe", [
-                "-NoLogo",
-                "-NoProfile",
-                "-NonInteractive",
-                "-Command",
-                '$rows = Get-CimInstance Win32_Process; foreach ($row in $rows) { $started = if ($null -eq $row.CreationDate) { "unknown" } else { $row.CreationDate.ToUniversalTime().Ticks }; "$($row.ProcessId) $($row.ParentProcessId) $started" }',
-            ], {
-                encoding: "utf8",
-                windowsHide: true,
-                timeout: 5_000,
-                maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT,
-            })
-            : await execFileAsync("ps", ["-A", "-o", "pid=,ppid="], {
-                encoding: "utf8",
-                timeout: 5_000,
-                maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT,
-            });
+        const result = await execFileAsync("ps", ["-A", "-o", "pid=,ppid="], {
+            encoding: "utf8",
+            timeout: 5_000,
+            maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT,
+        });
         stdout = result.stdout;
     }
     catch (error) {
@@ -37,16 +18,12 @@ export async function processSnapshot() {
     }
     const rows = [];
     for (const line of stdout.split(/\r?\n/u)) {
-        const [pidText, parentText, startText] = line.trim().split(/\s+/u);
+        const [pidText, parentText] = line.trim().split(/\s+/u);
         const pid = Number.parseInt(pidText ?? "", 10);
         const parent = Number.parseInt(parentText ?? "", 10);
         if (!Number.isSafeInteger(pid) || !Number.isSafeInteger(parent))
             continue;
-        rows.push({
-            pid,
-            parent_pid: parent,
-            start_identity: process.platform === "win32" && startText ? startText : null,
-        });
+        rows.push({ pid, parent_pid: parent });
     }
     return rows;
 }
@@ -64,40 +41,27 @@ export function descendantsOf(rootPid, snapshot) {
     const seen = new Set();
     while (pending.length) {
         const processInstance = pending.shift();
-        const key = processInstanceKey(processInstance);
-        if (seen.has(key))
+        if (seen.has(processInstance.pid))
             continue;
-        seen.add(key);
+        seen.add(processInstance.pid);
         result.push(processInstance);
         pending.push(...(children.get(processInstance.pid) ?? []));
     }
     return result;
 }
-export function liveProcessInstances(candidates, snapshot) {
-    if (process.platform !== "win32")
-        return candidates.filter((candidate) => processIdExists(candidate.pid));
-    const currentByPid = new Map(snapshot.map((entry) => [entry.pid, entry]));
-    return candidates.filter((candidate) => {
-        const current = currentByPid.get(candidate.pid);
-        return current ? processInstanceMatches(candidate, current) : false;
-    });
+export function liveProcessInstances(candidates) {
+    assertNonWindowsProcessTree();
+    return candidates.filter((candidate) => processIdExists(candidate.pid));
 }
-export function rootProcessAlive(rootPid, rootInstance, snapshot) {
-    if (process.platform !== "win32")
-        return processIdExists(rootPid);
-    const current = snapshot.find((entry) => entry.pid === rootPid);
-    if (!current)
-        return false;
-    return rootInstance ? processInstanceMatches(rootInstance, current) : true;
+export function rootProcessAlive(rootPid) {
+    assertNonWindowsProcessTree();
+    return processIdExists(rootPid);
 }
 export function uniqueProcessInstances(instances) {
     return [
-        ...new Map(instances.map((instance) => [processInstanceKey(instance), instance])).values(),
+        ...new Map(instances.map((instance) => [instance.pid, instance])).values(),
     ];
 }
-export function processInstanceKey(instance) {
-    return `${instance.pid}:${instance.start_identity ?? "pid-only"}`;
-}
 function processIdExists(pid) {
     try {
         process.kill(pid, 0);
@@ -109,6 +73,10 @@ function processIdExists(pid) {
         throw error;
     }
 }
+function assertNonWindowsProcessTree() {
+    if (process.platform === "win32")
+        throw new Error("process_observer_windows_job_required");
+}
 function nodeErrorCode(error) {
     return error && typeof error === "object" && "code" in error
         ? String(error.code)

package/dist/lib/long-task-process-tree.d.ts

@@ -1,4 +1,3 @@
-export { processInstanceMatches } from "./long-task-process-table.js";
 export interface ProcessTreeObserver {
     stop(): void;
     wait(): Promise<void>;

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

@@ -1,12 +1,9 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { descendantsOf, liveProcessInstances, processInstanceKey, processInstanceMatches, processSnapshot, rootProcessAlive, uniqueProcessInstances, } from "./long-task-process-table.js";
-export { processInstanceMatches } from "./long-task-process-table.js";
+import { descendantsOf, liveProcessInstances, processSnapshot, rootProcessAlive, uniqueProcessInstances, } from "./long-task-process-table.js";
 const PROCESS_TREE_GRACE_MS = 1_000;
-const execFileAsync = promisify(execFile);
 export function createProcessTreeObserver(rootPid) {
+    if (process.platform === "win32")
+        throw new Error("process_observer_windows_job_required");
     let stopped = false;
-    let rootInstance = null;
     const observed = new Map();
     const monitor = observe();
     return {
@@ -17,86 +14,60 @@ export function createProcessTreeObserver(rootPid) {
             return monitor;
         },
         terminate(force) {
-            return terminateProcessTree(rootPid, rootInstance, force, [...observed.values()], true);
+            return terminateProcessTree(rootPid, force, [...observed.values()], true);
         },
         forceQuiescence() {
-            return forceProcessTreeQuiescence(rootPid, rootInstance, observed);
+            return forceProcessTreeQuiescence(rootPid, observed);
         },
         assertQuiescent() {
-            return assertProcessTreeQuiescent(rootPid, rootInstance, observed);
+            return assertProcessTreeQuiescent(rootPid, observed);
         },
     };
     async function observe() {
         do {
             const snapshot = await processSnapshot();
-            const currentRoot = snapshot.find((entry) => entry.pid === rootPid);
-            if (currentRoot &&
-                (!rootInstance || processInstanceMatches(rootInstance, currentRoot))) {
-                rootInstance ??= currentRoot;
+            if (snapshot.some((entry) => entry.pid === rootPid))
                 for (const descendant of descendantsOf(rootPid, snapshot))
-                    observed.set(processInstanceKey(descendant), descendant);
-            }
+                    observed.set(descendant.pid, descendant);
             if (stopped)
                 return;
-            await delay(process.platform === "win32" ? 100 : 25);
+            await delay(25);
         } while (!stopped);
     }
 }
-async function forceProcessTreeQuiescence(rootPid, rootInstance, observed) {
-    await terminateProcessTree(rootPid, rootInstance, true, [...observed.values()], true);
+async function forceProcessTreeQuiescence(rootPid, observed) {
+    await terminateProcessTree(rootPid, true, [...observed.values()], true);
     const deadline = Date.now() + PROCESS_TREE_GRACE_MS;
     while (Date.now() < deadline) {
-        const snapshot = await processSnapshot();
-        const rootAlive = rootProcessAlive(rootPid, rootInstance, snapshot);
-        const descendantsAlive = liveProcessInstances([...observed.values()], snapshot).length;
-        const groupAlive = process.platform !== "win32" && processGroupExists(rootPid);
+        const rootAlive = rootProcessAlive(rootPid);
+        const descendantsAlive = liveProcessInstances([
+            ...observed.values(),
+        ]).length;
+        const groupAlive = processGroupExists(rootPid);
         if (!rootAlive && descendantsAlive === 0 && !groupAlive)
             return;
-        await delay(process.platform === "win32" ? 100 : 25);
+        await delay(25);
     }
     throw new Error("process_observer_descendant_process_alive");
 }
-async function assertProcessTreeQuiescent(rootPid, rootInstance, observed) {
+async function assertProcessTreeQuiescent(rootPid, observed) {
     const snapshot = await processSnapshot();
-    const currentRoot = snapshot.find((entry) => entry.pid === rootPid);
-    const finalDescendants = currentRoot &&
-        (!rootInstance || processInstanceMatches(rootInstance, currentRoot))
+    const finalDescendants = snapshot.some((entry) => entry.pid === rootPid)
         ? descendantsOf(rootPid, snapshot)
         : [];
     const candidates = uniqueProcessInstances([
         ...observed.values(),
         ...finalDescendants,
     ]);
-    const descendants = liveProcessInstances(candidates, snapshot);
-    const processGroupAlive = process.platform !== "win32" && processGroupExists(rootPid);
-    if (!descendants.length && !processGroupAlive)
+    const descendants = liveProcessInstances(candidates);
+    if (!descendants.length && !processGroupExists(rootPid))
         return;
-    await terminateProcessTree(rootPid, rootInstance, true, descendants, false);
+    await terminateProcessTree(rootPid, true, descendants, false);
     throw new Error("process_observer_descendant_process_alive");
 }
-async function terminateProcessTree(rootPid, rootInstance, force, knownDescendants, includeRoot) {
+async function terminateProcessTree(rootPid, force, knownDescendants, includeRoot) {
     if (!Number.isSafeInteger(rootPid) || rootPid <= 0)
         return;
-    if (process.platform === "win32") {
-        const snapshot = await processSnapshot();
-        const currentRoot = snapshot.find((entry) => entry.pid === rootPid);
-        const rootTarget = includeRoot &&
-            currentRoot &&
-            (!rootInstance || processInstanceMatches(rootInstance, currentRoot))
-            ? currentRoot
-            : null;
-        const currentDescendants = rootTarget
-            ? descendantsOf(rootPid, snapshot)
-            : [];
-        const descendants = liveProcessInstances(uniqueProcessInstances([...knownDescendants, ...currentDescendants]), snapshot).reverse();
-        const targets = rootTarget ? [...descendants, rootTarget] : descendants;
-        for (const target of targets)
-            await execFileAsync("taskkill.exe", ["/PID", String(target.pid), "/T", "/F"], {
-                windowsHide: true,
-                timeout: PROCESS_TREE_GRACE_MS,
-            }).catch(() => undefined);
-        return;
-    }
     const signal = force ? "SIGKILL" : "SIGTERM";
     if (includeRoot)
         try {
@@ -106,8 +77,7 @@ async function terminateProcessTree(rootPid, rootInstance, force, knownDescendan
             if (nodeErrorCode(error) !== "ESRCH")
                 throw error;
         }
-    const snapshot = await processSnapshot();
-    const descendants = liveProcessInstances(knownDescendants, snapshot);
+    const descendants = liveProcessInstances(knownDescendants);
     for (const descendant of descendants.reverse())
         try {
             process.kill(descendant.pid, signal);

package/dist/lib/long-task-proof-adequacy.d.ts

@@ -0,0 +1,12 @@
+import type { DeliveryContractV2, EvidenceCapabilityV2, SemanticFactExpectationV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export { externalClaimCapabilityFloor } from "./long-task-proof-capability-floor.js";
+export type CheckCompletionRoleV2 = "semantic" | "diagnostic";
+export interface CheckProofAdequacyV2 {
+    completion_role: CheckCompletionRoleV2;
+    expected_authority_refs: Record<string, string>;
+    required_evidence_capabilities: Record<string, EvidenceCapabilityV2[]>;
+}
+export type ProofAdequacyByCheckV2 = Record<string, CheckProofAdequacyV2>;
+export declare function proofAdequacyCheckKey(outcomeKey: string | null, checkKey: string): string;
+export declare function validateLongTaskProofAdequacy(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, expectationsByCheck: ReadonlyMap<string, SemanticFactExpectationV2[]>): ProofAdequacyByCheckV2;