@deksden-com/dd-flow-cli 0.9.0-beta.150 → 0.9.0-beta.151

package/dist/services/check-runner-proof.js

@@ -0,0 +1,305 @@
+import crypto from "node:crypto";
+import path from "node:path";
+import { isDeepStrictEqual, stripVTControlCharacters } from "node:util";
+import { fileURLToPath } from "node:url";
+export const RUNNER_PROOF_CONTRACT = "dd-flow/check-runner-proof@1";
+function object(value) { return Boolean(value) && typeof value === "object" && !Array.isArray(value); }
+function boundedString(value, bytes) { return typeof value === "string" && Buffer.byteLength(value) <= bytes; }
+const validatedBrowserProofs = new WeakSet();
+const unsupportedObservationContracts = new WeakSet();
+const validatedNativeProofs = new WeakSet();
+const validatedChildren = new WeakMap();
+const validatedReports = new WeakMap();
+const hash = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+const absoluteFile = (value) => typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.includes("\0") && path.isAbsolute(value);
+export function candidateAbsencesValid(value) { return Array.isArray(value) && value.length <= 64 && value.every(item => object(item) && absoluteFile(item.file) && item.path_state === "missing" && object(item.declaration) && absoluteFile(item.declaration.file) && hash(item.declaration.sha256)); }
+function relativeProofPath(value) { return typeof value === "string" && value.length > 0 && Buffer.byteLength(value) <= 4096 && !path.isAbsolute(value) && !value.includes("\\") && value.split("/").every(part => part !== "" && part !== "." && part !== ".."); }
+function proofArtifact(value) { return object(value) && relativeProofPath(value.relative_path) && typeof value.sha256 === "string" && /^[a-f0-9]{64}$/.test(value.sha256); }
+function browserProofShape(proof) {
+    const attempt = proof.attempt, step = proof.step;
+    return (proof.observation_contract === undefined || proof.observation_contract === "dd-tasks/browser-observation@2" && object(proof.target) && [proof.target.page_id, proof.target.context_id].every(value => boundedString(value, 256) && Boolean(value)) && Number.isSafeInteger(proof.window_epoch) && Number(proof.window_epoch) > 0)
+        && proof.native_code === "PLAYWRIGHT_ACTION_INACTIVITY" && object(attempt) && boundedString(attempt.invocation_id, 4096) && boundedString(attempt.test_id, 4096) && Boolean(attempt.test_id)
+        && [attempt.retry, attempt.repeat_each_index, attempt.worker_index].every(value => Number.isSafeInteger(value) && value >= 0)
+        && object(step) && boundedString(step.id, 4096) && Boolean(step.id) && ["pw:api", "expect"].includes(String(step.category)) && step.file === proof.file && Number.isSafeInteger(step.line) && step.line > 0
+        && proofArtifact(proof.worker_snapshot) && proofArtifact(proof.native_result);
+}
+export function runnerFailureValid(value) {
+    if (!object(value) || typeof value.category !== "string" || !["assertion", "tooling", "unclassified"].includes(value.category))
+        return false;
+    if (value.diagnostic_artifact !== undefined && !proofArtifact(value.diagnostic_artifact))
+        return false;
+    for (const key of ["code", "message", "file", "test_id", "native_code", "classification_reason"])
+        if (value[key] !== undefined && !boundedString(value[key], 4096))
+            return false;
+    if (value.stack !== undefined && !boundedString(value.stack, 16384) || value.origin !== undefined && (typeof value.origin !== "string" || !["candidate", "tooling", "unknown"].includes(value.origin)) || value.phase !== undefined && (typeof value.phase !== "string" || !["test", "setup", "teardown", "collection", "runner"].includes(value.phase)))
+        return false;
+    if (value.repair_evidence !== undefined) {
+        const proof = value.repair_evidence;
+        if (object(proof) && proof.rule === "candidate_test_runtime_error")
+            return ["TypeError", "ReferenceError", "Error"].includes(String(proof.exception_type)) && (proof.exception_type !== "Error" || proof.phase === "test")
+                && absoluteFile(proof.file) && hash(proof.file_sha256) && ["test", "setup", "collection"].includes(String(proof.phase))
+                && [proof.line, proof.column].every(value => Number.isSafeInteger(value) && Number(value) > 0) && proofArtifact(proof.native_artifact);
+        if (object(proof) && proof.rule === "candidate_migration_sql")
+            return proof.native_code === "42601" && absoluteFile(proof.file) && hash(proof.file_sha256)
+                && boundedString(proof.operation_id, 4096) && Boolean(proof.operation_id) && proofArtifact(proof.native_artifact) && object(proof.world)
+                && boundedString(proof.world.invocation_id, 4096) && typeof proof.world.world_id === "string" && /^[a-f0-9]{32}$/.test(proof.world.world_id)
+                && boundedString(proof.world.role, 128) && Boolean(proof.world.role) && hash(proof.world.migrations_sha256) && proof.world.phase === "migrating" && proof.world.setup_completed === false;
+        if (object(proof) && proof.rule === "candidate_tool_diagnostic")
+            return absoluteFile(proof.file) && proofArtifact(proof.native_artifact)
+                && object(proof.tool) && { biome: "2.5.6", typescript: "5.9.3", docs: "1", "value-absence": "1" }[String(proof.tool.name)] === proof.tool.version
+                && object(proof.step) && boundedString(proof.step.id, 256) && Boolean(proof.step.id) && Number.isSafeInteger(proof.step.ordinal) && proof.step.ordinal >= 0 && hash(proof.step.command_sha256)
+                && boundedString(proof.diagnostic_code, 256) && (proof.tool.name === "biome" ? ["format", "assist/source/organizeImports"].includes(String(proof.diagnostic_code)) || /^lint\/[\w/-]+$/.test(String(proof.diagnostic_code)) : proof.tool.name === "typescript" ? /^TS\d+$/.test(String(proof.diagnostic_code)) : proof.tool.name === "docs" ? ["required_path_missing", "docs_contract"].includes(String(proof.diagnostic_code)) : proof.diagnostic_code === "value_absence")
+                && (proof.path_state === "present" && hash(proof.file_sha256) || proof.path_state === "missing" && proof.tool.name === "docs" && proof.diagnostic_code === "required_path_missing" && proof.file_sha256 === null && object(proof.declaration) && absoluteFile(proof.declaration.file) && hash(proof.declaration.sha256));
+        if (!object(proof) || !boundedString(proof.rule, 128) || !boundedString(proof.native_code, 128) || !boundedString(proof.file, 4096) || !object(proof.world))
+            return false;
+        const world = proof.world;
+        if (world.schema_id !== "dd-tasks/test-world-ready@1" || !boundedString(world.invocation_id, 4096) || typeof world.world_id !== "string" || !/^[a-f0-9]{32}$/.test(world.world_id) || typeof world.migrations_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(world.migrations_sha256) || world.ready !== true || world.setup_completed !== true || !boundedString(world.role, 128) || !world.role)
+            return false;
+        if (proof.rule === "candidate_browser_action_inactivity" && !browserProofShape(proof))
+            return false;
+        if (!["candidate_sql_integrity", "candidate_browser_action_inactivity"].includes(String(proof.rule)))
+            return false;
+    }
+    return true;
+}
+function readBytes(context, relative, limit) {
+    if (!relativeProofPath(relative))
+        throw new Error("Unsafe proof path");
+    const bytes = context.readArtifact(relative);
+    if (!Buffer.isBuffer(bytes) || bytes.length > limit)
+        throw new Error("Evidence is not bounded bytes");
+    context.consumed += bytes.length;
+    if (context.consumed > 128 * 1024 * 1024)
+        throw Object.assign(new Error("Proof byte budget exceeded"), { code: "proof_budget_exceeded" });
+    return bytes;
+}
+function readProofArtifact(root, ref, context, limit = 2 * 1024 * 1024) {
+    const bytes = readBytes(context, path.posix.join(root, ref.relative_path), limit);
+    if (crypto.createHash("sha256").update(bytes).digest("hex") !== ref.sha256)
+        throw new Error("Proof hash differs");
+    const value = JSON.parse(bytes.toString("utf8"));
+    if (!object(value))
+        throw new Error("Invalid proof object");
+    return value;
+}
+function matches(actual, expected) { return object(actual) && Object.entries(expected).every(([key, value]) => actual[key] === value); }
+function validateBrowserArtifacts(root, proof, binding, context) {
+    const snapshot = readProofArtifact(root, proof.worker_snapshot, context), native = readProofArtifact(root, proof.native_result, context);
+    if (proof.observation_contract !== undefined && (proof.observation_contract !== "dd-tasks/browser-observation@2" || snapshot.observation_contract !== proof.observation_contract || native.observation_contract !== proof.observation_contract
+        || !isDeepStrictEqual(snapshot.target, proof.target) || !isDeepStrictEqual(native.target, proof.target) || snapshot.window_epoch !== proof.window_epoch || native.window_epoch !== proof.window_epoch))
+        return false;
+    if (!Array.isArray(native.errors) || native.errors.length < 1 || native.errors.length > 64 || native.errors.some(error => !boundedString(error, 4096) || !/^(?:Error: )?(?:[A-Za-z][\w.]*: )?Test timeout of [1-9]\d*ms exceeded\.(?:\nCall log:[\s\S]*)?$/.test(stripVTControlCharacters(String(error)))))
+        return false;
+    if (!matches(snapshot.binding, binding) || !matches(native.binding, binding) || !matches(snapshot.attempt, proof.attempt) || !matches(native.attempt, proof.attempt)
+        || !matches(snapshot.step, proof.step) || !matches(native.step, proof.step) || !matches(snapshot.world, proof.world) || proof.world.invocation_id !== binding.invocation_id
+        || native.status !== "timedOut" || native.phase !== "test" || native.file !== proof.file || snapshot.phase !== "body" || snapshot.observation_gap !== false || !matches(snapshot.browser, { connected: true, page_closed: false, crashed: false })
+        || !matches(snapshot.world_health, { api: true, web: true, db: true }))
+        return false;
+    const quiet = snapshot.quiet_ms, last = Date.parse(String(snapshot.last_progress_at)), deadline = Date.parse(String(snapshot.deadline_at)), observed = Date.parse(String(snapshot.observed_at)), health = Date.parse(String(snapshot.health_observed_at)), ended = Date.parse(String(native.ended_at));
+    return Number.isSafeInteger(quiet) && quiet > 0 && [last, deadline, observed, health, ended].every(Number.isFinite) && Math.abs(deadline - last - quiet) <= 2 && observed >= last && observed <= deadline && health <= observed && health >= last && deadline - health <= Math.min(1000, quiet / 4) && ended >= deadline && ended <= Date.now() && ended - deadline <= 5000;
+}
+export function runnerProofArtifacts(evidence) {
+    return [...new Set([...(evidence?.failures ?? []).flatMap(failure => {
+                const child = validatedChildren.get(failure);
+                if (child && failure.child_evidence)
+                    return [failure.child_evidence.report.relative_path, ...runnerProofArtifacts(child.evidence).map(file => path.posix.join(path.posix.dirname(failure.child_evidence.report.relative_path), file))];
+                const proof = failure.repair_evidence;
+                return [...(failure.diagnostic_artifact ? [failure.diagnostic_artifact.relative_path] : []), ...(proof?.rule === "candidate_browser_action_inactivity" ? [proof.worker_snapshot.relative_path, proof.native_result.relative_path] : proof && "native_artifact" in proof ? [proof.native_artifact.relative_path] : [])];
+            }), ...(evidence ? validatedReports.get(evidence) ?? [] : []).flatMap(child => [child.report.relative_path, ...runnerProofArtifacts(child.evidence).map(file => path.posix.join(path.posix.dirname(child.report.relative_path), file))])])];
+}
+function diagnostic(context, value) {
+    // Diagnostics are locators, never another copy of untrusted report content.
+    if (context.diagnostics.length >= 64 || context.bytes + Buffer.byteLength(JSON.stringify(value)) > 32 * 1024 - 64) {
+        context.truncated = true;
+        return;
+    }
+    context.diagnostics.push(value);
+    context.bytes += Buffer.byteLength(JSON.stringify(value));
+}
+export function validateRunnerProof(contract, binding, readArtifact) {
+    const context = { diagnostics: [], bytes: 0, consumed: 0, truncated: false, readArtifact };
+    const evidence = readRunnerEvidenceInternal("", contract, binding, 0, { reports: 0 }, context, "");
+    return { contract: RUNNER_PROOF_CONTRACT, evidence, required_artifacts: evidence ? runnerProofArtifacts(evidence) : [], diagnostics: context.diagnostics, ...(context.truncated ? { diagnostics_truncated: true } : {}) };
+}
+function readRunnerEvidenceInternal(root, contract, binding, depth, budget, context, prefix) {
+    const report = relativeProofPath(contract.path) ? path.posix.join(prefix, contract.path) : "<invalid-report-path>";
+    const count = context.diagnostics.length;
+    let accepted = false;
+    let failureReason = "invalid_shape";
+    const invalid = () => { if (context.diagnostics.length === count)
+        diagnostic(context, { reason: failureReason, report }); return null; };
+    try {
+        if (!relativeProofPath(contract.path))
+            return invalid();
+        if (depth > 4 || ++budget.reports > 64) {
+            failureReason = "proof_budget_exceeded";
+            return invalid();
+        }
+        const bytes = readBytes(context, path.posix.join(root, contract.path), 1024 * 1024);
+        failureReason = "invalid_json";
+        const evidence = JSON.parse(bytes.toString("utf8"));
+        failureReason = "invalid_shape";
+        if (!object(evidence))
+            return invalid();
+        if (!["dd-flow/check-runner-evidence@1", "dd-flow/check-runner-evidence@2"].includes(contract.schema_id))
+            return null;
+        const partial = evidence.failure_projection;
+        if (partial !== undefined && (evidence.schema_id !== "dd-flow/check-runner-evidence@2" || !object(partial) || partial.state !== "partial" || !["count_bound", "byte_bound", "interrupt"].includes(partial.reason)
+            || ![partial.represented, partial.omitted].every(value => Number.isSafeInteger(value) && value >= 0)))
+            return null;
+        if (evidence.schema_id !== contract.schema_id) {
+            diagnostic(context, { reason: "invalid_shape", report, expected: contract.schema_id, observed: ["dd-flow/check-runner-evidence@1", "dd-flow/check-runner-evidence@2"].includes(evidence.schema_id) ? evidence.schema_id : "unsupported" });
+            return null;
+        }
+        if (!evidence.binding || Object.entries(binding).some(([key, value]) => evidence.binding[key] !== value)) {
+            diagnostic(context, { reason: "binding_mismatch", report });
+            return null;
+        }
+        if (typeof evidence.runner?.name !== "string" || !evidence.runner.name || typeof evidence.runner.version !== "string" || !evidence.runner.version || typeof evidence.completed !== "boolean" || !evidence.counts
+            || ![evidence.counts.passed, evidence.counts.failed, evidence.counts.skipped].every(n => Number.isSafeInteger(n) && n >= 0)
+            || !Array.isArray(evidence.failures) || evidence.failures.length > 64 || evidence.failures.some(f => !runnerFailureValid(f))
+            || !partial && evidence.counts.failed > evidence.failures.length || evidence.observation_unknown !== undefined && typeof evidence.observation_unknown !== "boolean")
+            return null;
+        const children = new Map();
+        const consumed = new Map();
+        if (evidence.steps !== undefined) {
+            if (!Array.isArray(evidence.steps) || evidence.steps.length > 64)
+                return null;
+            const ids = new Set(), invocations = new Set();
+            let stopped = false;
+            for (const [ordinal, step] of evidence.steps.entries()) {
+                if (!step || !boundedString(step.id, 256) || !step.id || ids.has(step.id) || step.ordinal !== ordinal || !hash(step.command_sha256) || !["passed", "failed", "unreached"].includes(step.state))
+                    return null;
+                ids.add(step.id);
+                if (step.state === "unreached") {
+                    if (!stopped || step.binding !== undefined || step.report !== undefined || step.exit_code !== undefined)
+                        return null;
+                    continue;
+                }
+                if (stopped)
+                    return null;
+                if (step.state === "failed")
+                    stopped = true;
+                if (!step.binding || !proofArtifact(step.report) || !Number.isSafeInteger(step.exit_code) || step.state === "passed" && step.exit_code !== 0 || step.state === "failed" && step.exit_code === 0 || invocations.has(step.binding.invocation_id) || step.binding.invocation_id === binding.invocation_id)
+                    return null;
+                if (step.binding.invocation_id !== `${binding.invocation_id}:step:${step.id}` || step.binding.check_id !== `${binding.check_id}/${step.id}` || step.binding.verification_epoch !== binding.verification_epoch || step.binding.input_hash !== crypto.createHash("sha256").update(JSON.stringify([binding.input_hash, step.command_sha256])).digest("hex"))
+                    return null;
+                if (crypto.createHash("sha256").update(step.binding.command).digest("hex") !== step.command_sha256)
+                    return null;
+                invocations.add(step.binding.invocation_id);
+                failureReason = "artifact_mismatch";
+                readProofArtifact(root, step.report, context, 1024 * 1024);
+                failureReason = "invalid_shape";
+                const child = readRunnerEvidenceInternal(path.posix.join(root, path.posix.dirname(step.report.relative_path)), { schema_id: contract.schema_id, path: path.basename(step.report.relative_path) }, step.binding, depth + 1, budget, context, path.posix.join(prefix, path.posix.dirname(step.report.relative_path)));
+                if (!child || step.state === "passed" && (child.counts.failed !== 0 || child.failures.length !== 0) || step.state === "failed" && !child.failures.length && child.completed && !child.observation_unknown)
+                    return null;
+                if (!child.completed || child.observation_unknown)
+                    stopped = true;
+                children.set(step.id, child);
+            }
+            for (const key of ["passed", "failed", "skipped"])
+                if (evidence.counts[key] !== [...children.values()].reduce((total, child) => total + child.counts[key], 0))
+                    return null;
+        }
+        for (const failure of evidence.failures) {
+            failureReason = "artifact_mismatch";
+            if (failure.child_evidence) {
+                const ref = failure.child_evidence, step = evidence.steps?.find(item => item.id === ref.step_id), child = children.get(ref.step_id);
+                if (!step || !child || !isDeepStrictEqual(ref.binding, step.binding) || !isDeepStrictEqual(ref.report, step.report))
+                    return null;
+                const original = { ...failure };
+                delete original.child_evidence;
+                const used = consumed.get(child) ?? new Set();
+                consumed.set(child, used);
+                const index = child.failures.findIndex((item, index) => { const native = { ...item }; delete native.child_evidence; return !used.has(index) && isDeepStrictEqual(native, original); });
+                if (index < 0)
+                    return null;
+                used.add(index);
+                const matched = child.failures[index];
+                if (!matched.child_evidence && matched.repair_evidence?.rule === "candidate_tool_diagnostic" && !isDeepStrictEqual(matched.repair_evidence.step, { id: step.id, ordinal: step.ordinal, command_sha256: step.command_sha256 }))
+                    return null;
+                validatedChildren.set(failure, { failure: matched, evidence: child });
+                continue;
+            }
+            if (failure.diagnostic_artifact && !matches(readProofArtifact(root, failure.diagnostic_artifact, context, 2 * 1024 * 1024).binding, binding))
+                return null;
+            const proof = failure.repair_evidence;
+            if (proof?.rule === "candidate_migration_sql" || proof?.rule === "candidate_tool_diagnostic" || proof?.rule === "candidate_test_runtime_error") {
+                const native = readProofArtifact(root, proof.native_artifact, context, 2 * 1024 * 1024), facts = Object.fromEntries(Object.entries(proof).filter(([key]) => key !== "native_artifact"));
+                if (!isDeepStrictEqual(native.binding, binding) || Object.entries(facts).some(([key, value]) => !isDeepStrictEqual(native[key], value)))
+                    return null;
+                if (proof.rule === "candidate_test_runtime_error") {
+                    failureReason = "attribution_unproven";
+                    if (evidence.schema_id !== "dd-flow/check-runner-evidence@2" || native.executing_file !== proof.file || native.exception_name !== proof.exception_type
+                        || !isDeepStrictEqual(native.top_frame, { file: proof.file, line: proof.line, column: proof.column }) || !boundedString(native.stack, 16384) || !String(native.stack).startsWith(`${proof.exception_type}:`))
+                        return null;
+                    const firstFrame = String(native.stack).split("\n").find(line => /^\s*at\s/.test(line));
+                    const frame = firstFrame?.match(/^\s*at\s+(?:.*?\()?((?:file:\/\/)?\/[^\n]+):(\d+):(\d+)\)?$/);
+                    if (!frame || (frame[1].startsWith("file://") ? fileURLToPath(frame[1]) : frame[1]) !== proof.file || Number(frame[2]) !== proof.line || Number(frame[3]) !== proof.column)
+                        return null;
+                }
+                validatedNativeProofs.add(proof);
+            }
+            if (proof?.rule === "candidate_browser_action_inactivity") {
+                if (proof.observation_contract === undefined && evidence.schema_id === "dd-flow/check-runner-evidence@1") {
+                    // Legacy diagnostics remain readable; they do not prove the new window/target guarantee.
+                    if (!validateBrowserArtifacts(root, proof, binding, context))
+                        return null;
+                    evidence.completed = false;
+                    unsupportedObservationContracts.add(evidence);
+                    continue;
+                }
+                if (proof.observation_contract !== "dd-tasks/browser-observation@2" || !validateBrowserArtifacts(root, proof, binding, context))
+                    return null;
+                validatedBrowserProofs.add(proof);
+            }
+        }
+        failureReason = "invalid_shape";
+        const represented = [...consumed.values()].reduce((total, used) => total + used.size, 0), childFailures = [...children.values()].reduce((total, child) => total + child.failures.length, 0);
+        if (partial) {
+            if (children.size ? partial.represented !== represented || partial.omitted !== childFailures - represented : partial.represented !== evidence.failures.filter(failure => failure.code !== "report_truncated").length)
+                return null;
+            evidence.completed = false;
+        }
+        else if (represented !== childFailures)
+            return null;
+        // Valid but incomplete native observation is diagnostic evidence, not a
+        // malformed schema. Preserve the primary failure and references through
+        // every composite, including a parent that incorrectly claims completion.
+        if ([...children.values()].some(child => !child.completed || child.observation_unknown)) {
+            evidence.completed = false;
+            if ([...children.values()].some(child => unsupportedObservationContracts.has(child)))
+                unsupportedObservationContracts.add(evidence);
+            if (evidence.schema_id === "dd-flow/check-runner-evidence@1" && [...children.values()].some(child => !child.completed && !unsupportedObservationContracts.has(child)) || [...children.values()].some(child => child.observation_unknown))
+                evidence.observation_unknown = true;
+        }
+        validatedReports.set(evidence, (evidence.steps ?? []).flatMap(step => step.report && children.has(step.id) ? [{ report: step.report, evidence: children.get(step.id) }] : []));
+        if (unsupportedObservationContracts.has(evidence))
+            diagnostic(context, { reason: "unsupported_observation_contract", report, expected: "dd-tasks/browser-observation@2", observed: "legacy" });
+        else if (!evidence.completed || evidence.observation_unknown)
+            diagnostic(context, { reason: "observation_incomplete", report });
+        for (const failure of evidence.failures)
+            if (failure.origin === "unknown" || failure.category === "unclassified" && !failure.repair_evidence) {
+                diagnostic(context, { reason: "attribution_unproven", report });
+                break;
+            }
+        accepted = true;
+        return evidence;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            failureReason = "missing";
+        else if (error.code === "proof_budget_exceeded")
+            failureReason = "proof_budget_exceeded";
+        return invalid();
+    }
+    finally {
+        if (!accepted && context.diagnostics.length === count)
+            diagnostic(context, { reason: failureReason, report });
+    }
+}
+export function runnerEvidencePass(evidence) { return Boolean(evidence?.completed && !evidence.failure_projection && !evidence.observation_unknown && evidence.counts.failed === 0 && evidence.failures.length === 0); }
+export const validatedRunnerChild = (failure) => validatedChildren.get(failure);
+export const hasValidatedNativeProof = (proof) => validatedNativeProofs.has(proof);
+export const hasValidatedBrowserProof = (proof) => validatedBrowserProofs.has(proof);
+export const hasUnsupportedObservation = (evidence) => unsupportedObservationContracts.has(evidence);

package/dist/services/code-checks.js

@@ -17,6 +17,7 @@ import { admitRuntimeCheck, runtimeBudgetForRun } from "./runtime-budget.js";
 import { getResourceDatabase } from "../storage/database.js";
 import { readBoundedReleaseFile } from "./release-source.js";
 import { ownedCheckEnvironment, validateCheckEnvironment } from "./check-environment.js";
+import { browserCheckCapabilityEnvironment } from "./stage-context.js";
 const profileRelativePath = path.join(".memory-bank", "spec", "engineering", "code-check-profile.json");
 // Receipt reservation precedes child spawn so an interrupted CLI leaves an
 // auditable attempt. A second caller must not mistake that small handoff window
@@ -68,6 +69,8 @@ export function codeExecutionEnvironment(workspaceRoot, checkEnvironment) {
     // provider can otherwise run x64 checks against arm64-installed modules.
     const environment = { ...process.env, PATH: `${path.dirname(process.execPath)}${path.delimiter}${process.env.PATH ?? ""}`, DD_FLOW_LOCAL_DATABASE_SUFFIX: suffix };
     delete environment.NODE_PATH;
+    delete environment.DD_FLOW_BROWSER_CAPABILITY_PATH;
+    delete environment.DD_FLOW_BROWSER_CAPABILITY_SHA256;
     for (const key of ["DD_FLOW_CHECK_RUNNER_EVIDENCE_PATH", "DD_FLOW_CHECK_RUNNER_PROGRESS_PATH", "DD_FLOW_CHECK_INVOCATION_ID", "DD_FLOW_CHECK_ID", "DD_FLOW_CHECK_INPUT_HASH", "DD_FLOW_CHECK_VERIFICATION_EPOCH", "DD_FLOW_CHECK_COMMAND"])
         delete environment[key];
     Object.assign(environment, selected);
@@ -621,7 +624,7 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
                 const runnerEnvironment = group.runnerEvidence ? { DD_FLOW_CHECK_RUNNER_EVIDENCE_PATH: path.join(evidenceDir, group.runnerEvidence.path), DD_FLOW_CHECK_RUNNER_PROGRESS_PATH: path.join(evidenceDir, "runner-progress.jsonl"), DD_FLOW_CHECK_INVOCATION_ID: id, DD_FLOW_CHECK_ID: id, DD_FLOW_CHECK_INPUT_HASH: inputHash, DD_FLOW_CHECK_VERIFICATION_EPOCH: epoch } : {};
                 if (group.runnerEvidence)
                     fs.mkdirSync(path.dirname(path.join(evidenceDir, group.runnerEvidence.path)), { recursive: true });
-                result = await runCheck(group.command, input.workspaceRoot, { ...codeExecutionEnvironment(input.workspaceRoot, input.checkEnvironment), DD_FLOW_EVIDENCE_DIR: evidenceDir, DD_FLOW_CHECK_COMPLETION_FILE: completionPath, ...runnerEnvironment, ...portEnvironment(resources) }, stdout, stderr, (elapsed) => input.progress?.(`check ${index + 1}/${groups.length} still running (${elapsed}s): ${group.command}`), (pid) => {
+                result = await runCheck(group.command, input.workspaceRoot, { ...codeExecutionEnvironment(input.workspaceRoot, input.checkEnvironment), ...browserCheckCapabilityEnvironment(context, input.runId, input.runHome), DD_FLOW_EVIDENCE_DIR: evidenceDir, DD_FLOW_CHECK_COMPLETION_FILE: completionPath, ...runnerEnvironment, ...portEnvironment(resources) }, stdout, stderr, (elapsed) => input.progress?.(`check ${index + 1}/${groups.length} still running (${elapsed}s): ${group.command}`), (pid) => {
                     confirmedExpiry = confirmManagedProcess(context, { id: managed.id, leaseToken: managed.lease_token, pid, processGroupId: process.platform === "win32" ? null : pid }).lease_expires_at;
                     assertRunMutationAllowed(context, input.projectId, input.runId, generation);
                     if (budget)

package/dist/services/controller-child-capacity.js

@@ -1,3 +1,58 @@
+import { nativeContinuationSuccessor, nativeContinuationAdmitted } from "../harness-runtime/lib/native-children.mjs";
+/** The failure fence forbids fanout, not the exact retained child's recovery. */
+export function childCapacityDispatchAllowed(state, failures, parentId, operationId, promptSha256) {
+    return Object.entries(state.child_capacity ?? {}).some(([sessionId, intent]) => intent.operation_id === operationId
+        && intent.dispatched === true && intent.phase === "dispatched" && intent.prompt_sha256 === promptSha256
+        && failures.some(child => child.session_id === sessionId && child.parent_session_id === parentId
+            && child.status === "failed" && child.provenance !== "parent_mismatch" && child.terminal_turn_id === intent.turn_id));
+}
+/** An overloaded parent may have sent the message, but activity is not admission. */
+export function childCapacityRecoveryDecision(state, children, parentId, operationId, parentTurnId) {
+    const target = Object.entries(state.child_capacity ?? {}).find(([, intent]) => intent.operation_id === operationId);
+    if (!target)
+        return "reconciliation_blocked";
+    const child = children.find(item => item.session_id === target[0]);
+    if (child && (child.parent_session_id !== parentId || child.provenance === "parent_mismatch"))
+        return "reconciliation_blocked";
+    if (!child)
+        return "continue";
+    if (parentTurnId && child.continuation_admission?.parent_turn_id === parentTurnId && target[1].phase === "dispatched")
+        target[1].parent_turn_id = parentTurnId;
+    reconcileChildCapacity(state, [child], parentId);
+    if (["native_message_accepted", "successor_observed"].includes(target[1].phase ?? ""))
+        return "completed";
+    return child.status === "running" || child.terminal_turn_id && child.terminal_turn_id !== target[1].turn_id ? "reconciliation_blocked" : "continue";
+}
+/** Bind native admission to a durable managed parent Turn, never to child prose. */
+export function reconcileChildCapacity(state, children, parentId, observedAt = new Date().toISOString()) {
+    let changed = false;
+    for (const child of children) {
+        const intent = state.child_capacity?.[child.session_id], admission = child.continuation_admission;
+        if (!intent?.dispatched || !intent.operation_id || !intent.parent_turn_id || !intent.continuation_ref || !admission
+            || child.parent_session_id !== parentId || child.provenance === "parent_mismatch" || admission.parent_session_id !== parentId
+            || admission.parent_turn_id !== intent.parent_turn_id || admission.agent_id !== intent.continuation_ref.agent_id)
+            continue;
+        const bound = { ...admission, operation_id: intent.operation_id, predecessor_turn_id: intent.turn_id };
+        child.continuation_admission = bound;
+        const successor = nativeContinuationSuccessor(child, intent.turn_id, intent.continuation_ref.ended_at);
+        if (admission.proof_kind === "parent_tool_successor" && !successor)
+            continue;
+        if (admission.proof_kind === "parent_tool_admission" && !nativeContinuationAdmitted(child, intent.turn_id, intent.continuation_ref.ended_at))
+            continue;
+        const phase = successor ? "successor_observed" : "native_message_accepted";
+        if (intent.phase === "successor_observed" && !successor)
+            continue;
+        if (intent.phase !== phase || JSON.stringify(intent.admission) !== JSON.stringify(bound)) {
+            // A refreshed proof digest/status poll is not a new model signal.
+            if (intent.phase !== phase || !intent.last_signal_at)
+                intent.last_signal_at = observedAt;
+            intent.phase = phase;
+            intent.admission = bound;
+            changed = true;
+        }
+    }
+    return changed;
+}
 /** Only a proven new successful terminal Turn closes a child's retry episode. */
 export function closeSuccessfulChildCapacity(state, children, parentId) {
     const closed = [];
@@ -6,6 +61,9 @@ export function closeSuccessfulChildCapacity(state, children, parentId) {
         if (!retained || child.parent_session_id !== parentId || child.provenance === "parent_mismatch"
             || child.status !== "completed" || !child.terminal_turn_id || child.terminal_turn_id === retained.turn_id)
             continue;
+        if (retained.continuation_ref && retained.phase !== "successor_observed")
+            continue;
+        retained.phase = "settled";
         delete state.child_capacity[child.session_id];
         closed.push(child.session_id);
     }

package/dist/services/controller-child-observer.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { normalizeNativeChildren, safeNativeFailure } from "../harness-runtime/lib/native-children.mjs";
+import { normalizeNativeChildren, safeNativeFailure, nativeContinuationSuccessor } from "../harness-runtime/lib/native-children.mjs";
 /** A durable observation is a dispatch fence, not authority to complete Work. */
 export function retainedChildObserver(input) {
     let active = true, pending;
@@ -13,6 +13,11 @@ export function retainedChildObserver(input) {
         return { session_id: child.session_id, parent_session_id: child.parent_session_id, status: "failed", source: child.source, terminal_turn_id: child.terminal_turn_id,
             ...(typeof child.terminal_observed_at === "string" && Number.isFinite(Date.parse(child.terminal_observed_at)) ? { terminal_observed_at: child.terminal_observed_at } : {}),
             ...(child.native_source ? { native_source: child.native_source } : {}),
+            ...(child.continuation_ref ? { continuation_ref: child.continuation_ref } : {}),
+            ...(child.recovery_unavailable_reason ? { recovery_unavailable_reason: child.recovery_unavailable_reason } : {}),
+            ...(child.continuation_admission ? { continuation_admission: child.continuation_admission } : {}),
+            ...(child.resumed_from_message_id ? { resumed_from_message_id: child.resumed_from_message_id } : {}),
+            ...(child.current_turn_id ? { current_turn_id: child.current_turn_id } : {}),
             ...(child.native_turn_items ? { native_turn_items: {
                     ...(typeof child.native_turn_items.observed === "boolean" ? { observed: child.native_turn_items.observed } : {}),
                     ...(typeof child.native_turn_items.possible_effects === "boolean" ? { possible_effects: child.native_turn_items.possible_effects } : {}),
@@ -46,8 +51,9 @@ export function retainedChildObserver(input) {
         // This is an authoritative current native snapshot. Older failed Turns
         // remain in the journal/episode history, not in the current-outcome fence.
         const resolved = [...retained].filter(([, old]) => children.some(child => child.parent_session_id === input.scope.root_session_id
-            && child.provenance !== "parent_mismatch" && child.session_id === old.session_id && ["completed", "failed"].includes(child.status)
-            && child.terminal_turn_id && child.terminal_turn_id !== old.terminal_turn_id)).map(([key]) => key);
+            && child.provenance !== "parent_mismatch" && child.session_id === old.session_id
+            && (!old.continuation_ref && ["completed", "failed"].includes(child.status) && child.terminal_turn_id && child.terminal_turn_id !== old.terminal_turn_id
+                || nativeContinuationSuccessor(child, old.terminal_turn_id, old.continuation_ref?.ended_at)))).map(([key]) => key);
         if (!failed.length && !resolved.length && !gap)
             return;
         const fd = fs.openSync(input.file, "a", 0o600);

package/dist/services/memory-init-native-capacity.js

@@ -14,7 +14,7 @@ import { inspectDaemonOperation } from "../harness-runtime/lib/daemon-operations
 import { nativeCommandFingerprint } from "../harness-runtime/lib/native-request-proof.mjs";
 import { validateMemoryInitStartupScope } from "./memory-init-startup-custody.js";
 import { continueProviderCapacity } from "./provider-capacity.js";
-import { CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, refusalObservation, terminalProviderOverload } from "../harness-runtime/lib/provider-overload-policy.mjs";
+import { RECOVERY_POLICY as CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, recoveryRefusal as refusalObservation, terminalProviderRecovery as terminalProviderOverload } from "../harness-runtime/lib/provider-overload-policy.mjs";
 const sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
 function refuse(reason, effect = "no_effect") {
     throw new AppError("memory_init_native_capacity_required", "Native startup requires its exact qualified probe", 1, { reason, effect, next_action: "reconcile_exact_native_probe" });

package/dist/services/provider-capacity.js

@@ -1,6 +1,6 @@
 import { setTimeout as delay } from "node:timers/promises";
 import crypto from "node:crypto";
-import { CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, capacityBackoff, nativeItemsSettled, normalizeProviderFailure, overloadExhausted, parseCapacityOperation, refusalObservation, terminalProviderOverload, streamRequestKey } from "../harness-runtime/lib/provider-overload-policy.mjs";
+import { RECOVERY_POLICY as CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, classifyRecoveryError, recoveryBackoff as capacityBackoff, nativeItemsSettled, normalizeRecoveryFailure as normalizeProviderFailure, recoveryExhausted as overloadExhausted, parseCapacityOperation, recoveryRefusal as refusalObservation, terminalProviderRecovery as terminalProviderOverload, streamRequestKey } from "../harness-runtime/lib/provider-overload-policy.mjs";
 import { AppError } from "../shared/errors.js";
 import { isObservationLoss } from "../harness-runtime/lib/operation-errors.mjs";
 import { parseLifecycleCommand, commandOption } from "./lifecycle-command.js";
@@ -48,12 +48,20 @@ export function ownedProviderBoundary(context, input, boundary) {
     return boundary.outcome === "completed" && (input.scope === "work" ? rows[0].status === "completed" : stage.status === "done");
 }
 export function providerChildFailure(child) {
-    return child.provider_failure ?? { code: child.native_source ? "provider_capacity_transient" : "turn_interrupted", details: { native_source: child.native_source, provider_session_id: child.session_id, turn_id: child.terminal_turn_id, native_turn_id: child.terminal_turn_id, terminal_status: child.status, observed_at: child.terminal_observed_at ?? null, provider_error: child.provider_error, native_turn_items: child.native_turn_items } };
+    return child.provider_failure ?? { code: child.native_source ? classifyRecoveryError(child.provider_error) : "turn_interrupted", details: { native_source: child.native_source, provider_session_id: child.session_id, turn_id: child.terminal_turn_id, native_turn_id: child.terminal_turn_id, terminal_status: child.status, observed_at: child.terminal_observed_at ?? null, provider_error: child.provider_error, native_turn_items: child.native_turn_items } };
 }
 export function eligibleProviderChildOverload(child, parentSessionId) {
     return typeof child.session_id === "string" && child.session_id !== parentSessionId && child.parent_session_id === parentSessionId && child.provenance !== "parent_mismatch" && child.status === "failed" && typeof child.terminal_turn_id === "string" && nativeItemsSettled(child.native_turn_items)
         && terminalProviderOverload(providerChildFailure(child), child.session_id, child.terminal_turn_id);
 }
+export function unavailableProviderChildRecovery(child, parentSessionId) {
+    if (typeof child.session_id !== "string" || child.parent_session_id !== parentSessionId || child.provenance === "parent_mismatch" || child.status !== "failed"
+        || typeof child.terminal_turn_id !== "string" || typeof child.recovery_unavailable_reason !== "string" || !/^[a-z][a-z0-9_]{0,127}$/.test(child.recovery_unavailable_reason))
+        return null;
+    const primary = providerChildFailure(child);
+    return terminalProviderOverload(primary, child.session_id, child.terminal_turn_id)
+        ? new AppError("provider_recovery_unavailable", "Native provider refusal is retained, but same-child continuation is not safely supported", 1, { reason: child.recovery_unavailable_reason, child_session_id: child.session_id, terminal_turn_id: child.terminal_turn_id, primary_error: primary }) : null;
+}
 /** A terminal root is not a settled tree. Only the daemon's exact owned tree
  * with a settled root and positively live descendants permits waiting. */
 export function capacityReadiness(seen, sessionId, operationId, turnId, items, allowDescendants = false, requestProof) {
@@ -227,7 +235,7 @@ export async function continueProviderCapacity(input) {
         while (["prepared", "dispatching", "running", "awaiting_provider", "outcome_unknown"].includes(String(observed.state))) {
             input.signal?.throwIfAborted();
             input.assertCurrent();
-            const boundary = await observe(async () => await input.decision?.() ?? "continue", intent.operation_id);
+            const boundary = await observe(async () => await input.decision?.(undefined, error) ?? "continue", intent.operation_id);
             if (boundary === "completed" || boundary === "paused")
                 return { provider_session_id: input.sessionId, capacity_decision: boundary };
             if (boundary === "reconciliation_blocked")
@@ -246,7 +254,7 @@ export async function continueProviderCapacity(input) {
         if (observed.state === "completed" && observed.result && typeof observed.result === "object") {
             input.signal?.throwIfAborted();
             input.assertCurrent();
-            const boundary = await observe(async () => await input.decision?.() ?? "continue", intent.operation_id);
+            const boundary = await observe(async () => await input.decision?.(undefined, error) ?? "continue", intent.operation_id);
             input.signal?.throwIfAborted();
             input.assertCurrent();
             if (boundary === "reconciliation_blocked")
@@ -266,7 +274,7 @@ export async function continueProviderCapacity(input) {
         input.assertCurrent();
         const normalized = normalizeProviderFailure(error, input.sessionId);
         const candidate = normalized?.request_proof.kind === "stream_request" ? normalized.primary_error.details?.recovered_error_boundary : undefined;
-        const decision = await observe(async () => await input.decision?.(candidate?.receipt) ?? "continue", observedOperationId);
+        const decision = await observe(async () => await input.decision?.(candidate?.receipt, error) ?? "continue", observedOperationId);
         input.signal?.throwIfAborted();
         input.assertCurrent();
         if (normalized?.request_proof.kind === "stream_request" && ["completed", "paused"].includes(decision) && !candidate?.receipt)
@@ -445,11 +453,11 @@ export async function continueProviderCapacity(input) {
             // A task can complete/pause while the daemon queues for its permit.
             // Admission then refuses the stale prompt; accept that owner decision
             // before treating the transport's rejection as another provider failure.
+            error = nextError;
+            operationId = nextId;
             const finished = await decide(nextId);
             if (finished)
                 return finished;
-            error = nextError;
-            operationId = nextId;
         }
     }
 }

package/dist/services/run-controller-adapter.js

@@ -6,7 +6,7 @@ import { adapterSessionId, runHarnessAdapter } from "./harness-adapter.js";
 import { runtimeHarness } from "./execution-policy.js";
 import { appendEvent, digest, digestBytes, errorRecord, requireRun } from "./run-controller-state.js";
 import { managedProcessStatus } from "./managed-processes.js";
-import { CAPACITY_POLICY, parseCapacityOperation } from "../harness-runtime/lib/provider-overload-policy.mjs";
+import { RECOVERY_POLICY as CAPACITY_POLICY, parseCapacityOperation } from "../harness-runtime/lib/provider-overload-policy.mjs";
 import { recoveryObservationBudget } from "./recovery-observation-budget.js";
 import { canonicalNativeOperation } from "../harness-runtime/lib/adapter-timeouts.mjs";
 import { retainedDaemonReply } from "../harness-runtime/lib/daemon-observation.mjs";