audit-tools 0.32.19 → 0.32.22

package/dist/remediate/steps/dispatch.js

@@ -1,3615 +1,20 @@
-import { mkdir, rename } from "node:fs/promises";
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
-import { join, relative, dirname, resolve, isAbsolute } from "node:path";
-import { OwnershipRegistry } from "../dispatch/ownershipRegistry.js";
-import { routeAmendmentRequest } from "../dispatch/amendmentClaim.js";
-import { toBlockId, fromBlockId } from "../contractPipeline/idRegistry.js";
-import { readContractArtifact } from "../contractPipeline/artifactStore.js";
-import { verifyPairingForFinding } from "../contractPipeline/changeClassification.js";
-import { StateStore } from "../state/store.js";
-import { REMEDIATION_STEP, isClarificationCategory, } from "../state/types.js";
-import { computeDispatchAdmission, createReservationLedger, tierRank, spawnSyncHidden } from "audit-tools/shared";
-import { deriveCostRank, lookupConfirmedPosition, readConfirmedCostPositions } from "audit-tools/shared";
-import { scheduleWave as computePoolWaveSchedule } from "audit-tools/shared";
-import { withFileLock } from "audit-tools/shared";
-import { captureStepBoundaryFriction } from "audit-tools/shared";
-import { findingLead, renderFindingBadgeBody } from "audit-tools/shared";
-import { runShellCommand, runCommand } from "../utils/commands.js";
-import { mergedBaseCheckArgv } from "./gateCommands.js";
-import { AGENT_FEEDBACK_FILENAME, readJsonFile, readOptionalJsonFile, writeJsonFile, writeTextFile, withFsRetry, formatValidationIssues, detectRepoConventions, formatRepoConventions, toPromptPathToken, estimateTokensFromBytes, buildQuotaSource, HostSessionQuotaSource, severityRank, findingNeedsVerificationBeforeFix, compareTier, mostCapableTier, normalizeRepoPath, buildSourcePools, buildHostModelPools, resolveHostProviderName, isDemotableInProcessProvider, } from "audit-tools/shared";
-import { validateImplementWorkerResult } from "../validation/artifacts.js";
-import { REMEDIATION_DISPATCH_PLAN_CONTRACT_VERSION, REMEDIATION_DISPATCH_QUOTA_CONTRACT_VERSION, REMEDIATION_WORKER_RESULT_CONTRACT_VERSION, } from "./types.js";
-import { classifyFindingRisk, specIndicatesNoChange, hasExecutableEvidence, dependencyVerifiedComplete, } from "./stepUtils.js";
-import { isTerminalStatus, isVerifiedCompleteStatus, isSkipStatus, } from "../state/itemStatus.js";
-import { resnapshotAffectedFileHashes } from "../utils/fileIntegrity.js";
-import { computeDispatchCapacity, resolveHostActiveSubagentLimit, readQuotaState, buildProviderModelKey, computeBackoffCooldownMs, computeBackoffFailureWeight, summarizeDispatchCapacityPools, } from "../quota/index.js";
-export { resolveHostActiveSubagentLimit };
-export { detectHostActiveSubagentLimit as detectHostConcurrencyFromEnv, } from "../quota/hostLimits.js";
-const DEFAULT_WAVE_SIZE = 5;
-export function normalizeSlotTokens(tokens, count) {
-    if (!tokens || tokens.length === 0)
-        return new Array(count).fill(0);
-    if (tokens.length > count)
-        return tokens.slice(0, count);
-    if (tokens.length < count)
-        return [...tokens, ...new Array(count - tokens.length).fill(0)];
-    return tokens;
-}
-export function resolveHostConcurrencyLimit(options) {
-    return resolveHostActiveSubagentLimit({
-        explicitLimit: options.hostMaxConcurrent,
-        sessionConfig: options.sessionConfig ?? {},
-        env: options.env,
-    });
-}
-function _capacityPoolSummary(poolId, slots, schedule) {
-    return {
-        pool_id: poolId,
-        slots,
-        model: schedule.model,
-        confidence: schedule.confidence,
-        source: schedule.source,
-        resolved_limits: schedule.resolved_limits,
-        host_concurrency_limit: schedule.host_concurrency_limit,
-        cooldown_until: schedule.cooldown_until,
-        estimated_wave_tokens: schedule.estimated_wave_tokens,
-        binding_cap: schedule.binding_cap ?? "none",
-        quota_source_snapshot: schedule.quota_source_snapshot ?? null,
-    };
-}
-/**
- * Most-capable rank first, so the largest pending items land on the rank with
- * the largest window. Ordering comes from the single shared tier-rank authority
- * (`compareTier`, negated for descending) — no local {small,standard,deep} copy.
- */
-function sortRosterMostCapableFirst(roster) {
-    return [...roster].sort((a, b) => compareTier(b.rank, a.rank));
-}
-async function buildHostPoolPreamble(input) {
-    const sessionConfig = input.sessionConfig ?? {};
-    const providerName = input.providerName ??
-        sessionConfig.provider ??
-        "claude-code";
-    const hostModel = input.hostModel ??
-        sessionConfig.block_quota
-            ?.host_model ??
-        null;
-    // Quota-key identity: resolved model name, else the host's opaque id, else
-    // null → `provider/*`. Per-roster-rank `model_id` overrides per pool below.
-    const quotaModelKeySegment = hostModel ?? input.hostModelId ?? null;
-    const roster = input.hostModels?.length
-        ? sortRosterMostCapableFirst(input.hostModels)
-        : null;
-    const hostLimit = resolveHostConcurrencyLimit({
-        hostMaxConcurrent: input.hostMaxConcurrent,
-        sessionConfig,
-        env: input.env,
-    });
-    // The capability handshake: the host reported its dispatch model's real
-    // context/output window this session (the roster's most capable entry under
-    // the multi-rank handshake). Carried into the pool's discoveredLimits so the
-    // shared discovered_capability rung sizes the budget to the real window
-    // instead of the conservative 32k floor. RPM/TPM stay null and fill from the
-    // learned quota state.
-    const hostContextTokens = input.hostContextTokens ?? roster?.[0]?.context_tokens ?? null;
-    const hostOutputTokens = input.hostOutputTokens ?? roster?.[0]?.output_tokens ?? null;
-    const hostCapabilityLimits = hostContextTokens != null || hostOutputTokens != null
-        ? { context_tokens: hostContextTokens, output_tokens: hostOutputTokens }
-        : null;
-    let quotaEntries = {};
-    try {
-        const state = await readQuotaState();
-        quotaEntries = state.entries;
-    }
-    catch (err) {
-        process.stderr.write(`[waveScheduler] readQuotaState failed; degrading to no learned quota entry. ${err instanceof Error ? err.message : String(err)}\n`);
-    }
-    // The proactive quota snapshot (Claude OAuth source, then learned) so the
-    // scheduler can throttle/cooldown from live remaining quota — mirrors
-    // audit-code's buildDispatchPool. PREPEND the host-session source keyed on
-    // this host pool's own (provider, model) key — first-class PRE-WALL source
-    // (graduated remaining_pct → LOW/CRITICAL throttle before a 429), gating on the
-    // exact key so it never masks the proactive/learned sources.
-    const quotaSource = buildQuotaSource({
-        halfLifeHours: sessionConfig.quota
-            ?.empirical_half_life_hours,
-        hostSession: input.hostSession ??
-            new HostSessionQuotaSource({
-                providerModelKey: buildProviderModelKey(providerName, quotaModelKeySegment),
-            }),
-    });
-    // One capacity pool per reported roster rank (most capable first), each with
-    // its own discovered window and quota key; a single pool for the scalar/absent
-    // handshake. Built via the shared host-pool-from-roster core so the pool shape
-    // + account-keyed pool ids can't drift across the two consumers.
-    const primaryPools = await buildHostModelPools({
-        providerName,
-        hostModel,
-        hostConcurrencyLimit: hostLimit,
-        quotaSource,
-        quotaEntries,
-        roster,
-        resolve: (entry) => ({
-            poolKey: buildProviderModelKey(providerName, entry?.model_id ?? quotaModelKeySegment),
-            discoveredLimits: entry
-                ? { context_tokens: entry.context_tokens, output_tokens: entry.output_tokens }
-                : hostCapabilityLimits,
-        }),
-    });
-    return {
-        sessionConfig,
-        providerName,
-        hostModel,
-        quotaModelKeySegment,
-        roster,
-        hostLimit,
-        hostContextTokens,
-        hostOutputTokens,
-        hostCapabilityLimits,
-        quotaEntries,
-        quotaSource,
-        primaryPools,
-    };
-}
-export async function scheduleWave(input) {
-    const sessionConfig = input.sessionConfig ?? {};
-    const providerName = input.providerName ?? sessionConfig.provider ?? "claude-code";
-    const hostModel = input.hostModel ?? sessionConfig.block_quota?.host_model ?? null;
-    // Quota-key identity: resolved model name, else the host's opaque id, else
-    // null → `provider/*`. Per-roster-rank `model_id` overrides per pool below.
-    const quotaModelKeySegment = hostModel ?? input.hostModelId ?? null;
-    const roster = input.hostModels?.length
-        ? sortRosterMostCapableFirst(input.hostModels)
-        : null;
-    const hostLimit = resolveHostConcurrencyLimit({
-        hostMaxConcurrent: input.hostMaxConcurrent,
-        sessionConfig,
-        env: input.env,
-    });
-    // The capability handshake: the host reported its dispatch model's real
-    // context/output window this session (the roster's most capable entry under
-    // the multi-rank handshake). Carried into the pool's discoveredLimits so the
-    // shared discovered_capability rung sizes the budget to the real window
-    // instead of the conservative 32k floor. RPM/TPM stay null and fill from the
-    // learned quota state.
-    const hostContextTokens = input.hostContextTokens ?? roster?.[0]?.context_tokens ?? null;
-    const hostOutputTokens = input.hostOutputTokens ?? roster?.[0]?.output_tokens ?? null;
-    const quota = sessionConfig.quota;
-    if (!quota || quota.enabled === false) {
-        const cap = hostLimit?.active_subagents ?? DEFAULT_WAVE_SIZE;
-        const waveSize = Math.max(1, Math.min(cap, input.itemCount));
-        // Single-source the quota-off schedule math (wave-token formula + confidence +
-        // source) through the shared scheduler so the two orchestrators can't drift —
-        // remediate previously re-implemented it with a flat average + confidence:"low",
-        // disagreeing with shared's sumTopN + "high". The wave is already capped to
-        // `waveSize`, so shared (`requestedConcurrency: waveSize`, no quota) returns it
-        // verbatim. Only the roster-honoring window and the DEFAULT_WAVE_SIZE-aware
-        // binding_cap are remediate-specific and layered back on top.
-        const base = computePoolWaveSchedule({
-            providerName,
-            sessionConfig,
-            hostModel,
-            requestedConcurrency: waveSize,
-            estimatedSlotTokens: input.estimatedSlotTokens,
-            hostConcurrencyLimit: hostLimit,
-        });
-        const schedule = {
-            ...base,
-            resolved_limits: {
-                // Honor a host-reported window even with quota disabled; fall back to the
-                // shared scheduler's default only when nothing was discovered.
-                context_tokens: hostContextTokens ?? base.resolved_limits.context_tokens,
-                output_tokens: hostOutputTokens ?? base.resolved_limits.output_tokens,
-                requests_per_minute: null,
-                input_tokens_per_minute: null,
-                output_tokens_per_minute: null,
-            },
-            host_concurrency_limit: hostLimit,
-            // hostLimit-gated: a DEFAULT_WAVE_SIZE cap below itemCount is NOT a host
-            // concurrency bind (there is no host limit), so it stays "none".
-            binding_cap: hostLimit && waveSize < input.itemCount ? "host_concurrency" : "none",
-        };
-        return {
-            ...schedule,
-            capacity_pools: [_capacityPoolSummary(buildProviderModelKey(providerName, quotaModelKeySegment), waveSize, schedule)],
-        };
-    }
-    const preamble = await buildHostPoolPreamble({
-        sessionConfig: input.sessionConfig,
-        providerName: input.providerName,
-        hostModel: input.hostModel,
-        hostMaxConcurrent: input.hostMaxConcurrent,
-        hostContextTokens: input.hostContextTokens,
-        hostOutputTokens: input.hostOutputTokens,
-        hostModels: input.hostModels,
-        hostModelId: input.hostModelId,
-        env: input.env,
-    });
-    const capacity = computeDispatchCapacity({
-        pools: preamble.primaryPools,
-        sessionConfig,
-        pendingItemTokens: normalizeSlotTokens(input.estimatedSlotTokens, input.itemCount),
-    });
-    return {
-        ...capacity.primary.schedule,
-        capacity_pools: summarizeDispatchCapacityPools(capacity),
-    };
-}
-/**
- * Build the confirmed `CapacityPool[]` for a dispatch — one pool per reported
- * roster rank (each with its own discovered window + quota key), or a single
- * conservative pool for the scalar/absent handshake. This is the same pool shape
- * `scheduleWave` constructs internally; it is exposed so the rolling dispatch
- * engine (which is fed `confirmedPools` directly) sizes concurrency from the
- * identical quota inputs, never from a raw host flag. Reused by
- * `driveRollingImplementDispatch`.
- */
-export async function buildConfirmedPools(input) {
-    // Defect-1: the ACTUAL configured backend (used to build the demoted source pool) vs
-    // the HOST-pool identity. When an attended host demotes a headless backend to a source
-    // (codex/opencode/openai-compatible), the host pool must key to the CONVERSATION HOST
-    // (claude-code), not the backend — otherwise the host fan-out is charged against the
-    // backend's meter AND collides with the demoted source pool ([[capability-is-per-auditor-not-per-audit]]).
-    const actualProviderName = resolveHostProviderName(input.sessionConfig);
-    const demoteHostIdentity = input.demotePrimaryInProcess === true && isDemotableInProcessProvider(actualProviderName);
-    const hostProviderName = demoteHostIdentity
-        ? "claude-code"
-        : actualProviderName;
-    // Resolve identity/limits and build the per-rank host-model pools via the
-    // SAME preamble `scheduleWave` uses — the two no longer keep parallel copies.
-    const { sessionConfig, quotaSource, quotaEntries, primaryPools } = await buildHostPoolPreamble({
-        sessionConfig: input.sessionConfig,
-        providerName: hostProviderName,
-        hostMaxConcurrent: input.hostMaxConcurrent,
-        hostContextTokens: input.hostContextTokens,
-        hostOutputTokens: input.hostOutputTokens,
-        hostModels: input.hostModels,
-        hostModelId: input.hostModelId,
-        env: input.env,
-        hostSession: input.hostSession,
-    });
-    // Every configured dispatchable backend source (any non-IDE source: NIM/vLLM API,
-    // a CLI pool, …) becomes a CapacityPool alongside the primary, so the scheduler's
-    // proactive cross-pool spill (INV-QD-14) and the A-8 coordinator can route work to
-    // them. Single-sourced in shared (`buildSourcePools`) so audit and remediate surface
-    // the IDENTICAL pool shapes — the spill topology can't drift. `primaryProviderName`
-    // is the ACTUAL configured backend (not the demoted host identity) so the demoted
-    // source is built for the real provider.
-    const sourcePools = await buildSourcePools({
-        sessionConfig,
-        primaryProviderName: actualProviderName,
-        quotaSource,
-        quotaEntries,
-        demotePrimaryInProcess: input.demotePrimaryInProcess,
-    });
-    primaryPools.push(...sourcePools);
-    return primaryPools;
-}
-/**
- * Build the `AdmissionPool[]` the admission loop admits against from a schedule's
- * per-pool capacity summaries — the remediate analog of audit's `finalizeDispatchQuota`
- * pool mapping (both feed the single-sourced `computeDispatchAdmission`, so the two
- * orchestrators can't drift). Budget = the pool's live remaining token budget
- * (null ⇒ optimistic +Inf); declared cap = its host in-flight cap passed VERBATIM
- * (null ⇒ none — the only place an explicit agent-count exists); cost/capability rank
- * from its tier; capacity = its context window (a packet's input+output envelope must fit).
- */
-function admissionPoolsFromSchedule(schedule, confirmedCostPositions) {
-    return (schedule.capacity_pools ?? []).map((pool) => {
-        // costRank is a REAL cost axis (blended $/Mtok via the shared cost-first
-        // engine), decoupled from capabilityRank (still the tier ordinal). See
-        // spec/cost-first-routing.md. Rung 1 (operator-confirmed) via the model-keyed
-        // map; absent ⇒ price (rung 2) ⇒ tier (rung 3).
-        return {
-            poolId: pool.pool_id,
-            resourceKey: pool.pool_id,
-            budget: pool.remaining_token_budget ?? Number.POSITIVE_INFINITY,
-            declaredCap: pool.host_concurrency_limit?.active_subagents ?? null,
-            costRank: deriveCostRank({
-                model: pool.model,
-                tier: pool.rank,
-                confirmedPosition: lookupConfirmedPosition(confirmedCostPositions, pool.model),
-            }),
-            capabilityRank: tierRank(pool.rank),
-            capacityTokens: pool.resolved_limits.context_tokens,
-        };
-    });
-}
-export async function buildDispatchQuota(runId, phase, schedule, admissionPackets, 
-/**
- * Whether to LEASE the granted set against the shared reservation ledger. The
- * host-subagent path passes `true` (the host dispatches the grant across processes,
- * so the tool reserves-before-dispatch and reconciles at accept-node). The
- * in-process rolling engine passes `false`: it admits + leases per-packet itself, so
- * a host-grant lease here would double-count the same work. Mirrors audit's
- * `finalizeDispatchQuota` grantLeases parameterization.
- */
-grantLeases, quotaStateEntry, 
-/**
- * Operator-confirmed cost ordering (rung 1 of costRank; spec/cost-first-routing.md),
- * keyed by model id → 0-based confirmed position. Absent ⇒ price then tier.
- */
-confirmedCostPositions) {
-    let backoffState = null;
-    const count = quotaStateEntry?.consecutive_429_count ?? 0;
-    if (count > 0) {
-        backoffState = {
-            consecutive_429_count: count,
-            current_cooldown_ms: computeBackoffCooldownMs(count),
-            current_failure_weight: computeBackoffFailureWeight(count),
-        };
-    }
-    // Admission control: instead of a computed `max_concurrent_agents`, GRANT the
-    // affordable admitted set (cost-first-capable, ledger-leased). Per-packet reservation
-    // = input estimate + output envelope (declared output cap; the learned ratio refines
-    // it once a provider reports usage — dormant on the always-on claude-code host).
-    const admission = await computeDispatchAdmission({
-        packets: admissionPackets,
-        pools: admissionPoolsFromSchedule(schedule, confirmedCostPositions),
-        outputCap: schedule.resolved_limits.output_tokens,
-        grantLeases,
-        ledger: createReservationLedger(),
-    });
-    return {
-        contract_version: REMEDIATION_DISPATCH_QUOTA_CONTRACT_VERSION,
-        run_id: runId,
-        phase,
-        host_concurrency_limit: schedule.host_concurrency_limit,
-        admission,
-        estimated_wave_tokens: schedule.estimated_wave_tokens,
-        model: schedule.model,
-        confidence: schedule.confidence,
-        source: schedule.source,
-        resolved_limits: schedule.resolved_limits,
-        cooldown_until: schedule.cooldown_until,
-        binding_cap: schedule.binding_cap ?? "none",
-        capacity_pools: schedule.capacity_pools,
-        quota_source_snapshot: schedule.quota_source_snapshot ?? null,
-        backoff_state: backoffState,
-    };
-}
 // ---------------------------------------------------------------------------
-// Byte-based token estimation helpers
-// ---------------------------------------------------------------------------
-/** Fixed prompt overhead per dispatch slot (prompt instructions, JSON schema, etc.). */
-const PROMPT_OVERHEAD_TOKENS = 2000;
-/** Sum the byte sizes of a list of absolute or repo-relative file paths. */
-function sumFileSizes(filePaths) {
-    let total = 0;
-    for (const p of filePaths) {
-        try {
-            total += statSync(p).size;
-        }
-        catch {
-            // Missing file → 0 bytes; not an error for estimation purposes.
-        }
-    }
-    return total;
-}
-/** Estimate slot tokens for an implement dispatch slot from readFiles byte sizes. */
-function estimateImplementSlotTokens(readFiles, root) {
-    const absPaths = readFiles.map((f) => f.startsWith("/") || /^[A-Za-z]:[/\\]/.test(f) ? f : join(root, f));
-    const bytes = sumFileSizes(absPaths);
-    return estimateTokensFromBytes(bytes) + PROMPT_OVERHEAD_TOKENS;
-}
-// ---------------------------------------------------------------------------
-// detectRepoConventions cache (one call per repo root per process)
-// ---------------------------------------------------------------------------
-/** Module-level cache: repo root → formatted conventions string. */
-export const detectRepoConventionsCache = new Map();
-function getCachedConventions(root) {
-    if (detectRepoConventionsCache.has(root)) {
-        return detectRepoConventionsCache.get(root);
-    }
-    const result = formatRepoConventions(detectRepoConventions(root));
-    detectRepoConventionsCache.set(root, result);
-    return result;
-}
-/**
- * The git top-level directory containing `cwd`, or `null` when `cwd` is not
- * inside a git working tree (or git is unavailable). `git rev-parse
- * --show-toplevel` emits a forward-slash absolute path on every platform.
- */
-export function gitTopLevel(cwd) {
-    const result = spawnSyncHidden("git", ["rev-parse", "--show-toplevel"], {
-        cwd,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (result.status !== 0)
-        return null;
-    const top = (result.stdout ?? "").trim();
-    return top.length > 0 ? top : null;
-}
-/**
- * Canonical comparison key for a filesystem path. `realpathSync` resolves
- * symlinks and platform short-names so it matches git's `--show-toplevel`
- * output (macOS TMPDIR `/var`→`/private/var`, Windows 8.3 names); falls back to
- * `resolve` for paths that don't exist on disk (e.g. mocked unit tests).
- */
-function canonicalPathKey(p) {
-    try {
-        return normalizeRepoPath(realpathSync(p));
-    }
-    catch {
-        return normalizeRepoPath(resolve(p));
-    }
-}
-/**
- * Create an isolated git worktree on a fresh branch at HEAD. Throws on non-zero exit.
- *
- * Refuses when `root` is not ITSELF a git top-level: a bare `git worktree add`
- * with `cwd: root` walks UP to the nearest enclosing repo and silently creates
- * the worktree/branch in that ancestor (observed polluting the monorepo with
- * leaked `remediate-*` branches during the rolling_engine flip). The resolved
- * top-level must equal the target root, or we refuse rather than escape.
- */
-export function createWorktree(root, worktreePath, branchName) {
-    const top = gitTopLevel(root);
-    if (top === null) {
-        throw new Error(`Refusing to create a worktree: ${root} is not inside a git repository ` +
-            `(git rev-parse --show-toplevel failed). Rolling dispatch requires the target root to be a git repo.`);
-    }
-    if (canonicalPathKey(top) !== canonicalPathKey(root)) {
-        throw new Error(`Refusing to create a worktree: the git top-level for ${root} is ${top}, not the target root ` +
-            `itself, so 'git worktree add' would escape to an ancestor repo. Initialize a git repo at the ` +
-            `target root before rolling dispatch.`);
-    }
-    const result = spawnSyncHidden("git", ["worktree", "add", "-b", branchName, worktreePath, "HEAD"], { cwd: root, encoding: "utf8", shell: false });
-    if (result.status !== 0) {
-        const stderr = (result.stderr ?? "").trim();
-        const stdout = (result.stdout ?? "").trim();
-        throw new Error(`git worktree add failed (exit ${result.status ?? "unknown"}):\n${stderr || stdout}`);
-    }
-    // Link the main checkout's (gitignored → absent-in-worktree) node_modules so
-    // per-node verify can resolve deps. Folded into creation, not left to each
-    // caller to remember — a fresh worktree without it silently fails verify with
-    // missing-module errors. Best-effort + idempotent (see ensureWorktreeNodeModules).
-    ensureWorktreeNodeModules(root, worktreePath);
-}
-/**
- * Materialize into a fresh worktree any of the node's declared target paths that
- * exist in the main tree but are absent from the worktree — i.e. git-untracked or
- * gitignored files that `git worktree add HEAD` does not bring over. Without this
- * a node whose scope names an untracked config file (the dogfood hit
- * `opencode.json` and an uncommitted `.gemini/commands/*.toml`) cannot see its own
- * target, so the edit silently no-ops. The "absent in worktree" test is the
- * discriminator: a tracked path is already materialized from HEAD, so only the
- * genuinely-missing untracked/ignored declarations are copied — a tracked-but-dirty
- * file keeps its clean-from-HEAD worktree content and is never clobbered. Paths are
- * repo-relative (the declared scope contract); absolute/escaping paths are skipped.
- * Best-effort: a copy failure must not abort the dispatch (logged, not thrown).
- */
-export function seedUntrackedDeclaredPaths(root, worktreeRoot, declaredPaths) {
-    for (const rel of new Set(declaredPaths)) {
-        if (!rel || isAbsolute(rel))
-            continue;
-        // Reject paths that escape the root (defence-in-depth; declared scope is
-        // repo-relative and never `..`-prefixed in practice).
-        const dst = join(worktreeRoot, rel);
-        const src = join(root, rel);
-        if (relative(worktreeRoot, dst).startsWith(".."))
-            continue;
-        if (!existsSync(src) || existsSync(dst))
-            continue;
-        try {
-            mkdirSync(dirname(dst), { recursive: true });
-            cpSync(src, dst, { recursive: true });
-        }
-        catch (err) {
-            process.stderr.write(`[remediate-code] worktree seed: could not copy untracked declared path ${rel}: ${err.message}\n`);
-        }
-    }
-}
-/** Remove a git worktree. Best-effort: logs but does not throw on failure. */
-export function removeWorktree(root, worktreePath) {
-    // Already-absent worktree = silent no-op: no spawn, no stderr, no throw. A
-    // path that still exists but fails git-remove for another reason is surfaced
-    // exactly as before. We do NOT match on the 'not a working tree' stderr text.
-    if (!existsSync(worktreePath))
-        return;
-    const result = spawnSyncHidden("git", ["worktree", "remove", "--force", worktreePath], { cwd: root, encoding: "utf8", shell: false });
-    if (result.status !== 0) {
-        const stderr = (result.stderr ?? "").trim();
-        process.stderr.write(`[remediate-code] worktree remove failed (exit ${result.status ?? "unknown"}): ${stderr}\n`);
-    }
-}
-/**
- * Fully reset a node's isolated worktree + branch so a fresh `createWorktree -b`
- * can run, even when a prior attempt left either behind. This is the idempotent
- * cleanup the in-process driver needs across a `rate_limited` re-queue: the
- * engine re-enters the dispatcher for the SAME block while its branch (and maybe
- * a stale worktree admin entry) still exist, and `git worktree add -b <branch>`
- * would otherwise fail with "branch already exists". Removing the worktree,
- * pruning stale admin records, then force-deleting the branch makes every
- * (re-)dispatch start clean from HEAD. All steps are best-effort (a missing
- * worktree/branch is the expected first-attempt case, not an error). Any partial
- * edits from a throttled prior attempt are intentionally discarded — the
- * re-dispatch redoes the node from HEAD.
- */
-export function resetNodeWorktreeAndBranch(root, worktreePath, branchName) {
-    removeWorktree(root, worktreePath);
-    // Prune stale worktree admin entries (e.g. a dir deleted out from under git),
-    // otherwise `git worktree add` can refuse a path it still thinks is registered.
-    spawnSyncHidden("git", ["worktree", "prune"], { cwd: root, shell: false });
-    // Force-delete the leftover branch from a prior attempt so `-b` recreates it.
-    spawnSyncHidden("git", ["branch", "-D", branchName], { cwd: root, shell: false });
-    // Force-remove a leftover worktree DIRECTORY: when a prior attempt's worktree
-    // became an orphaned dir (registered admin entry gone but files remain),
-    // `git worktree remove` no-ops ("is not a working tree") and `git worktree add`
-    // then refuses because the path already exists. Deleting the dir makes the
-    // re-create succeed. Best-effort.
-    if (existsSync(worktreePath)) {
-        rmSync(worktreePath, { recursive: true, force: true });
-    }
-}
-/**
- * Run each targeted command in the worktree directory. Returns pass/fail and
- * combined output.
- *
- * `targeted_commands` are opaque host-authored command *strings* (e.g.
- * `npm run build`, `grep -c '/packages/' .gitignore`, anything with pipes,
- * quotes, or redirections), NOT pre-tokenized argv. They are run through the
- * platform shell (`runShellCommand` → `spawnSync(..., { shell: true })`, the
- * same path `close.ts` uses for `test_command`/`e2e_command`) so the shell — not
- * a word-split + `spawnSync(shell:false)` — resolves the verb. That is what
- * makes this OS-agnostic: on win32 `cmd.exe` natively execs `.cmd` shims (npm,
- * npx, …) and resolves PATH commands; on darwin/linux `/bin/sh` does. The prior
- * argv path ENOENT'd the *spawn itself* for any verb that wasn't a bare
- * executable (e.g. `grep` on Windows), turning a correct fix into a phantom
- * contract failure that burned the retry budget.
- */
-export function verifyNodeInWorktree(worktreePath, targetedCommands) {
-    const outputs = [];
-    for (const cmd of targetedCommands) {
-        const r = runShellCommand(cmd, {
-            cwd: worktreePath,
-            encoding: "utf8",
-        });
-        if (r.error) {
-            // Shell itself failed to spawn — surface it as a verify failure with the
-            // error text rather than a silent status.
-            outputs.push(`$ ${cmd}\n${r.error.message}`);
-            return { passed: false, output: outputs.join("\n---\n") };
-        }
-        const combined = [r.stdout ?? "", r.stderr ?? ""].filter(Boolean).join("\n");
-        outputs.push(`$ ${cmd}\n${combined}`);
-        if (r.status !== 0) {
-            return { passed: false, output: outputs.join("\n---\n") };
-        }
-    }
-    return { passed: true, output: outputs.join("\n---\n") };
-}
-/** Merge the worktree branch into the current HEAD via cherry-pick. On failure, removes the worktree and returns the error. */
-export function mergeWorktree(root, worktreePath, branchName) {
-    // Get the tip commit of the worktree branch
-    const revResult = spawnSyncHidden("git", ["rev-parse", branchName], {
-        cwd: root,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (revResult.status !== 0) {
-        const errMsg = (revResult.stderr ?? "").trim();
-        removeWorktree(root, worktreePath);
-        return { success: false, error: `Failed to resolve worktree branch ${branchName}: ${errMsg}` };
-    }
-    const worktreeTip = revResult.stdout.trim();
-    const mergeResult = spawnSyncHidden("git", ["cherry-pick", worktreeTip], {
-        cwd: root,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (mergeResult.status !== 0) {
-        const stderr = (mergeResult.stderr ?? "").trim();
-        // Abort the cherry-pick so the main tree stays clean
-        spawnSyncHidden("git", ["cherry-pick", "--abort"], { cwd: root, shell: false });
-        removeWorktree(root, worktreePath);
-        return { success: false, error: `cherry-pick failed: ${stderr}` };
-    }
-    removeWorktree(root, worktreePath);
-    return { success: true };
-}
-/**
- * Repo-relative tracked paths in the MAIN checkout that have uncommitted changes
- * AND collide with a path the node's branch edits. A pre-existing dirty tracked
- * file the cherry-pick would touch makes `git cherry-pick` abort with the opaque
- * "Your local changes to the following files would be overwritten by merge" — a
- * condition the node itself cannot fix and that identically re-fails every
- * auto-retry (observed: a docs-only node routed to human triage over unrelated
- * uncommitted WIP on the same file). Detected here so `acceptNodeWorktree` can
- * surface the actionable cause (which file, commit-or-stash) instead of the raw
- * git error. Best-effort: an unavailable diff / status probe returns `[]` (fall
- * through to the normal cherry-pick, which reproduces the original behaviour).
- */
-export function dirtyMainTreeCollisions(root, branch) {
-    const edited = gitEditedFilesForBranch(root, branch);
-    if (!edited.available || edited.files.size === 0)
-        return [];
-    const status = spawnSyncHidden("git", ["status", "--porcelain", "--", ...edited.files], { cwd: root, encoding: "utf8", shell: false });
-    if (status.error || status.status !== 0)
-        return [];
-    const dirty = [];
-    for (const line of (status.stdout ?? "").split(/\r?\n/)) {
-        // Porcelain v1: two status chars + a space, then the path. Rename entries
-        // ("R  old -> new") keep the destination after the arrow.
-        const raw = line.slice(3).trim();
-        if (raw.length === 0)
-            continue;
-        const arrow = raw.lastIndexOf(" -> ");
-        const p = (arrow >= 0 ? raw.slice(arrow + 4) : raw).replace(/\\/g, "/");
-        if (p.length > 0)
-            dirty.push(p);
-    }
-    return dirty;
-}
-/**
- * Rebase a node's worktree branch onto the main checkout's current HEAD (the
- * remediation branch tip) so a sibling that merged AFTER this worktree was created
- * is folded in before this node verifies and merges. Additive edits to a shared
- * file merge automatically (git's per-commit 3-way); a true hunk conflict is a
- * genuine seam that aborts cleanly so the node routes to triage instead of landing
- * a broken merge. The branch is checked out in the worktree, so the rebase runs
- * there. A no-op (branch already on HEAD — the common, no-sibling-merged case)
- * succeeds. Leaves the branch on its pre-rebase commit on abort (so the failed
- * node's work can still be quarantined).
- */
-export function rebaseBranchOntoHead(root, worktreePath, branch) {
-    const head = spawnSyncHidden("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8", shell: false });
-    if (head.error || head.status !== 0) {
-        const detail = (head.stderr ?? head.error?.message ?? "git rev-parse failed").toString().trim();
-        return { ok: false, error: `could not resolve remediation HEAD for rebase: ${detail}` };
-    }
-    const target = head.stdout.trim();
-    const rebase = spawnSyncHidden("git", ["rebase", target], {
-        cwd: worktreePath,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (rebase.error || rebase.status !== 0) {
-        const detail = [rebase.stdout ?? "", rebase.stderr ?? "", rebase.error?.message ?? ""]
-            .filter(Boolean)
-            .join("\n")
-            .trim();
-        // Leave a clean tree: abort the in-progress rebase before the worktree is dropped.
-        spawnSyncHidden("git", ["rebase", "--abort"], { cwd: worktreePath, shell: false });
-        return {
-            ok: false,
-            error: `rebase onto the current remediation HEAD conflicted (a real seam — two ` +
-                `nodes edited the same lines): ${detail}`,
-        };
-    }
-    return { ok: true };
-}
-/** Worktree path for a remediation block. */
-export function worktreePath(root, blockId, runId) {
-    return join(root, ".audit-tools", "worktrees", `remediate-${blockId}-${runId}`);
-}
-/**
- * Deterministic name of the dedicated remediation branch for a run. Derived from
- * the stable run id (= the plan id, constant for the whole remediation) so every
- * wave and the final report resolve the SAME branch without persisting it. Ref-safe:
- * any character outside [A-Za-z0-9._-] collapses to '-'. Distinct from the per-node
- * worktree branches (`remediate-<blockId>-<runId>`) — this uses a `remediation/` ref
- * namespace so the two never collide.
- */
-function refSafeSegment(s, fallback) {
-    return (s
-        .replace(/[^A-Za-z0-9._-]+/g, "-")
-        .replace(/\.{2,}/g, ".") // ".." is invalid in a git ref name
-        .replace(/^[-.]+|[-.]+$/g, "") || fallback);
-}
-export function remediationBranchName(runId) {
-    return `remediation/${refSafeSegment(runId, "run")}`;
-}
-/**
- * Lock path for the base-mutating accept critical section (INV-2/CE-001), keyed on
- * the base repo root + run's remediation branch. DISTINCT from the per-run
- * `rolling-session.lock` (`withFileLock` is non-reentrant — an exclusive `wx`
- * create — so the base lock MUST be a different path than the session lock
- * `advanceHostRolling` already holds, or the nested acquire would self-deadlock).
- * Both rolling drivers (host-subagent + in-process) serialize the rebase →
- * cherry-pick → cross-package check → reset sequence through this single lock.
- */
-export function baseBranchLockPath(root, runId) {
-    return join(root, ".audit-tools", "remediation", "runs", refSafeSegment(runId, "run"), "base-branch.lock");
-}
-/** Durable ref under which a failed-but-committed node's commit is preserved. */
-export function quarantineRef(runId, blockId) {
-    return `refs/remediation-quarantine/${refSafeSegment(runId, "run")}/${refSafeSegment(blockId, "node")}`;
-}
-/**
- * Preserve a failed-but-committed node's work so it can never be lost. A node that
- * committed real edits to its worktree branch but then failed verify / the
- * write-scope gate / the cherry-pick is about to have its worktree removed and (on
- * the next re-dispatch) its branch force-deleted — orphaning the commit. The dogfood
- * lost a verified fix exactly this way (the worktree was pruned before recovery).
- * Point a durable ref at the branch tip: a ref under refs/remediation-quarantine/
- * survives `git branch -D` and `git worktree prune`, so the work stays reachable for
- * a manual `git cherry-pick`. Best-effort; returns the ref + commit, or null.
- */
-export function quarantineFailedNodeCommit(root, branch, runId, blockId) {
-    const rev = spawnSyncHidden("git", ["rev-parse", "--verify", "--quiet", `${branch}^{commit}`], {
-        cwd: root,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (rev.status !== 0)
-        return null;
-    const commit = (rev.stdout ?? "").trim();
-    const ref = quarantineRef(runId, blockId);
-    const upd = spawnSyncHidden("git", ["update-ref", ref, commit], {
-        cwd: root,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (upd.status !== 0) {
-        process.stderr.write(`[remediate-code] could not quarantine ${branch}: ${(upd.stderr ?? "").trim()}\n`);
-        return null;
-    }
-    process.stderr.write(`[remediate-code] preserved failed node ${blockId} commit ${commit.slice(0, 8)} at ${ref} for recovery\n`);
-    return { ref, commit };
-}
-/**
- * Preserve a failed-but-UNCOMMITTED node's worktree edits before the worktree is
- * removed. The verify / scope / merge-fail paths quarantine an already-committed
- * branch tip; this is the missing twin for the commit-REFUSAL path: when
- * `commitWorktree` fails loudly (e.g. a generated artifact landed under the write
- * scope — the genuine CE-003 fail-loud), the worker's real source edits are still
- * sitting uncommitted in the worktree and would be destroyed by `removeWorktree`.
- * Stage everything and land a preservation commit on the node's ISOLATED branch
- * (never cherry-picked into main — it exists only so a durable quarantine ref can
- * point at the otherwise-lost work), then quarantine that commit. A guard that
- * destroys good work is worse than the bug it guards. Best-effort; returns the
- * quarantine ref + commit, or null when there was nothing to preserve / it failed.
- */
-export function quarantineUncommittedWorktreeEdits(root, worktreeRoot, branch, runId, blockId) {
-    // Stage tracked modifications + new (non-ignored) source files. `git add -A`
-    // honours .gitignore, so the incidental ignored churn (node_modules/dist) and
-    // the offending generated artifact stay out — what we preserve is the worker's
-    // real source work.
-    const add = spawnSyncHidden("git", ["add", "-A"], {
-        cwd: worktreeRoot,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (add.status !== 0)
-        return null;
-    // Nothing staged → no uncommitted edits to preserve.
-    const staged = spawnSyncHidden("git", ["diff", "--cached", "--quiet"], {
-        cwd: worktreeRoot,
-        shell: false,
-    });
-    if (staged.status === 0)
-        return null;
-    const commit = spawnSyncHidden("git", ["commit", "-m", `remediate-quarantine ${blockId} (${runId}) — fail-loud preserve`], { cwd: worktreeRoot, encoding: "utf8", shell: false });
-    if (commit.status !== 0) {
-        process.stderr.write(`[remediate-code] could not preserve uncommitted edits for ${blockId}: ${(commit.stderr ?? "").trim()}\n`);
-        return null;
-    }
-    return quarantineFailedNodeCommit(root, branch, runId, blockId);
-}
-/** Clear a node's quarantine ref (e.g. once a later re-dispatch landed successfully). Best-effort. */
-export function clearQuarantinedCommit(root, runId, blockId) {
-    spawnSyncHidden("git", ["update-ref", "-d", quarantineRef(runId, blockId)], {
-        cwd: root,
-        encoding: "utf8",
-        shell: false,
-    });
-}
-/** Quarantined failed-node commits still preserved for a run, for recovery surfacing in the report. */
-export function listQuarantinedCommits(root, runId) {
-    const prefix = `refs/remediation-quarantine/${refSafeSegment(runId, "run")}/`;
-    const res = spawnSyncHidden("git", ["for-each-ref", "--format=%(refname) %(objectname)", prefix], {
-        cwd: root,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (res.status !== 0 || !res.stdout)
-        return [];
-    const out = [];
-    for (const line of res.stdout.split("\n")) {
-        const [ref, commit] = line.trim().split(/\s+/);
-        if (!ref || !commit)
-            continue;
-        out.push({ block: ref.slice(prefix.length), ref, commit });
-    }
-    return out;
-}
-/**
- * Ensure the main checkout is on the dedicated remediation branch BEFORE any node
- * commit is cherry-picked, so accepted work lands there and the user's base branch
- * is NEVER modified — the run leaves a feature branch for review (it does not merge
- * back). Idempotent across waves: creates the branch from the current HEAD (the base)
- * the first time, checks it out on later waves. Best-effort on a non-git root (the
- * worktree dispatch flow can't run there anyway): returns null without throwing so
- * non-git callers/tests are unaffected. Returns the branch name on success.
- */
-/** Sidecar recording the base branch the run was launched from (B5). */
-export function remediationBaseBranchPath(artifactsDir) {
-    return join(artifactsDir, "remediation-base-branch.json");
-}
-/**
- * The base branch this run was launched from, recorded when the remediation
- * branch was first created. `null` when unrecorded (e.g. a detached HEAD at
- * launch, or a branch created by a prior run) — the opt-in merge-to-base
- * closing action degrades to "merge manually" rather than guessing a target.
- */
-export function readRemediationBaseBranch(artifactsDir) {
-    try {
-        const parsed = JSON.parse(readFileSync(remediationBaseBranchPath(artifactsDir), "utf8"));
-        return typeof parsed?.base_branch === "string" && parsed.base_branch.length > 0
-            ? parsed.base_branch
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function ensureRemediationBranchCheckedOut(root, runId, artifactsDir) {
-    const top = gitTopLevel(root);
-    if (top === null || canonicalPathKey(top) !== canonicalPathKey(root))
-        return null;
-    const branch = remediationBranchName(runId);
-    const current = spawnSyncHidden("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-        cwd: root,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (current.status === 0 && (current.stdout ?? "").trim() === branch)
-        return branch;
-    const branchExisted = gitBranchExists(root, branch);
-    const args = branchExisted ? ["checkout", branch] : ["checkout", "-b", branch];
-    const co = spawnSyncHidden("git", args, { cwd: root, encoding: "utf8", shell: false });
-    if (co.status !== 0) {
-        process.stderr.write(`[remediate-code] could not switch to remediation branch ${branch}: ${(co.stderr ?? "").trim()}\n`);
-        return null;
-    }
-    // First creation: record the branch we came from as the merge-back target (B5).
-    // Only a real branch name — a detached HEAD reports "HEAD" and is skipped.
-    if (!branchExisted && artifactsDir) {
-        const base = current.status === 0 ? (current.stdout ?? "").trim() : "";
-        if (base && base !== "HEAD" && base !== branch) {
-            try {
-                writeFileSync(remediationBaseBranchPath(artifactsDir), JSON.stringify({ base_branch: base }, null, 2));
-            }
-            catch {
-                // best-effort: an unrecorded base degrades to manual merge, never throws
-            }
-        }
-    }
-    process.stderr.write(`[remediate-code] remediation changes land on branch ${branch} (base branch left untouched)\n`);
-    return branch;
-}
-/**
- * Stage and commit all of a worktree's edits onto its branch. The TOOL owns this
- * commit (never the worker/host) so that the branch has a real commit for two
- * downstream invariants: `gitEditedFilesForBranch` (the write-scope ground truth,
- * `HEAD...<branch>`) and `mergeWorktree`'s cherry-pick both operate on the worker's
- * changes rather than an empty diff against HEAD. Gitignored paths (node_modules,
- * .audit-tools artifacts, the result file written to the main artifacts dir) are
- * excluded by `git add -A` honoring .gitignore, so the commit captures exactly the
- * source edits. Returns `committed:false` (not an error) when the worker made no
- * tracked edits — there is then nothing to verify or merge.
- */
-/**
- * Source-file extensions a worker is allowed to CREATE as a brand-new untracked
- * file that `.gitignore` happens to shadow. A new source file (a .ts the build
- * compiles, a .js shim, a source .json fixture/config) is real work that MUST land
- * even though `git add -A` honours `.gitignore` and would silently drop it
- * (CE-003/CE-004 — the dogfood lost a gitignored friction-dir file exactly this
- * way). A new
- * file with any OTHER suffix under write scope is a GENERATED artifact (`.tsbuildinfo`,
- * an emitted `.d.ts`, a coverage dump, …) — committing it would land a stale build
- * output, so those FAIL LOUDLY rather than commit a half-change.
- */
-const SOURCE_NEW_FILE_EXTENSIONS = new Set([
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".json",
-]);
-/**
- * A new untracked-ignored file is a SOURCE file (force-add it) iff its extension
- * is in {@link SOURCE_NEW_FILE_EXTENSIONS} AND it is not a generated declaration
- * (`.d.ts` / `.d.mts` / `.d.cts`) — a generated `.d.ts` has a `.ts` suffix but is
- * build output, so it must be excluded from the source set.
- */
-function isSourceNewFile(rel) {
-    const lower = rel.toLowerCase();
-    if (/\.d\.[cm]?ts$/.test(lower))
-        return false;
-    const dot = lower.lastIndexOf(".");
-    if (dot < 0)
-        return false;
-    return SOURCE_NEW_FILE_EXTENSIONS.has(lower.slice(dot));
-}
-/**
- * Whether a repo-relative path falls UNDER one of the block's declared write
- * paths. A declared path matches a new file when it is the file itself, a
- * directory prefix of it (declared `src/x` matches `src/x/new.ts`), or a glob
- * whose pre-wildcard directory prefix contains it (a leading-wildcard glob like
- * a friction-dir pattern matches `src/a/friction/new.ts`). Declared paths and the
- * candidate are normalized to
- * repo-relative forward-slash form so the comparison is OS-agnostic.
- */
-function isUnderWritePaths(rel, declaredWritePaths, root) {
-    const target = toRepoRelative(rel, root);
-    for (const raw of declaredWritePaths) {
-        const declared = toRepoRelative(raw, root);
-        if (declared === target)
-            return true;
-        // Glob: reduce a wildcard pattern to the leading literal dir segment(s)
-        // before the first wildcard and treat that as a containing prefix.
-        const wildcard = declared.search(/[*?[]/);
-        const literalPrefix = (wildcard >= 0 ? declared.slice(0, wildcard) : declared)
-            .replace(/\/+$/, "");
-        if (literalPrefix.length === 0) {
-            // A leading-wildcard glob (a friction-dir style pattern) — match on the
-            // trailing literal segment appearing anywhere in the candidate's path.
-            const trailing = declared.replace(/^[*?/]+/, "").replace(/\/+$/, "");
-            if (trailing.length > 0 && (target === trailing || target.includes(`/${trailing}/`) || target.includes(`${trailing}/`))) {
-                return true;
-            }
-            continue;
-        }
-        if (target === literalPrefix || target.startsWith(`${literalPrefix}/`))
-            return true;
-    }
-    return false;
-}
-/**
- * Force-add worker-created NEW files that `.gitignore` shadows so genuine new
- * source work lands in the commit. `git add -A` (and any diff) honour `.gitignore`
- * and can ONLY be enumerated via `git ls-files --others --ignored
- * --exclude-standard`. Only files UNDER the block's declared write scope are
- * considered: a source-extension one is `git add -f`'d so it lands; a non-source
- * one (generated artifact under a source dir) FAILS LOUDLY rather than committing
- * build output. An untracked-ignored file OUTSIDE the write scope is incidental
- * churn (node_modules created by running npm in the worktree, dist/, .audit-tools/,
- * another module's output) — `git add -A` already skips it, so it is skipped here
- * too (it must NOT trip a fail-loud; doing so falsely rejected every node whose
- * worker ran npm in its worktree). `declaredWritePaths` undefined → the lifecycle
- * unit-test path with no scope: skip force-add entirely (legacy behaviour).
- */
-function forceAddNewSourceFiles(worktreeRoot, declaredWritePaths) {
-    if (declaredWritePaths === undefined)
-        return { ok: true };
-    const ls = spawnSyncHidden("git", ["ls-files", "--others", "--ignored", "--exclude-standard"], { cwd: worktreeRoot, encoding: "utf8", shell: false });
-    if (ls.error || ls.status !== 0) {
-        return {
-            ok: false,
-            error: `git ls-files (untracked-ignored enumeration) failed: ${(ls.stderr ?? ls.error?.message ?? "").toString().trim()}`,
-        };
-    }
-    const newFiles = (ls.stdout ?? "")
-        .split(/\r?\n/)
-        .map((l) => l.trim().replace(/\\/g, "/"))
-        .filter((l) => l.length > 0);
-    const toForceAdd = [];
-    for (const rel of newFiles) {
-        // Only files UNDER the node's declared write scope are candidates. An
-        // untracked-ignored file OUTSIDE the write scope is incidental churn the
-        // worker did not author as part of this change — node_modules (e.g.
-        // `node_modules/.bin/esbuild` created by running npm/vitest in the worktree),
-        // `dist/`, `.audit-tools/`, or another module's output. `git add -A` already
-        // skips all of it; it must NOT trip a fail-loud (doing so falsely rejected
-        // every node whose worker ran npm in its worktree). Skip it.
-        if (!isUnderWritePaths(rel, declaredWritePaths, worktreeRoot))
-            continue;
-        if (isSourceNewFile(rel)) {
-            toForceAdd.push(rel);
-            continue;
-        }
-        // Under the declared write scope but NOT a source extension: a generated
-        // artifact (e.g. a `.tsbuildinfo` / generated `.d.ts`) a worker dropped under
-        // a source dir. This is the genuine CE-003 case — fail loudly rather than
-        // committing build output.
-        return {
-            ok: false,
-            error: `Worker created a new non-source (generated) file under its write scope: ${rel}. ` +
-                `Only source-extension new files are committed; a generated artifact must not land. ` +
-                `Refusing to commit a half-change.`,
-        };
-    }
-    for (const rel of toForceAdd) {
-        const add = spawnSyncHidden("git", ["add", "-f", "--", rel], {
-            cwd: worktreeRoot,
-            encoding: "utf8",
-            shell: false,
-        });
-        if (add.status !== 0) {
-            return { ok: false, error: `git add -f ${rel} failed: ${(add.stderr ?? "").trim()}` };
-        }
-    }
-    return { ok: true };
-}
-export function commitWorktree(worktreeRoot, message, declaredWritePaths) {
-    // Force-add worker-created new SOURCE files that `.gitignore` shadows (and fail
-    // loudly on a generated-artifact / out-of-scope new file) BEFORE `git add -A`,
-    // which on its own silently drops every untracked-ignored path (CE-003/CE-004).
-    const forced = forceAddNewSourceFiles(worktreeRoot, declaredWritePaths);
-    if (!forced.ok) {
-        return { committed: false, error: forced.error };
-    }
-    const add = spawnSyncHidden("git", ["add", "-A"], {
-        cwd: worktreeRoot,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (add.status !== 0) {
-        return { committed: false, error: `git add failed: ${(add.stderr ?? "").trim()}` };
-    }
-    // `git diff --cached --quiet` exits 0 when nothing is staged → no worker edits.
-    const staged = spawnSyncHidden("git", ["diff", "--cached", "--quiet"], {
-        cwd: worktreeRoot,
-        shell: false,
-    });
-    if (staged.status === 0) {
-        return { committed: false };
-    }
-    const commit = spawnSyncHidden("git", ["commit", "-m", message], {
-        cwd: worktreeRoot,
-        encoding: "utf8",
-        shell: false,
-    });
-    if (commit.status !== 0) {
-        return { committed: false, error: `git commit failed: ${(commit.stderr ?? "").trim()}` };
-    }
-    return { committed: true };
-}
-/**
- * Make the main checkout's installed `node_modules` available to a worktree. A
- * fresh `git worktree add` checks out only tracked files, and `node_modules` is
- * gitignored, so per-node verify commands (`npm run check`, focused tests) would
- * otherwise fail with missing dependencies. Best-effort junction/symlink to the
- * main root's `node_modules`; on failure it logs and the verify step surfaces the
- * missing-deps error rather than crashing the dispatch. NOTE: workspace package
- * symlinks inside `node_modules/@audit-tools/*` point back into the MAIN checkout,
- * so cross-package runtime resolution sees the main tree — the authoritative
- * cross-package re-check is the central post-merge build/gate, not this fast
- * per-node verify (which gates obvious breakage early).
- */
-export function ensureWorktreeNodeModules(mainRoot, worktreeRoot) {
-    const target = join(mainRoot, "node_modules");
-    const link = join(worktreeRoot, "node_modules");
-    if (!existsSync(target) || existsSync(link))
-        return;
-    try {
-        symlinkSync(target, link, "junction");
-    }
-    catch (err) {
-        process.stderr.write(`[remediate-code] worktree node_modules link failed (${worktreeRoot}): ${String(err)}\n`);
-    }
-}
-/**
- * The shared post-worker "accept node" lifecycle, extracted so BOTH rolling
- * drivers reuse identical correctness: the in-process provider engine
- * (`driveRollingImplementDispatch`) calls it inline once the worker returns; the
- * host-subagent driver calls it from the `accept-node` callback once a host
- * subagent finishes.
- *
- * Given a completed worker run in an isolated worktree, this: (1) TOOL-commits
- * the worker's edits onto the branch (deterministic, never the worker/host) so
- * the branch diff is the write-scope ground truth; (2) runs the per-node verify
- * IN the worktree BEFORE accepting; (3) merges via cherry-pick only on a passing
- * verify; and (4) drops the worktree on any failure so the main tree is never
- * dirtied by an unverified change. It returns the LIFECYCLE outcome (which the
- * caller records for the deterministic merge); the caller still returns the
- * worker's TRANSPORT outcome to the rolling engine (so a `rate_limited` worker
- * re-queues, while a verify-failure is adjudicated by the merge → triage).
- *
- * SAFETY: the main tree is touched only through `mergeWorktree` (cherry-pick of a
- * verified branch, aborts cleanly on conflict). No state mutation here — the
- * caller persists via `mergeImplementResults`.
- */
-export async function acceptNodeWorktree(params) {
-    const { root, runId, blockId, worktreeRoot: wt, branch, workerOutcome, targetedCommands, additionalVerifyCommands } = params;
-    let verifyPassed = false;
-    let merged = false;
-    if (workerOutcome === "rate_limited") {
-        // Piece D — quota-death worktree preservation: a worker that died on a host
-        // session-limit is a RETRYABLE pause, not a failure. Leave its worktree INTACT
-        // (do NOT removeWorktree) so nothing is destroyed during the pause; the node
-        // redoes clean on resume (the re-entry `resetNodeWorktreeAndBranch` handles the
-        // clean redo). Nothing to land now — return the outcome so the rolling engine
-        // records the pause + strands the node pending.
-        return { outcome: workerOutcome, verifyPassed, merged };
-    }
-    if (workerOutcome !== "success") {
-        // Real worker failure (error / timeout): nothing to land; drop the worktree so
-        // the main tree is never dirtied by an unverified change, preserve the outcome.
-        removeWorktree(root, wt);
-        return { outcome: workerOutcome, verifyPassed, merged };
-    }
-    const commit = commitWorktree(wt, `remediate ${blockId} (${runId})`, params.writePaths);
-    if (commit.error) {
-        // Could not commit the worker's edits (e.g. a generated-artifact-under-scope
-        // fail-loud) → cannot safely LAND it, but the worker's real source edits are
-        // still uncommitted in the worktree. Preserve them under a durable quarantine
-        // ref BEFORE removing the worktree (P0 data-loss: a guard must not destroy the
-        // good work alongside the offending artifact), mirroring the verify/scope/
-        // merge-fail quarantine paths below.
-        quarantineUncommittedWorktreeEdits(root, wt, branch, runId, blockId);
-        removeWorktree(root, wt);
-        return { outcome: "error", verifyPassed, merged, diagnostic: commit.error };
-    }
-    if (!commit.committed) {
-        // Worker reported success but made no tracked edits — nothing to verify or merge.
-        // The deterministic merge adjudicates the result file (resolved_no_change needs evidence).
-        removeWorktree(root, wt);
-        return { outcome: "success", verifyPassed, merged };
-    }
-    // Base-mutating critical section (INV-2/INV-3/CE-001/CE-002/CE-005) under a DISTINCT
-    // base-branch lock — NOT the per-run rolling-session.lock `advanceHostRolling` holds
-    // (withFileLock is non-reentrant, so a same-path nested acquire would self-deadlock).
-    // Acquired exactly ONCE here so BOTH rolling drivers serialize the rebase →
-    // cherry-pick → cross-package check → reset sequence through one lock. The base HEAD
-    // OID is captured before the cherry-pick so a RED merged-base check rolls the base
-    // back bit-identically. The lock is released on EVERY exit path (success, verify
-    // fail, scope fail, check fail, subprocess fail) by withFileLock's finally.
-    return withFileLock(baseBranchLockPath(root, runId), async () => {
-        // Rebase the node's branch onto the current remediation HEAD BEFORE verify, so a
-        // sibling that merged after this worktree was created is folded in. Verify, the
-        // write-scope gate, and the cherry-pick then all operate on the FINAL to-be-merged
-        // content (green-at-merge; the later cherry-pick can no longer conflict). A true
-        // hunk conflict here is a genuine seam — preserve the work and route to triage
-        // rather than land a broken merge.
-        const rebase = rebaseBranchOntoHead(root, wt, branch);
-        if (!rebase.ok) {
-            quarantineFailedNodeCommit(root, branch, runId, blockId);
-            removeWorktree(root, wt);
-            return { outcome: "error", verifyPassed, merged, diagnostic: rebase.error };
-        }
-        // Pre-flight: a dirty tracked file in the MAIN checkout that collides with a
-        // path this node edits makes the later cherry-pick abort with an opaque
-        // "local changes would be overwritten by merge" — a condition the node cannot
-        // fix and that re-fails identically on every auto-retry. Detect it up front
-        // (before the expensive verify) and surface the actionable cause; preserve the
-        // committed work under quarantine like every sibling error path so nothing is
-        // lost while the host commits/stashes the unrelated WIP.
-        const collisions = dirtyMainTreeCollisions(root, branch);
-        if (collisions.length > 0) {
-            quarantineFailedNodeCommit(root, branch, runId, blockId);
-            removeWorktree(root, wt);
-            const paths = collisions.map((c) => `\`${c}\``).join(", ");
-            const it = collisions.length > 1 ? "them" : "it";
-            return {
-                outcome: "error",
-                verifyPassed,
-                merged,
-                diagnostic: `main tree has uncommitted changes to ${paths} — commit or stash ${it} ` +
-                    `before merging this node (the cherry-pick would otherwise abort with ` +
-                    `"local changes would be overwritten by merge"). This is unrelated to the ` +
-                    `node's own fix; the node's work is preserved under its quarantine ref.`,
-            };
-        }
-        // Verify commands: when the host omits them (real rolling drivers), DERIVE them
-        // from the just-committed branch's touched test files — correct paths/runner by
-        // construction, only this node's own tests, never the whole suite. An explicit
-        // list (or `[]` to skip) overrides; both used by lifecycle unit tests. task_7d35176d:
-        // run the derive AND the node's own build-free `targeted_commands` (deduped) — the
-        // auditor's fix-specific regression checks the derive misses when a fix touches no
-        // test. `additionalVerifyCommands` is ignored on the explicit-override path.
-        const baseCommands = targetedCommands === undefined
-            ? deriveVerifyCommandsFromBranch(root, branch)
-            : targetedCommands;
-        let verifyCommands;
-        if (targetedCommands === undefined) {
-            // Self-contained per-node verify (2026-07-03): the derived `baseCommands` come
-            // from this node's ACTUAL branch edits (self-contained by construction), but the
-            // node's host/auditor-authored `additionalVerifyCommands` can reference a sibling
-            // node's not-yet-created deliverable → a guaranteed-fail deadlock. Drop any such
-            // cross-node command (deferred to the integration/close gate). Own paths = the
-            // node's declared write set ∪ the files it actually edited on its branch.
-            const edited = gitEditedFilesForBranch(root, branch);
-            const ownPaths = [
-                ...(params.writePaths ?? []),
-                ...(edited.available ? edited.files : []),
-            ];
-            const additional = selfContainedVerifyCommands(buildFreeVerifyCommands(additionalVerifyCommands), ownPaths, wt);
-            verifyCommands = [...new Set([...baseCommands, ...additional])];
-        }
-        else {
-            verifyCommands = baseCommands;
-        }
-        const verify = verifyCommands.length > 0
-            ? verifyNodeInWorktree(wt, verifyCommands)
-            : { passed: true, output: "" };
-        verifyPassed = verify.passed;
-        if (!verify.passed) {
-            // Verify failed: do not merge; drop the worktree so the main tree stays clean.
-            // The node DID commit real edits, so preserve them under a durable quarantine
-            // ref before the worktree/branch go away — a tool-verify false-negative must
-            // not destroy a good fix (the dogfood lost one this way). Carry the failing
-            // command + output so triage isn't blind on outcome:error.
-            quarantineFailedNodeCommit(root, branch, runId, blockId);
-            removeWorktree(root, wt);
-            return { outcome: "error", verifyPassed, merged, diagnostic: verify.output };
-        }
-        // Write-scope gate (OBL-DS-06), BEFORE the cherry-pick: an out-of-scope or
-        // seam-conflicting edit must never land in the main tree, so it is adjudicated
-        // against the branch's git diff (the ground truth) here rather than reported
-        // after `mergeWorktree` already merged it. The gate routes the node's ACTUAL
-        // out-of-declared edits (git diff, never a self-report): an edit to a file no
-        // sibling block owns widens the effective scope, while one owned by another
-        // block blocks as a seam conflict.
-        const decision = enforceAcceptWriteScope({
-            root,
-            branch,
-            blockId,
-            allBlockScopes: params.scope.allBlockScopes,
-        });
-        if (decision.blocked) {
-            // Scope-blocked but the node committed real work — preserve it for recovery.
-            quarantineFailedNodeCommit(root, branch, runId, blockId);
-            removeWorktree(root, wt);
-            return { outcome: "error", verifyPassed, merged: false, diagnostic: decision.reason };
-        }
-        // Capture the base HEAD OID BEFORE the cherry-pick so a RED merged-base check can
-        // roll the base back to a bit-identical state.
-        const baseHeadBefore = spawnSyncHidden("git", ["rev-parse", "HEAD"], {
-            cwd: root,
-            encoding: "utf8",
-            shell: false,
-        });
-        if (baseHeadBefore.error || baseHeadBefore.status !== 0) {
-            quarantineFailedNodeCommit(root, branch, runId, blockId);
-            removeWorktree(root, wt);
-            return {
-                outcome: "error",
-                verifyPassed,
-                merged,
-                diagnostic: `could not capture base HEAD before merge: ${(baseHeadBefore.stderr ?? baseHeadBefore.error?.message ?? "").toString().trim()}`,
-            };
-        }
-        const baseOid = baseHeadBefore.stdout.trim();
-        // mergeWorktree cherry-picks the verified branch and removes the worktree (on
-        // success AND on conflict-abort), so no explicit cleanup is needed afterwards.
-        const mergeRes = mergeWorktree(root, wt, branch);
-        merged = mergeRes.success;
-        if (!mergeRes.success) {
-            // Cherry-pick conflict: the committed work would otherwise be orphaned — preserve it.
-            quarantineFailedNodeCommit(root, branch, runId, blockId);
-            return { outcome: "error", verifyPassed, merged, diagnostic: mergeRes.error };
-        }
-        // Merged-base-green (INV-2): the cherry-pick landed in the MAIN checkout, where
-        // node_modules is faithful (the worktree's @audit-tools junction resolves to main
-        // and is unfaithful, so the per-node worktree verify cannot catch a cross-package
-        // break). Run the REAL cross-package check in the main tree. On RED, roll the base
-        // back to its captured OID bit-identically, scoped-clean the cherry-pick's emitted
-        // untracked files, quarantine, and fail — never leave a broken base for the sibling.
-        const checkArgv = params.mergedBaseCheckCommand === undefined
-            ? mergedBaseCheckArgv(root)
-            : params.mergedBaseCheckCommand;
-        if (checkArgv !== null) {
-            // Paths the just-landed pick touched, so the scoped clean nukes only those
-            // (never unrelated untracked state). Resolved BEFORE the check runs.
-            const pickedFiles = gitEditedFilesForBranch(root, branch);
-            // argv via runCommand → runTracked scrubs CLAUDECODE / CLAUDE_CODE_* and applies
-            // the shared Windows `.cmd` wrapping — never `shell: true`.
-            const [checkCmd, ...checkArgs] = checkArgv;
-            const check = runCommand(checkCmd, checkArgs, { cwd: root, encoding: "utf8" });
-            const checkFailed = !!check.error || check.status !== 0;
-            if (checkFailed) {
-                const detail = check.error
-                    ? check.error.message
-                    : [check.stdout ?? "", check.stderr ?? ""].filter(Boolean).join("\n");
-                // Roll the base back to its pre-pick OID, bit-identical.
-                spawnSyncHidden("git", ["reset", "--hard", baseOid], { cwd: root, shell: false });
-                // Scoped clean: remove only the cherry-pick / check-emitted untracked files
-                // under the paths the pick touched — never a blanket `git clean` that could
-                // nuke unrelated untracked state.
-                if (pickedFiles.available && pickedFiles.files.size > 0) {
-                    spawnSyncHidden("git", ["clean", "-fdq", "--", ...[...pickedFiles.files]], { cwd: root, shell: false });
-                }
-                quarantineFailedNodeCommit(root, branch, runId, blockId);
-                return {
-                    outcome: "error",
-                    verifyPassed,
-                    merged: false,
-                    diagnostic: `$ ${checkArgv.join(" ")}\n${detail}`,
-                };
-            }
-        }
-        // Landed successfully and the merged base is green: clear any quarantine ref left
-        // by a prior failed attempt for this node so the recovery report lists only
-        // genuinely-unrecovered work.
-        clearQuarantinedCommit(root, runId, blockId);
-        return { outcome: "success", verifyPassed, merged };
-    });
-}
-/**
- * Sidecar path for a node's tool-owned accept (verify/merge) outcome. Written by
- * BOTH rolling drivers as each node is accepted, read by `mergeImplementResults`.
- * Block ids here follow the same filename-safe convention as the per-node result
- * files in the same dir.
- */
-export function nodeAcceptOutcomePath(artifactsDir, runId, blockId) {
-    return join(runDir(artifactsDir, runId, "implement"), `accept-outcome-${blockId}.json`);
-}
-/**
- * Persist a node's `acceptNodeWorktree` lifecycle outcome so finalization can tell
- * a node whose edits actually LANDED (merged) from one that self-reported "resolved"
- * but failed tool-owned verify / merge (OBL-DS-06: never trust the worker's self
- * report). Both rolling drivers (host-subagent `advanceHostRolling` and in-process
- * `driveRollingImplementDispatch`) call this; the interim main-tree path writes none,
- * so the merge-state gate is inert there.
- */
-export async function recordNodeAcceptOutcome(artifactsDir, runId, blockId, result) {
-    await writeJsonFile(nodeAcceptOutcomePath(artifactsDir, runId, blockId), {
-        schema_version: "remediate-code-implement/node-accept-outcome/v1alpha1",
-        block_id: blockId,
-        outcome: result.outcome,
-        verify_passed: result.verifyPassed,
-        merged: result.merged,
-        // Only present on a failure outcome; gives triage the failing command + output.
-        ...(result.diagnostic !== undefined ? { diagnostic: result.diagnostic } : {}),
-    });
-}
-/** Load a node's recorded accept outcome, or null when none was written. */
-export async function loadNodeAcceptOutcome(artifactsDir, runId, blockId) {
-    const raw = await readOptionalJsonFile(nodeAcceptOutcomePath(artifactsDir, runId, blockId));
-    if (!raw)
-        return null;
-    return {
-        outcome: raw.outcome,
-        verifyPassed: raw.verify_passed,
-        merged: raw.merged,
-        ...(raw.diagnostic !== undefined ? { diagnostic: raw.diagnostic } : {}),
-    };
-}
-/**
- * Run ONE node's full in-process lifecycle in an isolated worktree — shared by BOTH
- * in-process callers (the reactive `driveRollingImplementDispatch` engine and the
- * A-8 hybrid executor) so they create / commit / verify / merge identically:
- *
- *   reset + create the node's worktree → link node_modules → seed declared targets →
- *   launch the worker (`dispatchNode`) → `acceptNodeWorktree` (tool-commit, rebase,
- *   verify, write-scope gate, cherry-pick) → persist the accept outcome.
- *
- * Claim ownership is the CALLER's concern (the reactive engine claims through the
- * shared registry; the hybrid executor is handed a coordinator-minted claim), so
- * this fn neither claims nor releases — it returns the worker transport result AND
- * the accept lifecycle outcome and lets the caller record `nodeOutcomes` / release.
- * Any thrown error degrades to a dropped worktree + a persisted `error` accept
- * outcome, never an unhandled rejection into the engine.
- */
-export async function executeNodeInWorktree(args) {
-    const { block, slot, root, artifactsDir, runId, resultPath, seedPaths, allBlockScopes, additionalVerifyCommands, dispatchNode } = args;
-    const branch = worktreeBranchForBlock(block.block_id, runId);
-    const wt = worktreePath(root, block.block_id, runId);
-    try {
-        // Idempotent reset of any worktree dir AND leftover branch from a prior attempt
-        // (a `rate_limited` re-queue re-enters for the same block with its branch still
-        // present), then create this node's isolated worktree (createWorktree also links
-        // the main checkout's node_modules so verify can resolve deps), and seed
-        // untracked declared targets a committed-files-only worktree can't see.
-        resetNodeWorktreeAndBranch(root, wt, branch);
-        createWorktree(root, wt, branch);
-        seedUntrackedDeclaredPaths(root, wt, seedPaths);
-        const result = await dispatchNode({ block, slot, worktreeRoot: wt, resultPath });
-        // Shared post-worker lifecycle. Verify commands are DERIVED from the node's
-        // actually-touched tests inside acceptNodeWorktree (post-commit) — omit them so a
-        // host-authored path can't mis-verify. The write-scope gate adjudicates the node's
-        // ACTUAL git edits against every block's declared scope.
-        const accept = await acceptNodeWorktree({
-            root,
-            runId,
-            blockId: block.block_id,
-            worktreeRoot: wt,
-            branch,
-            workerOutcome: result.outcome,
-            additionalVerifyCommands,
-            scope: { allBlockScopes },
-            // The block's OWN declared write paths (INV-1 new-file inclusion).
-            writePaths: allBlockScopes.find((b) => b.block_id === block.block_id)?.write_paths ?? [],
-        });
-        await recordNodeAcceptOutcome(artifactsDir, runId, block.block_id, accept);
-        return { result, accept };
-    }
-    catch (err) {
-        removeWorktree(root, wt);
-        const accept = { outcome: "error", verifyPassed: false, merged: false };
-        await recordNodeAcceptOutcome(artifactsDir, runId, block.block_id, accept);
-        return {
-            result: {
-                packet: { id: block.block_id, payload: { block_id: block.block_id }, estimatedTokens: 0, complexity: 0.5 },
-                outcome: "error",
-                error: err,
-            },
-            accept,
-        };
-    }
-}
-/** Read the promoted DAG-node overlay fields off a Finding (all optional). */
-function nodeFieldsOf(finding) {
-    return finding;
-}
-/**
- * The reconciliation expectations a node must honor (INV-DS-12): the explicit
- * `reconciliation_expectations` when present, else the node's `preconditions`
- * (upstream contracts' declared outputs). Returned as a deduped string list so
- * the renderer can thread them and the disposition can record them.
- */
-function reconciliationExpectationsOf(finding) {
-    const node = nodeFieldsOf(finding);
-    const explicit = Array.isArray(node.reconciliation_expectations)
-        ? node.reconciliation_expectations
-        : [];
-    const preconditions = Array.isArray(node.preconditions) ? node.preconditions : [];
-    return [...new Set([...explicit, ...preconditions])].filter((s) => typeof s === "string" && s.trim().length > 0);
-}
-// ---------------------------------------------------------------------------
-// Build-free per-node verification commands (residual CE-001)
-// ---------------------------------------------------------------------------
-/**
- * The host manages the build centrally; a per-node verify command that runs
- * `npm run build` (or a `npm test` whose package script prepends a build) races
- * the central build's dist/ and is therefore forbidden. A command is build-free
- * only when it neither builds nor invokes a build-prepending test script.
- *
- * Forbidden (return false):
- *  - `npm run build` / `npm run build -w ...` / `tsc` emit (`tsc -b`, `tsc --build`)
- *  - bare `npm test` / `npm t` / `npm run test` (the package script prepends build)
- *
- * Allowed (return true):
- *  - `npm run check` (no emit)
- *  - `npx vitest run <path>` / `vitest run <path>`
- *  - `node --test <path>`
- */
-export function isBuildFreeVerifyCommand(cmd) {
-    const c = cmd.trim().toLowerCase().replace(/\s+/g, " ");
-    if (c.length === 0)
-        return false;
-    // Any explicit build step is forbidden.
-    if (/\bnpm\s+run\s+build\b/.test(c))
-        return false;
-    if (/\btsc\b.*(-b\b|--build\b)/.test(c))
-        return false;
-    if (/(^|\s)tsc(\s|$)/.test(c) && !/--noemit\b/.test(c)) {
-        // A bare `tsc` (or `tsc -p ...`) emits unless --noEmit is set.
-        return false;
-    }
-    // A build-prepending `npm test` / `npm t` / `npm run test` is forbidden; the
-    // build-free runner (vitest run / node --test) must be invoked directly.
-    if (/\bnpm\s+(test|t)\b/.test(c))
-        return false;
-    if (/\bnpm\s+run\s+test\b/.test(c))
-        return false;
-    return true;
-}
-/**
- * Inject the tsx ESM loader into a bare `node --test <file>` command so the `.mjs`
- * node:test suites (which import `audit-tools/shared` via tsconfig `paths`, honored
- * only by tsx) resolve in a per-node worktree with no built `dist/`. A host- or
- * DAG-authored `node --test tests/audit/x.test.mjs` would otherwise fail module
- * resolution; the tool normalizes it so correctness can't depend on the host
- * remembering to add the loader. Idempotent: a command already carrying
- * `--import tsx/esm` or a `--loader` is left untouched. Mirrors the runner the
- * derived verify uses ({@link verifyCommandsForEdits}), so the displayed per-node
- * command and the in-process verify match.
- */
-export function normalizeNodeTestCommand(cmd) {
-    const trimmed = cmd.trim();
-    if (!/^node\b/.test(trimmed))
-        return cmd;
-    if (!/\s--test\b/.test(trimmed))
-        return cmd;
-    if (/--import\s+tsx\/esm\b/.test(trimmed) || /--loader\b/.test(trimmed))
-        return cmd;
-    return trimmed.replace(/^node\b/, "node --import tsx/esm");
-}
-/**
- * True when `cmd` is a test-runner invocation whose target is a whole directory
- * or the entire suite rather than specific test files — e.g. `npx vitest run
- * tests/remediate`, `vitest run` (no path), `node --test tests/audit/`. Such a
- * command, run as an *additional* per-node verify alongside the scoped derive,
- * re-enters the FULL suite inside a per-node worktree. That is the structural
- * deadlock proven 2026-06-30: a source node's whole-suite verify fails on a
- * stale test owned by a DIFFERENT node, and concurrent worktrees race shared
- * test temp dirs. The derived verify already runs this node's OWN touched
- * tests, so a host/DAG-authored whole-suite command adds only risk — the tool
- * drops it rather than relying on the author to scope it (enforce-in-tooling,
- * never host discretion). A command naming at least one concrete `.test.<ext>`
- * file is scoped and kept.
- */
-export function isWholeSuiteTestCommand(cmd) {
-    const c = cmd.trim();
-    const isVitest = /\bvitest\b\s+run\b/.test(c) || /\bvitest\b(?!\s+run)/.test(c);
-    const isNodeTest = /^node\b/.test(c) && /\s--test\b/.test(c);
-    if (!isVitest && !isNodeTest)
-        return false;
-    // Tokenise; a concrete test file makes it scoped. Anything that is a runner
-    // with no concrete test-file target (bare runner, or a directory/glob target)
-    // is whole-suite.
-    const namesConcreteTestFile = /(^|\s)[^\s]*\.test\.(ts|tsx|mjs|cjs|js)(\s|$)/.test(c);
-    return !namesConcreteTestFile;
-}
-/**
- * Filter a node's `targeted_commands` to the build-free subset for the per-node
- * verify section. Build-prepending or build commands are dropped (the host runs
- * the build centrally) rather than emitted into the prompt. Whole-suite /
- * whole-directory test runs are dropped too — they re-enter the full suite in a
- * per-node worktree and re-create the cross-node verify deadlock (the scoped
- * derive already covers this node's own tests). Surviving `node --test`
- * commands are normalized to carry the tsx loader.
- */
-function buildFreeVerifyCommands(commands) {
-    if (!Array.isArray(commands))
-        return [];
-    return commands
-        .filter((c) => typeof c === "string" &&
-        isBuildFreeVerifyCommand(c) &&
-        !isWholeSuiteTestCommand(c))
-        .map(normalizeNodeTestCommand);
-}
-/**
- * Repo-relative path-like tokens in a shell command — tokens containing a `/` and a
- * file extension (e.g. `scripts/remediate/verify-hosts.mjs`, `tests/x.test.ts`).
- * Used to decide whether a targeted verify command is self-contained.
- */
-export function pathTokensInCommand(cmd) {
-    const tokens = cmd.match(/(?:[\w.@-]+\/)+[\w.@-]+\.\w+/g) ?? [];
-    return [...new Set(tokens.map((t) => t.replace(/\\/g, "/")))];
-}
-/**
- * Keep only the targeted verify commands that are SELF-CONTAINED for this node:
- * every path-like token they reference is either one of the node's own paths (its
- * declared write set ∪ the files it actually edited on its branch) or already
- * present in the tree. A command referencing a path this node doesn't own and that
- * isn't in the tree depends on a SIBLING node's not-yet-created deliverable —
- * running it in per-node verify is a guaranteed-fail deadlock (proven 2026-07-03: a
- * node's `targeted_command` was `node scripts/remediate/verify-hosts.mjs`, another
- * node's pending output). Per-node verify must be self-contained; such a cross-node
- * command is dropped here and deferred to the integration/close gate. A command with
- * no path tokens (e.g. `npm run check`) is always kept.
- */
-export function selfContainedVerifyCommands(commands, ownPaths, treeRoot) {
-    const owned = new Set([...ownPaths].map((p) => p.replace(/\\/g, "/")));
-    return commands.filter((cmd) => {
-        for (const token of pathTokensInCommand(cmd)) {
-            if (owned.has(token))
-                continue;
-            if (existsSync(join(treeRoot, token)))
-                continue;
-            return false;
-        }
-        return true;
-    });
-}
-/** A repo-relative test path → the runner that executes that file directly. */
-function verifyRunnerForTestFile(repoRelPath) {
-    // ONE vitest runner across all suites (audit / shared / remediate). The node:test
-    // split was retired 2026-07-02, so every tracked `.test.mjs` / `.test.ts` file is a
-    // vitest file — running a `.mjs` vitest suite under `node --test` throws "Vitest
-    // failed to access its internal state". vitest resolves `audit-tools/shared` via its
-    // config alias, so a per-node worktree needs no prior build (`npx vitest run <file>`).
-    if (/^tests\/.+\.test\.(mjs|ts|tsx)$/.test(repoRelPath))
-        return "vitest";
-    return undefined;
-}
-/**
- * Derive a node's per-node verify commands from the test files it ACTUALLY touched
- * on its worktree branch (the git ground truth), instead of trusting host-authored
- * `targeted_commands` whose paths/runner can drift from where the worker put the
- * test. Always typechecks (`npm run check`, no emit), then runs ONLY this node's
- * own touched test files with the repo's runners — never the whole suite (which
- * would re-enter worktree-spawning tests inside a nested worktree). Build-free: the
- * host owns the central build; a node's own test imports the source it changed via
- * the tsx loader. Returns `[]` when there is no git ground truth so the caller can
- * skip the gate rather than fabricate a command.
- */
-/** Pure assembly (git-free) of the verify commands for a set of edited paths —
- *  the testable core of {@link deriveVerifyCommandsFromBranch}. */
-export function verifyCommandsForEdits(editedFiles) {
-    const vitestTests = [];
-    for (const f of editedFiles) {
-        const rel = f.replace(/\\/g, "/");
-        if (verifyRunnerForTestFile(rel) === "vitest")
-            vitestTests.push(rel);
-    }
-    const cmds = ["npm run check"];
-    if (vitestTests.length > 0) {
-        cmds.push(`npx vitest run ${vitestTests.sort().join(" ")}`);
-    }
-    return cmds;
-}
-export function deriveVerifyCommandsFromBranch(root, branch) {
-    const edited = gitEditedFilesForBranch(root, branch);
-    if (!edited.available)
-        return [];
-    return verifyCommandsForEdits(edited.files);
-}
-/**
- * A node's own `targeted_commands` for the per-node verify (task_7d35176d) — the union
- * of the block's `targeted_commands` and its findings' `targeted_commands` (the
- * auditor-specified, fix-specific verification). `acceptNodeWorktree` runs these IN
- * ADDITION to the derived touched-test commands (build-free subset, deduped), so a
- * fix-specific regression check is honoured even when the fix touches no test file.
- */
-export function targetedCommandsForBlock(state, blockId) {
-    const block = state.plan?.blocks?.find((b) => b.block_id === blockId);
-    if (!block)
-        return [];
-    const out = [...(block.targeted_commands ?? [])];
-    for (const fid of block.items) {
-        const finding = state.plan?.findings?.find((f) => f.id === fid);
-        for (const c of finding?.targeted_commands ?? [])
-            out.push(c);
-    }
-    return [...new Set(out)];
-}
-function markStarted(item) {
-    item.started_at ??= new Date().toISOString();
-    delete item.completed_at;
-}
-function markTerminal(item) {
-    const now = new Date().toISOString();
-    item.started_at ??= now;
-    item.completed_at = now;
-}
-/**
- * Load a worker's already-written implement result, distinguishing an ABSENT
- * file (the worker hasn't run yet → re-dispatch from scratch) from a PRESENT but
- * INVALID one (the worker ran but emitted malformed/unparseable JSON or a result
- * that fails the contract). A bare `catch → undefined` conflated the two: a
- * written-but-invalid file looked identical to "never produced", so the merge
- * loop silently `continue`d past the block (the missing-file branch never fires
- * because the file DOES exist) and the node could neither converge nor surface
- * the corruption. We now archive the invalid file (so a clean re-dispatch can
- * write a fresh one) and report it loudly, returning `undefined` only for the
- * genuinely-absent case.
- */
-async function tryLoadExistingImplementResult(resultPath) {
-    if (!existsSync(resultPath))
-        return undefined;
-    try {
-        const result = await readJsonFile(resultPath);
-        assertImplementWorkerResult(result, resultPath);
-        return result;
-    }
-    catch (err) {
-        // Present but invalid: do NOT treat it as absent (which would let the block
-        // be silently dropped from the merge). Archive the corrupt file and surface
-        // the reason so a clean re-dispatch produces a valid result.
-        process.stderr.write(`[remediate-code] dispatch: existing implement result ${resultPath} is present but ` +
-            `invalid (${err instanceof Error ? err.message : String(err)}); archiving and re-dispatching\n`);
-        await archiveIncompleteImplementResult(resultPath);
-        return undefined;
-    }
-}
-function pendingOrDocumentedFindingIdsForBlock(block, state) {
-    return block.items.filter((findingId) => {
-        const item = state.items?.[findingId];
-        return item?.status === "pending" && !isTerminalStatus(item.status);
-    });
-}
-/**
- * Bound on incomplete-coverage re-dispatch (E2): after this many merges observe a
- * worker silently omitting an assigned finding from its `item_results`, the finding
- * is blocked (→ triage) so the run converges instead of re-dispatching the same
- * worker indefinitely. Mirrors the other small convergence caps (DAG/cyclic-seam = 2).
- */
-const MAX_INCOMPLETE_COVERAGE_ATTEMPTS = 2;
-/**
- * Resolve the set of finding ids a worker result actually covers, alias-aware:
- * a worker may legitimately report a finding by its block id or an obligation
- * alias (the exact resolution `collapseItemResults` applies). Coverage/completeness
- * decisions MUST use this — a raw `finding_id` set would treat an alias-using-but-
- * complete result as incomplete and re-dispatch it forever.
- */
-function resolveCoveredFindingIds(result, block, state) {
-    const knownFindingIds = new Set(Object.keys(state.items ?? {}));
-    const aliasMap = buildBlockAliasMap(block, state);
-    const covered = new Set();
-    for (const entry of result.item_results) {
-        let targetId = entry.finding_id;
-        if (!knownFindingIds.has(targetId)) {
-            const nodeId = fromBlockId(targetId);
-            if (nodeId && knownFindingIds.has(nodeId)) {
-                targetId = nodeId;
-            }
-            else {
-                const remapped = aliasMap.get(targetId);
-                if (!remapped)
-                    continue;
-                targetId = remapped;
-            }
-        }
-        covered.add(targetId);
-    }
-    return covered;
-}
-function implementResultCoversFindings(result, findingIds, block, state) {
-    const covered = resolveCoveredFindingIds(result, block, state);
-    return findingIds.every((findingId) => covered.has(findingId));
-}
-async function archiveIncompleteImplementResult(resultPath) {
-    if (!existsSync(resultPath))
-        return;
-    const archivedPath = `${resultPath}.stale-${Date.now()}`;
-    await withFsRetry(() => rename(resultPath, archivedPath));
-}
-function runDir(artifactsDir, runId, phase) {
-    return join(artifactsDir, "runs", runId, phase);
-}
-function dispatchPlanPath(artifactsDir, runId, phase) {
-    return join(runDir(artifactsDir, runId, phase), "dispatch-plan.json");
-}
-const TEST_FILE_RE = /\.(test|spec)\.[cm]?[jt]sx?$/;
-const WALK_SKIP_DIRS = new Set([
-    "node_modules", ".git", "dist", "build", "coverage", "out",
-    ".next", ".turbo", ".audit-tools",
-]);
-/** Bounded recursive scan for test files under `root` (skips vendor/build dirs). */
-function walkTestFiles(root, max = 400) {
-    const out = [];
-    const stack = [root];
-    let visited = 0;
-    while (stack.length > 0 && out.length < max) {
-        const dir = stack.pop();
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (++visited > 20000)
-                return out;
-            if (entry.isDirectory()) {
-                if (WALK_SKIP_DIRS.has(entry.name) || entry.name.startsWith(".test-"))
-                    continue;
-                stack.push(join(dir, entry.name));
-            }
-            else if (TEST_FILE_RE.test(entry.name)) {
-                out.push(join(dir, entry.name));
-                if (out.length >= max)
-                    break;
-            }
-        }
-    }
-    return out;
-}
-/**
- * Walk the repo ONCE and read every test file's content (bounded). Built once per
- * dispatch and shared across all blocks so the filesystem walk + reads are not
- * repeated per block.
- */
-export function buildTestFileIndex(root) {
-    const index = [];
-    for (const testPath of walkTestFiles(root)) {
-        let content;
-        try {
-            content = readFileSync(testPath, "utf8");
-        }
-        catch {
-            continue;
-        }
-        index.push({ rel: relative(root, testPath).replace(/\\/g, "/"), content });
-    }
-    return index;
-}
-/**
- * Collect test files from `index` that reference any of `sourceFiles` by
- * module basename. When `packageRoot` is supplied (repo-relative prefix, e.g.
- * `packages/foo`), only test files under that package are considered —
- * otherwise all test files in the index are matched (existing behavior).
- */
-export function collectReferencingTests(index, sourceFiles, packageRoot) {
-    if (sourceFiles.length === 0 || index.length === 0)
-        return [];
-    const basenames = sourceFiles
-        .map((f) => (f.split(/[/\\]/).pop() ?? f).replace(/\.[cm]?[jt]sx?$/, ""))
-        .filter((b) => b.length > 1);
-    if (basenames.length === 0)
-        return [];
-    const needles = basenames.map((b) => new RegExp(`\\b${b.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`));
-    const sourceSet = new Set(sourceFiles.map((f) => f.replace(/\\/g, "/")));
-    // Normalize packageRoot to forward slashes and ensure it ends without trailing slash
-    const pkgPrefix = packageRoot
-        ? packageRoot.replace(/\\/g, "/").replace(/\/$/, "") + "/"
-        : null;
-    const result = [];
-    for (const { rel, content } of index) {
-        if (sourceSet.has(rel))
-            continue;
-        // If a package scope is set, skip files outside that package
-        if (pkgPrefix && !rel.startsWith(pkgPrefix))
-            continue;
-        if (needles.some((re) => re.test(content)))
-            result.push(rel);
-    }
-    return result;
-}
-function uniquePaths(paths) {
-    return [...new Set(paths)];
-}
-/**
- * Detect the nearest ancestor directory containing a `package.json` for the
- * first source file in `sourceFiles` (walk up, stop at `root`). Returns the
- * repo-relative path prefix (e.g. `packages/foo`) or undefined if none found.
- */
-function detectPackageRoot(sourceFiles, root) {
-    if (sourceFiles.length === 0)
-        return undefined;
-    const first = sourceFiles[0];
-    // Resolve to absolute path relative to root if not already absolute
-    const absFirst = first.startsWith("/") || /^[A-Za-z]:[/\\]/.test(first)
-        ? first
-        : join(root, first);
-    let dir = dirname(absFirst);
-    while (dir !== root && dir.length > root.length) {
-        if (existsSync(join(dir, "package.json"))) {
-            return relative(root, dir).replace(/\\/g, "/");
-        }
-        const parent = dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return undefined;
-}
-/**
- * The files an implement worker should receive as context for a finding:
- * pre-document affected_files PLUS any files the document phase declared in the
- * item_spec's `touched_files`.
- */
-function itemReadFiles(finding, spec) {
-    const files = finding.affected_files.map((f) => f.path);
-    if (spec?.touched_files)
-        files.push(...spec.touched_files);
-    return uniquePaths(files);
-}
-/**
- * The files an implement worker is expected to write. The documented
- * `touched_files` set is authoritative when present; affected_files are only a
- * fallback for older or incomplete document results.
- */
-function itemWriteFiles(finding, spec) {
-    if (Array.isArray(spec?.touched_files)) {
-        return uniquePaths(spec.touched_files);
-    }
-    return uniquePaths(finding.affected_files.map((f) => f.path));
-}
-/**
- * Repo-relative paths every finding in a block needs for context, deduped.
- */
-function blockReadFiles(block, state) {
-    const files = block.items.flatMap((findingId) => {
-        const finding = state.plan?.findings.find((f) => f.id === findingId);
-        if (!finding)
-            return [];
-        return itemReadFiles(finding, state.items?.[findingId]?.item_spec);
-    });
-    return uniquePaths(files);
-}
-/**
- * Repo-relative paths every finding in a block may write, deduped. This is kept
- * narrower than read context so a broad affected hub file does not serialize
- * blocks whose documented write sets are actually disjoint.
- */
-function blockWriteFiles(block, state) {
-    const files = block.items.flatMap((findingId) => {
-        const finding = state.plan?.findings.find((f) => f.id === findingId);
-        if (!finding)
-            return [];
-        return itemWriteFiles(finding, state.items?.[findingId]?.item_spec);
-    });
-    return uniquePaths(files);
-}
-/**
- * Construct the DispatchPlanItem for an implement task. Single source of truth
- * so prepareImplementDispatch and mergeImplementResults stay in lockstep on item
- * shape.
- */
-function buildImplementDispatchItem(block, state, dir) {
-    const taskId = `implement-${block.block_id}`;
-    const readFiles = blockReadFiles(block, state);
-    const writeFiles = blockWriteFiles(block, state);
-    const resultPath = join(dir, `${taskId}.result.json`);
-    return {
-        task_id: taskId,
-        block_id: block.block_id,
-        prompt_path: join(dir, `${taskId}.md`),
-        result_path: resultPath,
-        model_hint: buildImplementModelHint(block, state),
-        access: {
-            read_paths: readFiles,
-            write_paths: [...writeFiles, resultPath],
-        },
-    };
-}
-export function buildImplementModelHint(block, state) {
-    // Prefer the node's own promoted `model_tier` (derived from contract-pipeline
-    // complexity signals) over a re-derived block heuristic. In the contract
-    // pipeline a block maps 1:1 to a DAG node, so the block's single finding
-    // carries the authoritative relative rank. Never collapse to a flat
-    // "standard" when the node declared a tier.
-    const nodeTiers = block.items
-        .map((findingId) => {
-        const finding = state.plan?.findings.find((f) => f.id === findingId);
-        return finding ? nodeFieldsOf(finding).model_tier : undefined;
-    })
-        .filter((t) => t !== undefined);
-    if (nodeTiers.length > 0) {
-        // Take the most-capable declared rank across the block's nodes so a deep
-        // node is never under-provisioned by a sibling's smaller rank. Ordering is
-        // the single shared tier-rank authority (`mostCapableTier`).
-        const tier = mostCapableTier(nodeTiers) ?? "standard";
-        return { tier, reasons: ["node_model_tier"] };
-    }
-    const deepReasons = [];
-    let allSafe = true;
-    let maxSeverityRank = 0;
-    for (const findingId of block.items) {
-        const item = state.items?.[findingId];
-        const finding = state.plan?.findings.find((f) => f.id === findingId);
-        if (!finding)
-            continue;
-        const rank = severityRank(finding.severity);
-        if (rank > maxSeverityRank)
-            maxSeverityRank = rank;
-        if (item?.item_spec) {
-            const { tier } = classifyFindingRisk(finding, item.item_spec);
-            if (tier === "context_dependent") {
-                deepReasons.push(`context_dependent_${findingId}`);
-            }
-            if (tier !== "safe") {
-                allSafe = false;
-            }
-        }
-        else {
-            allSafe = false;
-        }
-    }
-    if (maxSeverityRank >= 5) {
-        deepReasons.push("critical_severity");
-    }
-    if (block.items.length >= 5) {
-        deepReasons.push("large_block");
-    }
-    if (deepReasons.length > 0) {
-        return { tier: "deep", reasons: deepReasons };
-    }
-    if (allSafe && block.items.length === 1 && maxSeverityRank <= 2) {
-        return { tier: "small", reasons: ["all_safe_single_finding"] };
-    }
-    return { tier: "standard", reasons: ["default_implement_block"] };
-}
-/**
- * G1 + INV-GND-02: a finding that the auditor's grounding pass marked ungrounded
- * — or that carries NO grounding verdict (undefined → treated as ungrounded) —
- * has not been positively re-verified against the cited code. Instruct the
- * worker to VERIFY the claim against the source first and only then fix it (or
- * resolve_no_change if the claim does not hold), rather than blindly applying a
- * fix to a possibly-stale/hallucinated finding. A positively-grounded finding
- * adds no bullet (it was already re-verified at ingest).
- */
-function groundingVerificationBullet(finding) {
-    if (!findingNeedsVerificationBeforeFix(finding))
-        return "";
-    const reason = finding.grounding?.reason
-        ? ` (${finding.grounding.reason})`
-        : " (no grounding verdict was recorded for this finding)";
-    return `- VERIFY BEFORE FIX: this finding is not positively grounded${reason}. Confirm the claim against the cited code first; if it holds, fix it, otherwise mark the item \`resolved_no_change\` with evidence. Do not apply a fix to an unverified claim.`;
-}
-/**
- * Opt-in meta-audit reflection invitation (parity with audit-code's worker
- * prompt). Rendered after the file-access section because it carves out one
- * extra append-only path. Shape: the shared `AgentReflectionSchema`;
- * the close phase aggregates the file into the report's "Process Feedback"
- * section. Best-effort by design — it must never compete with the obligation.
- */
-function reflectionInvitation(feedbackDisplay, taskId, lens) {
-    return `
-## Optional process feedback
-
-Never let this delay or replace the required output above: if you hit task
-ambiguity, tool friction, or unclear instructions, you MAY append one JSON
-reflection line to \`${feedbackDisplay}\` with shape:
-  {"task_id": "${taskId}"${lens ? `, "lens": "${lens}"` : ""}, "instruction_clarity": "clear|mostly_clear|ambiguous|unclear",
-   "ambiguities": ["..."], "tool_friction": ["..."], "suggestions": ["..."],
-   "severity": "info|low|medium|high"}
-One object per line; never overwrite existing lines. Appending to this file is
-allowed in addition to the file access above.
-`;
-}
-// ---------------------------------------------------------------------------
-// Infra-modifying block detection
-// ---------------------------------------------------------------------------
-/**
- * The live dispatch/orchestration modules whose modification can break the
- * running engine mid-run. Derived from the REAL post-A12 source layout
- * (`src/remediate/...`) — this module IS one of them (`steps/dispatch.ts`), so
- * the list is anchored to the actual files on disk, not a hand-typed monorepo
- * path that drifts when the tree is reorganised (the pre-A12
- * `packages/remediate-code/...` list silently matched NOTHING after the
- * collapse, so every infra block rendered as non-infra). Each entry is the
- * module's path relative to the `src/remediate` area, forward-slash form.
- */
-const INFRA_MODULE_SUBPATHS = [
-    "steps/nextStep.ts",
-    "steps/dispatch.ts",
-    "state/store.ts",
-    "steps/contractPipeline.ts",
-    "steps/stepWriter.ts",
-];
-/**
- * The infra module sub-paths anchored under `src/remediate/` — the canonical
- * repo-relative form for the current (post-A12) single-package layout. A write
- * path matches when its normalised (forward-slash) form ends with one of these
- * segments, so an absolute worktree path
- * (`.../worktrees/foo/src/remediate/steps/dispatch.ts`), a repo-relative path
- * (`src/remediate/steps/dispatch.ts`), or a Windows backslash path all match,
- * while a same-basename file in another area (`src/audit/steps/dispatch.ts`)
- * does not.
- */
-const INFRA_FILE_SEGMENTS = INFRA_MODULE_SUBPATHS.map((sub) => `src/remediate/${sub}`);
-/**
- * Returns true when any path in `writePaths` is one of the live infra modules.
- * Paths are normalised to forward-slash form (win32 backslash → `/`) and matched
- * by trailing repo-relative segment so absolute/worktree/relative spellings all
- * resolve identically. Used to gate the live-surface verification section in the
- * implement prompt.
- */
-export function isInfraModifyingBlock(writePaths) {
-    for (const p of writePaths) {
-        const normalized = p.replace(/\\/g, "/");
-        for (const segment of INFRA_FILE_SEGMENTS) {
-            if (normalized === segment || normalized.endsWith("/" + segment)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function infraModifyingSection(repoRoot) {
-    const rootDisplay = toPromptPathToken(repoRoot);
-    return `
-## Infra-modifying block
-
-This block modifies the dispatch/orchestration engine that the current run
-executes. **The host builds the package centrally — do NOT run \`npm run build\`
-or \`npm test\` here** (a worker-side build races the central build's \`dist/\`).
-Verify build-free only and let the host re-exercise the live surface after its
-central build:
-
-1. **Type-check (no emit):** After completing all edits, run:
-   \`\`\`
-   npm run check
-   \`\`\`
-   from \`${rootDisplay}\`. If type-check fails, mark the item blocked and record
-   the failure in \`failure_reason\`.
-
-2. **Targeted build-free tests:** Run this package's build-free test runner
-   directly against the tests for your change — for remediate-code:
-   \`\`\`
-   npx vitest run <your-test-file>
-   \`\`\`
-   from \`${rootDisplay}\`. Never invoke \`npm test\`/\`npm run build\`: those
-   prepend a build. If a targeted test fails, mark the item blocked and record
-   the failure in \`failure_reason\`.
-
-3. **Rollback is the host's job.** Because you do not build or republish the
-   engine, you cannot brick the live dispatcher mid-run. The host owns the
-   central build and any dist rollback; record the files you changed in your
-   result evidence so the host can attribute a post-build failure.
-`;
-}
-/**
- * Per-item bullets threading what upstream/neighbor nodes agreed to provide
- * (INV-DS-12): the node's reconciliation_expectations / preconditions and its
- * expected_changes. Rendered inside each item so a dependent node implements
- * against the realized upstream surface rather than guessing.
- */
-function upstreamExpectationsBullets(finding) {
-    const node = nodeFieldsOf(finding);
-    const expectations = reconciliationExpectationsOf(finding);
-    const lines = [];
-    if (expectations.length > 0) {
-        lines.push(`- Upstream/neighbor contract provides (implement against these, do not redefine them): ${expectations.join("; ")}`);
-    }
-    if (typeof node.expected_changes === "string" && node.expected_changes.trim().length > 0) {
-        lines.push(`- Expected changes: ${node.expected_changes.trim()}`);
-    }
-    if (Array.isArray(node.verification) && node.verification.length > 0) {
-        lines.push(`- Verification checks: ${node.verification.join("; ")}`);
-    }
-    return lines.join("\n");
-}
-/**
- * The build-free per-node verification section. Emits the node's own build-free
- * targeted commands (build/build-prepending commands filtered out — residual
- * CE-001) plus the standard build-free baseline (`npm run check` + the package's
- * build-free test runner). NON-EMITTING: it instructs the worker to run these to
- * gate its own result, never to emit further dispatch.
- */
-function perNodeVerificationSection(block, state, rootDisplay) {
-    const nodeCommands = uniquePaths(block.items.flatMap((findingId) => {
-        const finding = state.plan?.findings.find((f) => f.id === findingId);
-        return finding ? buildFreeVerifyCommands(finding.targeted_commands) : [];
-    }));
-    const commandBlock = nodeCommands.length > 0
-        ? `Run these node-targeted, build-free commands and record each command + result in the affected item's evidence:
-\`\`\`
-${nodeCommands.join("\n")}
-\`\`\`
-`
-        : "";
-    return `
-## Per-node verification (build-free)
-
-The host builds the package centrally; do NOT run \`npm run build\` or \`npm test\`
-(either races the central build's \`dist/\`). Verify build-free only, from
-\`${rootDisplay}\`:
-
-- Type-check with \`npm run check\` (no emit).
-- Run the package's build-free test runner directly against your change
-  (remediate-code: \`npx vitest run <your-test-file>\`; node-test packages:
-  \`node --import tsx/esm --test <your-test-file>\`).
-
-${commandBlock}A node is verified-complete only when its declared outputs exist and these
-build-free checks pass; otherwise mark the item blocked with the failure in
-\`failure_reason\`.
-`;
-}
-function implementPrompt(block, state, resultPath, conventions, repoRoot, feedbackDisplay, worktreeRoot) {
-    const items = block.items.flatMap((findingId) => {
-        const item = state.items?.[findingId];
-        const finding = state.plan?.findings.find((entry) => entry.id === findingId);
-        if (!finding)
-            return [];
-        // Only render items that still need implementing — never a resolved item
-        // from a prior wave or one the user skipped (deemed_inappropriate/ignored).
-        if (!item || isTerminalStatus(item.status))
-            return [];
-        if (item.status !== "pending")
-            return [];
-        // item_spec may be pre-populated from the plan DAG node or absent;
-        // either way the implementer receives finding context directly.
-        // clarification_context carries the user's answer when this item was re-opened
-        // from a clarification round (up-front gate or mid-run) — thread it through so
-        // the retry acts on the decided scope, not the original ambiguity.
-        return [{ finding, spec: item.item_spec, clarification: item.clarification_context }];
-    });
-    // When a worktreeRoot is supplied, the worker operates in the worktree, not
-    // the main repo root. Source file paths are prefixed with the worktree root.
-    // The result path always lives in the artifacts dir (outside the worktree).
-    const effectiveRoot = worktreeRoot ?? repoRoot;
-    // Normalize to forward slashes for host-facing prompt text; bash-like shells
-    // on Windows treat backslashes as escape characters.
-    const rootDisplay = toPromptPathToken(effectiveRoot);
-    const resultDisplay = toPromptPathToken(resultPath);
-    // Prefix each source file path with the worktree root when applicable.
-    function resolveFilePath(rel) {
-        if (!worktreeRoot)
-            return rel;
-        if (rel.startsWith("/") || /^[A-Za-z]:[/\\]/.test(rel))
-            return rel;
-        return toPromptPathToken(join(worktreeRoot, rel));
-    }
-    const worktreeNote = worktreeRoot
-        ? `\nYou are working in a worktree at ${toPromptPathToken(worktreeRoot)}; all file edits go here. Do not edit files outside this worktree.\n`
-        : "";
-    return `
-# Implement Remediation Block
-
-You are implementing one bounded remediation block. Edit the files needed for the
-findings in this prompt, and you MAY create new files (e.g. a test file or an
-extracted module) within the SAME package as those files when a finding's change
-calls for it. Do not edit unrelated files in other packages, and do not change
-remediation state files directly.
-Repository root: ${rootDisplay}
-Set the shell/tool workdir to the repository root when running commands; do not rely on cwd state from prior shell calls.
-
-## Block
-
-- Block ID: ${block.block_id}
-- Findings: ${items.map(({ finding }) => finding.id).join(", ")}
-
-## Items
-
-${items
-        .map(({ finding, spec, clarification }) => `
-### ${finding.id} — ${finding.title}
-
-${findingLead(finding.summary)}
-
-${renderFindingBadgeBody(finding, { showGrounding: false, showAdvisoryMeta: false, showFiles: false, showDetails: false, showEvidence: false }).join("\n")}
-- Files: ${itemReadFiles(finding, spec).map(resolveFilePath).join(", ")}
-- Details: ${finding.summary}
-${clarification ? `- Clarified scope (decided with the user — act on THIS): ${clarification}\n` : ""}${groundingVerificationBullet(finding)}
-${spec ? `- Concrete change: ${spec.concrete_change}
-- Tests to write: ${spec.tests_to_write
-        .map((test) => `${test.name}: ${test.assertions.join("; ")}`)
-        .join(" | ")}` : ""}
-${upstreamExpectationsBullets(finding)}
-`)
-        .join("\n")}
-${conventions ? `\n${conventions}\n` : ""}${perNodeVerificationSection(block, state, rootDisplay)}${isInfraModifyingBlock(blockWriteFiles(block, state)) ? infraModifyingSection(repoRoot) : ""}
-## Verification
-${worktreeNote}
-Run changed or newly created tests by name when possible, and record the focused
-command and result in the affected item's evidence. If a broad or full-suite
-command fails in a dirty worktree and appears unrelated or pre-existing, record
-that broad failure separately instead of using it as the only verdict for this
-block. If a focused test for this block fails, the affected item remains blocked.
-If targeted commands are listed under an item, run them when applicable and
-include each command and result in that item's evidence.
-
-Windows PowerShell: do not pipe an inline foreach statement directly into ConvertTo-Json.
-Assign the foreach output to a variable first, then pipe that variable to ConvertTo-Json.
-
-## Output
-
-After editing and verifying the block, write JSON to exactly:
-
-\`${resultDisplay}\`
-
-Emit **exactly one \`item_results\` entry per node id below — no more, no fewer**.
-Each entry's \`finding_id\` MUST be one of the exact ids: ${items
-        .map(({ finding }) => `\`${finding.id}\``)
-        .join(", ")}. Do not substitute a title, an obligation id, or a block id for
-the node id, and do not emit duplicate entries for the same node.
-
-\`\`\`json
-{
-  "contract_version": "${REMEDIATION_WORKER_RESULT_CONTRACT_VERSION}",
-  "phase": "implement",
-  "item_results": [
-${items
-        .map(({ finding }) => `    {
-      "finding_id": "${finding.id}",
-      "status": "resolved",
-      "evidence": ["test or verification evidence"]
-    }`)
-        .join(",\n")}
-  ]
-}
-\`\`\`
-
-For an item you cannot safely finish because of an EXECUTION failure (a test
-won't pass, a build breaks, the change is infeasible), set \`status\` to
-\`blocked\` and include \`failure_reason\`. If instead you are stuck on a SCOPING
-or JUDGMENT question — how far the fix should reach, which of several valid
-behaviors is intended, or whether the issue is real — do NOT guess and do NOT
-block: set \`status\` to \`needs_clarification\` and put the question in
-\`clarification_question\` (optionally \`clarification_category\`). It is routed to
-the user as a real question, then re-dispatched with the answer. Stop after
-writing the result JSON.
-
-## File access
-
-Read: ${uniquePaths(items.flatMap(({ finding, spec }) => itemReadFiles(finding, spec))).join(", ")}
-Write: ${uniquePaths(items.flatMap(({ finding, spec }) => itemWriteFiles(finding, spec))).join(", ")}
-You may also create new files within the same package as those files (e.g. tests
-or extracted modules) when a finding requires it.
-If your change renames, moves, or removes a symbol, also update the existing test
-files that reference it — fixing tests for a changed surface is part of this
-block, not a later cleanup. Test files that reference these files are included in
-your write access.
-Write result: ${resultDisplay}
-Do not modify unrelated files outside these paths or files in other packages.
-${reflectionInvitation(feedbackDisplay, block.block_id)}`;
-}
-async function loadStateOrThrow(artifactsDir) {
-    const state = await new StateStore(artifactsDir).loadState();
-    if (!state) {
-        throw new Error(`No remediation state found at ${join(artifactsDir, "state.json")}.`);
-    }
-    return state;
-}
-export async function prepareImplementDispatch(options, runId, onlyBlockId, waveOptions) {
-    const state = await loadStateOrThrow(options.artifactsDir);
-    if (!state.plan || !state.items) {
-        throw new Error("Cannot prepare implement dispatch without plan and items.");
-    }
-    const dir = runDir(options.artifactsDir, runId, "implement");
-    await mkdir(dir, { recursive: true });
-    // Use the module-level cache so repeated calls within the same process do not
-    // re-scan the filesystem for repo conventions.
-    const conventions = getCachedConventions(options.root);
-    const seenBlockIds = new Set();
-    const candidateBlocks = state.plan.blocks.filter((block) => {
-        if (onlyBlockId && block.block_id !== onlyBlockId)
-            return false;
-        if (seenBlockIds.has(block.block_id))
-            return false;
-        // Rolling eligibility (INV-RS-01): a dependent node is dispatched only once
-        // every prerequisite reached a VERIFIED-COMPLETE disposition
-        // (resolved / resolved_no_change). A skipped or blocked prerequisite never
-        // satisfies the edge, so the dependent is held back rather than racing the
-        // main tree against an upstream surface that never landed.
-        if (!dependencyVerifiedComplete(block, state))
-            return false;
-        const hasWork = block.items.some((findingId) => {
-            const item = state.items?.[findingId];
-            return item?.status === "pending";
-        });
-        if (hasWork) {
-            seenBlockIds.add(block.block_id);
-            return true;
-        }
-        return false;
-    });
-    // Before any node is dispatched (and therefore before any accepted commit is
-    // cherry-picked into the main tree), switch the main checkout onto the dedicated
-    // remediation branch so all landed work accumulates there and the base branch is
-    // never modified. Idempotent across waves; only when there is work to land.
-    if (candidateBlocks.length > 0 && options.root) {
-        ensureRemediationBranchCheckedOut(options.root, runId, options.artifactsDir);
-    }
-    // Walk the repo for test files ONCE per dispatch (not once per block) and cache
-    // their contents; collectReferencingTests then matches in memory.
-    const testIndex = buildTestFileIndex(options.root);
-    const items = [];
-    const itemReadFileLists = [];
-    let reconciledCount = 0;
-    for (const block of candidateBlocks) {
-        const item = buildImplementDispatchItem(block, state, dir);
-        const readFiles = blockReadFiles(block, state);
-        // Detect the package root from this block's source files: walk up from the
-        // first source file to the nearest ancestor with a package.json (stop at root).
-        const packageRoot = detectPackageRoot(readFiles, options.root);
-        // Pull test files that reference this block's source into its access, so the
-        // worker that changes or removes a symbol also fixes the tests that assert it
-        // (otherwise their breakage is orphaned for a separate central mop-up).
-        // Scoped to the block's package to avoid pulling in unrelated package tests.
-        const referencingTests = collectReferencingTests(testIndex, readFiles, packageRoot);
-        if (referencingTests.length > 0 && item.access) {
-            item.access.read_paths = [
-                ...new Set([...item.access.read_paths, ...referencingTests]),
-            ];
-            item.access.write_paths = [
-                ...new Set([...item.access.write_paths, ...referencingTests]),
-            ];
-        }
-        // Reconcile an already-produced result regardless of wave packing.
-        const pendingFindingIds = pendingOrDocumentedFindingIdsForBlock(block, state);
-        const existingResult = await tryLoadExistingImplementResult(item.result_path);
-        if (existingResult) {
-            if (implementResultCoversFindings(existingResult, pendingFindingIds, block, state)) {
-                reconciledCount++;
-                continue;
-            }
-            process.stderr.write(`[remediate-code] dispatch: existing implement result for block ${block.block_id} ` +
-                `does not cover ${pendingFindingIds.length} still-pending item(s); re-dispatching\n`);
-            await archiveIncompleteImplementResult(item.result_path);
-        }
-        // No wave-time file-conflict deferral heuristic: parallel blocks with
-        // overlapping files are both dispatched. Parallel safety comes from the planner
-        // (mergeBlocksSharingFiles) and rolling verified-complete dependency ordering
-        // (dependencyVerifiedComplete). Workers operate in isolated worktrees;
-        // verification prevents bad merges from dirtying the main tree.
-        await writeTextFile(item.prompt_path, implementPrompt(block, state, item.result_path, conventions, options.root, toPromptPathToken(join(options.artifactsDir, AGENT_FEEDBACK_FILENAME)), waveOptions?.worktreeRootedPrompts
-            ? worktreePath(options.root, block.block_id, runId)
-            : undefined));
-        items.push(item);
-        itemReadFileLists.push([...readFiles, ...referencingTests]);
-    }
-    if (reconciledCount > 0) {
-        console.log(`Reconciliation: reused ${reconciledCount} existing implement results.`);
-    }
-    const plan = {
-        contract_version: REMEDIATION_DISPATCH_PLAN_CONTRACT_VERSION,
-        phase: "implement",
-        run_id: runId,
-        // Normalize to forward slashes so hosts running bash-like shells on Windows
-        // receive paths that survive shell expansion (backslash is an escape char).
-        repo_root: toPromptPathToken(options.root),
-        artifacts_dir: toPromptPathToken(options.artifactsDir),
-        items,
-    };
-    await writeJsonFile(dispatchPlanPath(options.artifactsDir, runId, "implement"), plan);
-    const estimatedSlotTokens = itemReadFileLists.map((files) => estimateImplementSlotTokens(files, options.root));
-    const schedule = await scheduleWave({
-        hostMaxConcurrent: waveOptions?.hostMaxConcurrent,
-        sessionConfig: waveOptions?.sessionConfig ?? null,
-        hostContextTokens: waveOptions?.hostContextTokens,
-        hostOutputTokens: waveOptions?.hostOutputTokens,
-        hostModels: waveOptions?.hostModels,
-        hostModelId: waveOptions?.hostModelId,
-        itemCount: items.length,
-        estimatedSlotTokens,
-    });
-    // Admission packets in plan order: id = the node's block id (what
-    // `admission.granted_packet_ids` references and the host matches to nodes),
-    // inputTokens = its estimated slot cost, complexity = the remediate default 0.5.
-    // Keyed by block_id (same filter the frontier builder uses), so a granted id always
-    // resolves to a frontier node.
-    const admissionPackets = items
-        .map((item, i) => ({ item, inputTokens: estimatedSlotTokens[i] ?? 0 }))
-        .filter((p) => typeof p.item.block_id === "string")
-        .map((p) => ({ id: p.item.block_id, inputTokens: p.inputTokens, complexity: 0.5 }));
-    process.stderr.write(`[remediate-code] dispatch: implement ${items.length} item(s) ` +
-        `source=${schedule.source} cap=${schedule.binding_cap ?? "none"}\n`);
-    // Cost-first routing rung 1: honor the operator-confirmed cost ordering from the
-    // shared Gate-0 confirmation (spec/cost-first-routing.md). Best-effort — absent /
-    // unreadable / roster-changed confirmation ⇒ costRank falls to real price then tier.
-    const confirmedCostPositions = await readConfirmedCostPositions(options.root, waveOptions?.sessionConfig ?? {});
-    const quota = await buildDispatchQuota(runId, "implement", schedule, admissionPackets, waveOptions?.grantLeases ?? true, null, confirmedCostPositions);
-    await writeJsonFile(join(dir, "dispatch-quota.json"), quota);
-    return plan;
-}
-function assertImplementWorkerResult(value, path) {
-    const issues = validateImplementWorkerResult(value, path).filter((i) => i.severity === "error");
-    if (issues.length > 0) {
-        throw new Error(formatValidationIssues(issues));
-    }
-}
-/** True when `root` is inside a git work tree (the git tool is present and it's a repo). */
-function isGitWorkTree(root) {
-    const probe = spawnSyncHidden("git", ["rev-parse", "--is-inside-work-tree"], { cwd: root, encoding: "utf8", shell: false });
-    return !probe.error && probe.status === 0 && /true/.test(probe.stdout ?? "");
-}
-/** True when `branch` resolves to a commit in the repo at `root`. */
-function gitBranchExists(root, branch) {
-    const probe = spawnSyncHidden("git", ["rev-parse", "--verify", "--quiet", `${branch}^{commit}`], { cwd: root, encoding: "utf8", shell: false });
-    return !probe.error && probe.status === 0;
-}
-/** Normalize a declared path (absolute, repo-relative, or back-slashed) to a repo-relative forward-slash string. */
-function toRepoRelative(p, root) {
-    const normalizedRoot = root.replace(/\\/g, "/").replace(/\/$/, "");
-    let s = p.replace(/\\/g, "/");
-    if (s.startsWith(normalizedRoot + "/")) {
-        s = s.slice(normalizedRoot.length + 1);
-    }
-    return s;
-}
-/**
- * Files the worker edited (from git) that fall OUTSIDE the block's declared
- * write scope. Result-file artifacts and the agent-feedback file are excluded
- * (they are sanctioned side outputs, never source edits). Returns the offending
- * repo-relative paths (empty when the edits are fully within scope).
- */
-export function writeScopeViolations(declaredWritePaths, editedFiles, root) {
-    const declared = new Set(declaredWritePaths.map((p) => toRepoRelative(p, root)));
-    const violations = [];
-    for (const edited of editedFiles) {
-        const rel = toRepoRelative(edited, root);
-        if (declared.has(rel))
-            continue;
-        // Sanctioned non-source outputs: result JSON files and the reflection file.
-        if (rel.endsWith(".result.json"))
-            continue;
-        if (rel.endsWith(AGENT_FEEDBACK_FILENAME))
-            continue;
-        violations.push(rel);
-    }
-    return violations;
-}
-/** Branch name a block's isolated worktree is created on (mirrors `worktreePath`). */
-export function worktreeBranchForBlock(blockId, runId) {
-    return `remediate-${blockId}-${runId}`;
-}
-/**
- * The files a worker's worktree branch changed relative to HEAD — the ground
- * truth for write-scope enforcement. Diffs `HEAD...<branch>` (the branch's own
- * commits). Fail-closed / not-a-repo semantics mirror `gitEditedFiles`.
- */
-export function gitEditedFilesForBranch(root, branch) {
-    if (!isGitWorkTree(root)) {
-        return { available: false, reason: "not_a_repo", error: "root is not a git work tree" };
-    }
-    const diff = spawnSyncHidden("git", ["diff", "--name-only", `HEAD...${branch}`], { cwd: root, encoding: "utf8", shell: false });
-    if (diff.error || typeof diff.status !== "number" || diff.status !== 0) {
-        const detail = (diff.stderr ?? diff.error?.message ?? "git diff failed").toString().trim();
-        return { available: false, reason: "probe_failed", error: detail };
-    }
-    const files = new Set();
-    for (const line of (diff.stdout ?? "").split(/\r?\n/)) {
-        const p = line.trim();
-        if (p.length > 0)
-            files.add(p.replace(/\\/g, "/"));
-    }
-    return { available: true, files };
-}
-/**
- * Parse `git diff HEAD...<branch>` into per-hunk NEW-side line ranges — the
- * ground truth for whether two same-file edits actually touch disjoint regions.
- * Mirrors {@link gitEditedFilesForBranch}'s fail-closed / not-a-repo semantics:
- * never throws; on a non-repo / failed probe / malformed diff returns a
- * discriminated result marking hunks unavailable so the caller can fail closed.
- *
- * Paths are normalised to repo-relative forward-slash (the same scheme
- * {@link gitEditedFilesForBranch} emits) so hunk files compare like-for-like
- * with the file set.
- */
-export function gitHunksForBranch(root, branch) {
-    if (!isGitWorkTree(root)) {
-        return { available: false, reason: "not_a_repo", error: "root is not a git work tree" };
-    }
-    const diff = spawnSyncHidden("git", 
-    // No rename detection / context noise beyond what we parse; a plain unified
-    // diff carries the `+++ b/<path>` and `@@ … +start,count @@` headers we need.
-    ["diff", `HEAD...${branch}`], { cwd: root, encoding: "utf8", shell: false });
-    if (diff.error || typeof diff.status !== "number" || diff.status !== 0) {
-        const detail = (diff.stderr ?? diff.error?.message ?? "git diff failed").toString().trim();
-        return { available: false, reason: "probe_failed", error: detail };
-    }
-    return parseUnifiedDiffHunks(diff.stdout ?? "");
-}
-/**
- * Parse a unified-diff body into NEW-side hunk ranges. Extracted for testability
- * (no git spawn). Recognises `+++ b/<path>` file headers and
- * `@@ -a,b +c,d @@` hunk headers; a header we cannot parse fails the whole probe
- * closed (returns `probe_failed`) rather than silently producing partial hunks
- * that would let a real overlap slip through.
- */
-export function parseUnifiedDiffHunks(diffText) {
-    const hunks = [];
-    let currentFile = null;
-    for (const rawLine of diffText.split(/\r?\n/)) {
-        if (rawLine.startsWith("+++ ")) {
-            // `+++ b/path` — or `+++ /dev/null` for a pure deletion (no new side).
-            const target = rawLine.slice(4).trim();
-            if (target === "/dev/null") {
-                currentFile = null;
-                continue;
-            }
-            // Strip the conventional `b/` prefix; leave already-bare paths intact.
-            const bare = target.startsWith("b/") ? target.slice(2) : target;
-            currentFile = bare.replace(/\\/g, "/");
-            continue;
-        }
-        if (rawLine.startsWith("@@")) {
-            const match = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/.exec(rawLine);
-            if (!match) {
-                return {
-                    available: false,
-                    reason: "probe_failed",
-                    error: `unparseable hunk header: ${rawLine}`,
-                };
-            }
-            if (currentFile === null)
-                continue; // deletion-only target: no new-side hunk.
-            const startLine = Number(match[1]);
-            const lineCount = match[2] === undefined ? 1 : Number(match[2]);
-            hunks.push({ file: currentFile, startLine, lineCount });
-        }
-    }
-    return { available: true, hunks };
-}
-/**
- * Pure write-scope gate decision (OBL-DS-06). Given the block's declared write
- * paths and the resolved git edit set:
- *  - `not_a_repo`   → no ground truth (no worktree workflow) → not blocked.
- *  - `probe_failed` → git is a repo but the diff failed → FAIL CLOSED (blocked).
- *  - available      → block iff any edited file is outside declared scope.
- * The worker's self-reported `amended_files` is never an input here.
- */
-export function enforceWriteScope(declaredWritePaths, edited, root) {
-    if (!edited.available) {
-        if (edited.reason === "not_a_repo") {
-            return { blocked: false };
-        }
-        // probe_failed: git is present but could not be queried → fail closed.
-        return {
-            blocked: true,
-            reason: `Write-scope could not be verified: git probe failed (${edited.error}). ` +
-                `Failing closed rather than trusting self-reported edits.`,
-        };
-    }
-    const violations = writeScopeViolations(declaredWritePaths, edited.files, root);
-    if (violations.length === 0)
-        return { blocked: false };
-    return {
-        blocked: true,
-        reason: `Worker edited files outside its declared write scope: ${violations.join(", ")}. ` +
-            `Declared scope must be amended through the seam protocol; the self-reported ` +
-            `amended_files set is not trusted for this gate.`,
-    };
-}
-/** Each block's declared write scope from a dispatch plan — the seed for the
- *  accept-time write-scope gate's ownership registry (so an amended path owned by
- *  a sibling block is recognised as a seam conflict, not silently granted). */
-export function blockScopesFromPlan(plan) {
-    return plan.items.flatMap((item) => item.block_id && item.access
-        ? [{ block_id: item.block_id, write_paths: item.access.write_paths }]
-        : []);
-}
-/**
- * A block's declared target paths (write ∪ read) from the persisted dispatch plan
- * — the single source of the scope the worker actually received (same authority
- * the accept-time write-scope gate reads). Used to seed untracked declared targets
- * into a fresh worktree (see {@link seedUntrackedDeclaredPaths}).
- */
-export function declaredPathsFromPlan(plan, blockId) {
-    const item = plan.items.find((i) => i.block_id === blockId);
-    if (!item?.access)
-        return [];
-    return [...(item.access.write_paths ?? []), ...(item.access.read_paths ?? [])];
-}
-/**
- * Pure write-scope adjudication (OBL-DS-06) — git-free so it is unit-testable with
- * a synthetic edit set. Seeds an ephemeral `OwnershipRegistry` from `allBlockScopes`
- * (normalised to repo-relative so ownership compares like-for-like) and routes the
- * node's ACTUAL out-of-declared edits — the git ground truth, never a self-report:
- *  - an edit to a file no sibling block owns is granted and widens this node's
- *    effective scope (a too-narrow — or empty — declared scope no longer blocks a
- *    correct fix; this is the sanctioned "extend into unowned files" path);
- *  - an edit to a file in another block's declared scope is a seam conflict that
- *    blocks until the seam protocol re-scopes or serialises the nodes.
- * Cross-sibling contention on a file two live nodes both touch (neither declared)
- * is left to the merge-time lost-update detector (`detectOverlappingEdits`), which
- * sees the full set of merged blocks a single accept cannot.
- */
-export function adjudicateWriteScope(allBlockScopes, blockId, edited, root) {
-    const registry = new OwnershipRegistry();
-    registry.initialize(allBlockScopes.map((b) => ({
-        node_id: b.block_id,
-        write_paths: b.write_paths.map((p) => toRepoRelative(p, root)),
-    })));
-    if (edited.available) {
-        // The node's real source edits outside its declared scope (sanctioned side
-        // outputs already excluded by writeScopeViolations).
-        const candidates = writeScopeViolations(registry.getScope(blockId), edited.files, root);
-        if (candidates.length > 0) {
-            const { seam_routed } = routeAmendmentRequest(registry, blockId, candidates);
-            if (seam_routed.length > 0) {
-                const detail = seam_routed
-                    .map((r) => {
-                    const reason = r.reason;
-                    if (reason.outcome === "owned")
-                        return `${r.path} owned by ${reason.owner_node_id}`;
-                    if (reason.outcome === "contended") {
-                        return `${r.path} contended by ${reason.sibling_node_id}`;
-                    }
-                    return r.path;
-                })
-                    .join("; ");
-                return {
-                    blocked: true,
-                    reason: `Node edited files owned by another block (seam conflict): ${detail}. ` +
-                        `Resolve via the seam protocol (re-scope contracts or serialise the nodes) before this node can land.`,
-                };
-            }
-            // every candidate was unowned → granted into this node's effective scope.
-        }
-    }
-    return enforceWriteScope(registry.getScope(blockId), edited, root);
-}
-/**
- * Accept-time write-scope gate, run from `acceptNodeWorktree` AFTER the verify and
- * BEFORE the cherry-pick so a violation PREVENTS the merge rather than being
- * reported once the edit already landed in main. Thin git wrapper around
- * {@link adjudicateWriteScope}: resolves the branch's actual edits and adjudicates.
- */
-export function enforceAcceptWriteScope(params) {
-    const { root, branch, blockId, allBlockScopes } = params;
-    return adjudicateWriteScope(allBlockScopes, blockId, gitEditedFilesForBranch(root, branch), root);
-}
-// ---------------------------------------------------------------------------
-// Merge-seam: obligation-id → node remap + multi-entry collapse (tolerance)
-// ---------------------------------------------------------------------------
-/**
- * Build the map from a known obligation/node alias to the finding id that owns
- * it, for one block. A worker that mislabels its `finding_id` as an obligation
- * id it was assigned (or a CP-BLOCK-prefixed/unprefixed node alias) is remapped
- * to the owning node's finding rather than dropped as an orphan — the tolerant
- * seam (the host is a variable of any strength). The map only ever points at
- * findings that belong to THIS block, so a mislabel can never resolve to an
- * unrelated node.
- */
-export function buildBlockAliasMap(block, state) {
-    const aliasToFinding = new Map();
-    for (const findingId of block.items) {
-        const finding = state.plan?.findings.find((f) => f.id === findingId);
-        if (!finding)
-            continue;
-        // The node id itself, and its block-prefixed / unprefixed aliases.
-        const register = (alias) => {
-            if (!alias || alias === findingId)
-                return;
-            if (!aliasToFinding.has(alias))
-                aliasToFinding.set(alias, findingId);
-        };
-        // CP-BLOCK- aliases are now resolved deterministically by the id registry in
-        // `collapseItemResults` (S4); registering them here is defence-in-depth only.
-        register(toBlockId(findingId));
-        register(block.block_id);
-        // The obligation ids the node satisfies/verifies — a worker may report one.
-        for (const obl of [
-            ...(finding.contract_obligation_ids ?? []),
-            ...(finding.verification_obligation_ids ?? []),
-        ]) {
-            register(obl);
-        }
-    }
-    return aliasToFinding;
-}
-/**
- * Collapse a worker result's `item_results` to one entry per resolved finding
- * id, applying the block alias map first (obligation/node-alias → finding). When
- * several entries collapse onto the same finding, a single `blocked` entry wins
- * over `resolved` (a node is not complete if any reported facet failed), and the
- * union of evidence / first failure_reason is preserved. Entries whose id is
- * neither a known finding nor a known alias are returned in `unresolved` so the
- * caller can record them as orphans.
- */
-export function collapseItemResults(itemResults, aliasMap, knownFindingIds) {
-    const byFinding = new Map();
-    const unresolved = [];
-    for (const entry of itemResults) {
-        let targetId = entry.finding_id;
-        if (!knownFindingIds.has(targetId)) {
-            // Registry-authoritative (S4): a CP-BLOCK- block id maps deterministically
-            // to its bare node id via the id registry, so the common "worker reported
-            // the block id" mislabel resolves here without the tolerant alias remap —
-            // the remap is defence-in-depth for non-block aliases (e.g. a mislabelled
-            // obligation id) only.
-            const nodeId = fromBlockId(targetId);
-            if (nodeId && knownFindingIds.has(nodeId)) {
-                targetId = nodeId;
-            }
-            else {
-                const remapped = aliasMap.get(targetId);
-                if (remapped) {
-                    targetId = remapped;
-                }
-                else {
-                    unresolved.push(entry);
-                    continue;
-                }
-            }
-        }
-        const normalized = { ...entry, finding_id: targetId };
-        const existing = byFinding.get(targetId);
-        if (!existing) {
-            byFinding.set(targetId, normalized);
-            continue;
-        }
-        // Collapse precedence: blocked > needs_clarification > resolved >
-        // resolved_no_change. A hard failure dominates an unanswered scoping question,
-        // which dominates an actual change, which dominates a no-change claim (a
-        // no-change claim only survives if every entry agreed nothing changed). Merge
-        // evidence; keep first failure_reason / clarification question.
-        const mergedEvidence = [
-            ...new Set([...(existing.evidence ?? []), ...(normalized.evidence ?? [])]),
-        ];
-        const status = existing.status === "blocked" || normalized.status === "blocked"
-            ? "blocked"
-            : existing.status === "needs_clarification" || normalized.status === "needs_clarification"
-                ? "needs_clarification"
-                : existing.status === "resolved" || normalized.status === "resolved"
-                    ? "resolved"
-                    : "resolved_no_change";
-        byFinding.set(targetId, {
-            finding_id: targetId,
-            status,
-            evidence: mergedEvidence.length > 0 ? mergedEvidence : undefined,
-            failure_reason: existing.failure_reason ?? normalized.failure_reason,
-            clarification_question: existing.clarification_question ?? normalized.clarification_question,
-            clarification_category: existing.clarification_category ?? normalized.clarification_category,
-        });
-    }
-    return { collapsed: [...byFinding.values()], unresolved };
-}
-/**
- * Build the per-node disposition for a block (INV-DS-15). A SKIP disposition
- * (user-skipped: `ignored` / `deemed_inappropriate`) is NEVER reported as
- * `verified_complete`. Each block maps 1:1 to a node, so the disposition keys on
- * the block's first finding (the node id).
- */
-export function buildNodeDisposition(block, state) {
-    const nodeId = block.items[0] ?? block.block_id;
-    const finding = state.plan?.findings.find((f) => f.id === nodeId);
-    // Resolve the block's overall status from its items.
-    const statuses = block.items.map((id) => state.items?.[id]?.status ?? "pending");
-    const isSkip = statuses.some((s) => isSkipStatus(s));
-    const allResolved = statuses.length > 0 && statuses.every((s) => isVerifiedCompleteStatus(s));
-    const anyBlocked = statuses.some((s) => s === "blocked");
-    let disposition;
-    if (isSkip) {
-        // INV-DS-15: a skipped node is never verified_complete.
-        disposition = "skipped";
-    }
-    else if (anyBlocked) {
-        disposition = "blocked";
-    }
-    else if (allResolved) {
-        disposition = "verified_complete";
-    }
-    else {
-        disposition = "missing_result";
-    }
-    const reason = block.items
-        .map((id) => state.items?.[id]?.failure_reason)
-        .find((r) => typeof r === "string" && r.length > 0);
-    return {
-        node_id: nodeId,
-        block_id: block.block_id,
-        disposition,
-        finding_status: statuses.join(","),
-        reconciliation_expectations: finding ? reconciliationExpectationsOf(finding) : [],
-        reason,
-    };
-}
-/**
- * Attribute a post-merge sibling-block failure (INV-DS-14). Given the repo-
- * relative paths implicated by a red sibling and the merged blocks' declared
- * write scopes, return the exactly-one block whose scope contains an implicated
- * file (attributable → route THAT sibling to triage). When zero or more than one
- * merged block could own the failure, the red is unattributable and is deferred
- * to the rolling-scheduler's coarse backstop (return null).
- */
-export function attributeSiblingRed(implicatedFiles, mergedBlockScopes, root) {
-    const implicated = new Set(implicatedFiles.map((p) => toRepoRelative(p, root)));
-    const owners = new Set();
-    for (const { block_id, write_paths } of mergedBlockScopes) {
-        for (const wp of write_paths) {
-            if (implicated.has(toRepoRelative(wp, root))) {
-                owners.add(block_id);
-                break;
-            }
-        }
-    }
-    // Attributable only when a single merged block owns the implicated surface.
-    return owners.size === 1 ? [...owners][0] : null;
-}
-/**
- * Detect lost-update hazards across concurrently-merged blocks (ARC-f378135d-2 /
- * ARC-c1693139). When the rolling engine dispatches multiple nodes in flight and
- * each worker edits in its own worktree, two workers can both modify the SAME
- * file; cherry-picking both branches silently drops one worker's change to that
- * file (lost update). This pure function returns every repo-relative path that
- * appears in more than one merged block's ACTUAL edit set, with the owning block
- * ids. The caller routes the involved blocks to triage so the conflict is
- * reconciled rather than silently losing an edit. Result-file artifacts and the
- * agent-feedback file are sanctioned side outputs and are never counted as
- * overlaps.
- */
-export function detectOverlappingEdits(editedByBlock) {
-    const isSanctionedSideOutput = (rel) => rel.endsWith(".result.json") || rel.endsWith(AGENT_FEEDBACK_FILENAME);
-    // path → block_id → the block's hunks for that path (undefined when hunk info
-    // is unavailable for the block, which forces the conservative fail-closed path).
-    const pathToBlockHunks = new Map();
-    for (const { block_id, files, hunks } of editedByBlock) {
-        for (const file of files) {
-            const rel = file.replace(/\\/g, "/");
-            // Sanctioned non-source outputs never constitute a lost-update conflict.
-            if (isSanctionedSideOutput(rel))
-                continue;
-            let byBlock = pathToBlockHunks.get(rel);
-            if (!byBlock) {
-                byBlock = new Map();
-                pathToBlockHunks.set(rel, byBlock);
-            }
-            // Hunk info is only usable when git resolved it AND this block edited this
-            // file per its hunk set. `available:false` (or an absent map) → undefined,
-            // which detectOverlap treats as "cannot prove disjoint" → collision stands.
-            const fileHunks = hunks?.available === true
-                ? hunks.hunks.filter((h) => h.file === rel)
-                : undefined;
-            byBlock.set(block_id, fileHunks);
-        }
-    }
-    const overlaps = [];
-    for (const [path, byBlock] of pathToBlockHunks) {
-        if (byBlock.size <= 1)
-            continue;
-        const owners = [...byBlock.keys()].sort();
-        // A file is a lost-update hazard iff SOME pair of owning blocks has edits we
-        // cannot prove disjoint. If EVERY pair's hunks are known and disjoint, the
-        // cherry-picks compose cleanly → not a collision. Any pair with unavailable
-        // hunks fails closed (treated as overlapping).
-        let collides = false;
-        outer: for (let i = 0; i < owners.length; i++) {
-            for (let j = i + 1; j < owners.length; j++) {
-                const a = byBlock.get(owners[i]);
-                const b = byBlock.get(owners[j]);
-                if (a === undefined || b === undefined) {
-                    collides = true; // fail closed: no proof of disjointness.
-                    break outer;
-                }
-                if (hunkRangesOverlap(a, b)) {
-                    collides = true;
-                    break outer;
-                }
-            }
-        }
-        if (collides) {
-            overlaps.push({ path, block_ids: owners });
-        }
-    }
-    // Deterministic ordering so the diagnostic + tests are stable.
-    return overlaps.sort((a, b) => a.path.localeCompare(b.path));
-}
-/**
- * True when any hunk in `a` shares a new-side line with any hunk in `b`. Each
- * hunk spans `[startLine, startLine + lineCount - 1]`; a zero-line hunk (pure
- * deletion at `startLine`) is treated as touching the single anchor line
- * `startLine` so a deletion adjacent to another block's insertion is still a
- * conflict. Purely non-overlapping ranges (e.g. lines 1–5 vs 40–50) return
- * false → the two edits are disjoint and compose cleanly.
- */
-function hunkRangesOverlap(a, b) {
-    const span = (h) => {
-        const count = h.lineCount > 0 ? h.lineCount : 1;
-        return [h.startLine, h.startLine + count - 1];
-    };
-    for (const ha of a) {
-        const [aStart, aEnd] = span(ha);
-        for (const hb of b) {
-            const [bStart, bEnd] = span(hb);
-            if (aStart <= bEnd && bStart <= aEnd)
-                return true;
-        }
-    }
-    return false;
-}
-/**
- * The contract-pipeline obligation ids a finding covers — the union of its
- * `contract_obligation_ids` (satisfied) and `verification_obligation_ids`
- * (verified). Empty for audit-findings intake (no contract overlay), so the DC-5
- * verify gate is inert there.
- */
-function obligationIdsForFinding(state, findingId) {
-    const finding = state.plan?.findings.find((f) => f.id === findingId);
-    if (!finding)
-        return [];
-    return [
-        ...(finding.contract_obligation_ids ?? []),
-        ...(finding.verification_obligation_ids ?? []),
-    ];
-}
-/**
- * Reconcile (free) the reservation-ledger leases the dispatch grant took for this
- * run's granted set — the "reconcile at result-ingest" half of admission control
- * (spec/audit/dispatch-admission-control.md), the remediate analog of audit's
- * `reconcileAdmissionLeases`. The host has now reported the granted set's results, so
- * those reservations are no longer in flight and their budget returns to the shared
- * account for the NEXT grant. Best-effort + token-checked (a missing/already-freed
- * lease is a no-op), so a lost reconcile self-heals via the lease TTL and never blocks
- * the merge. Only the host-subagent grant persists leases (`grantLeases: true`); the
- * in-process path leases per-packet in the engine and reconciles there.
- */
-async function reconcileAdmissionLeases(artifactsDir, runId) {
-    const quotaPath = join(runDir(artifactsDir, runId, "implement"), "dispatch-quota.json");
-    const quota = await readOptionalJsonFile(quotaPath);
-    const leases = quota?.admission?.leases;
-    if (!leases || leases.length === 0)
-        return;
-    const ledger = createReservationLedger();
-    for (const lease of leases) {
-        try {
-            await ledger.reconcile(lease.resource_key, lease.lease_id);
-        }
-        catch {
-            // Best-effort: the lease TTL reclaims budget if a reconcile is lost.
-        }
-    }
-}
-export async function mergeImplementResults(options, runId) {
-    // Free the grant's reservation-ledger leases now that the host has reported the
-    // granted set's results — returns the reserved budget for the next grant.
-    await reconcileAdmissionLeases(options.artifactsDir, runId);
-    const plan = await readJsonFile(dispatchPlanPath(options.artifactsDir, runId, "implement"));
-    if (plan.contract_version !== REMEDIATION_DISPATCH_PLAN_CONTRACT_VERSION ||
-        plan.phase !== "implement") {
-        throw new Error("Implement dispatch plan has an unsupported contract.");
-    }
-    const store = new StateStore(options.artifactsDir);
-    // OBL-INV-RSD-02 / OBL-SEAM-RSD-04: the entire read-modify-write of state.json
-    // is performed under a single held lock via StateStore.mutate, and committed
-    // exactly once after the full item loop. No partial state.json write happens
-    // mid-loop — a malformed/unknown finding_id no longer leaves a half-applied
-    // state (and never throws past the loop; see OBL-INV-RSD-01 below). Evidence
-    // artifacts (result_<id>_verify_code_against_documentation.json, the orphan
-    // diagnostic) are separate sidecar files, not state.json, so writing them
-    // inside the loop does not violate the single-state-commit invariant.
-    return store.mutate(async (loaded) => {
-        if (!loaded) {
-            throw new Error(`No remediation state found at ${join(options.artifactsDir, "state.json")}.`);
-        }
-        const state = loaded;
-        if (!state.items) {
-            throw new Error("Cannot merge implement results without items.");
-        }
-        return mergeImplementResultsIntoState(options, runId, plan, state);
-    });
-}
-/**
- * Apply every dispatched implement worker result to `state` (mutated in place)
- * and return it. Runs inside the StateStore.mutate lock so the caller commits
- * the result exactly once (OBL-INV-RSD-02 / OBL-SEAM-RSD-04). Pure with respect
- * to state.json: it mutates the in-memory `state` and writes only sidecar
- * evidence/diagnostic artifacts.
- */
-async function mergeImplementResultsIntoState(options, runId, plan, state) {
-    if (!state.items) {
-        throw new Error("Cannot merge implement results without items.");
-    }
-    const dir = runDir(options.artifactsDir, runId, "implement");
-    // Piece D — quota-paused strand set: block_ids stranded by a `quota_paused`
-    // partial-completion terminal (their worker rate-limited on a host session
-    // limit). Their result files are legitimately absent, but they are a RETRYABLE
-    // pause, NOT a failure — a later step redispatches them clean (worktrees were
-    // preserved). The merge must therefore LEAVE their items pending instead of
-    // marking them blocked on the missing result. Only the quota_paused reason is
-    // treated this way; `empty_pool` nodes are genuine failures and block as before.
-    const quotaPausedStrandedBlocks = state.partial_completion_terminal?.reason === "quota_paused"
-        ? new Set(state.partial_completion_terminal.stranded_ids)
-        : new Set();
-    // DC-5 verify gate: load the obligation_ledger + test_validator_plan once so a
-    // resolved finding that covers a behavior-CHANGE obligation can be re-blocked
-    // when its test specs are only one polarity (a positive without a scoped
-    // negative, or a negative-only set). Absent for non-contract-pipeline runs
-    // (audit-findings intake), where the gate is inert. Read defensively: the
-    // payloads are the validated artifact bodies, or `undefined` when missing.
-    const obligationLedgerPayload = (await readContractArtifact(options.artifactsDir, "obligation_ledger"))?.payload;
-    const testValidatorPlanPayload = (await readContractArtifact(options.artifactsDir, "test_validator_plan"))?.payload;
-    const plannedBlockIds = new Set(plan.items.map((item) => item.block_id).filter((id) => typeof id === "string"));
-    const itemsToMerge = [...plan.items];
-    for (const block of state.plan?.blocks ?? []) {
-        if (plannedBlockIds.has(block.block_id)) {
-            continue;
-        }
-        const hasDocumentedWork = block.items.some((findingId) => {
-            const stateItem = state.items?.[findingId];
-            return stateItem?.status === "pending";
-        });
-        if (!hasDocumentedWork) {
-            continue;
-        }
-        const item = buildImplementDispatchItem(block, state, dir);
-        const existingResult = await tryLoadExistingImplementResult(item.result_path);
-        const pendingFindingIds = pendingOrDocumentedFindingIdsForBlock(block, state);
-        if (!existingResult ||
-            !implementResultCoversFindings(existingResult, pendingFindingIds, block, state)) {
-            continue;
-        }
-        itemsToMerge.push(item);
-    }
-    // Build a lightweight ownership registry seeded from each block's declared
-    // write_paths so amended_files checks are correct even when no rolling-dispatch
-    // registry was persisted (interim path, until rollingDispatch replaces this).
-    const mergeRegistry = new OwnershipRegistry();
-    const dagNodes = itemsToMerge.flatMap((item) => {
-        if (!item.block_id || !item.access)
-            return [];
-        return [{ node_id: item.block_id, write_paths: item.access.write_paths }];
-    });
-    mergeRegistry.initialize(dagNodes);
-    // OBL-INV-RSD-01: a worker result whose finding_id is not in state.items is
-    // never silently dropped and never throws past the loop. Each such id is
-    // recorded here; if it belongs to a known block (via the result's owning
-    // task block_id) that block's non-terminal items are blocked, otherwise it is
-    // a true orphan recorded in the diagnostic artifact below. Either way the run
-    // cannot advance past an unaccounted result.
-    const orphanResults = [];
-    // Per-block ACTUAL edited file sets (resolved from each block's worktree
-    // branch), collected for post-loop lost-update / overlapping-edit detection
-    // (ARC-f378135d-2 / ARC-c1693139). Only blocks dispatched through an isolated
-    // worktree (their branch exists) contribute; the interim main-tree path has no
-    // per-worker diff to attribute, so it cannot be checked for cross-block overlap.
-    const editedByBlock = [];
-    for (const item of itemsToMerge) {
-        if (!existsSync(item.result_path)) {
-            // Piece D: a node stranded by a quota_paused terminal has no result file
-            // because its worker paused on a host session limit — leave its items
-            // PENDING so a later step (after the reset) redispatches them clean; never
-            // mark them blocked here.
-            if (item.block_id && quotaPausedStrandedBlocks.has(item.block_id)) {
-                continue;
-            }
-            console.warn(`Missing implement worker result: ${item.result_path} — marking items blocked.`);
-            const block = item.block_id
-                ? state.plan?.blocks.find((b) => b.block_id === item.block_id)
-                : undefined;
-            for (const findingId of block?.items ?? []) {
-                const stateItem = state.items[findingId];
-                // Don't flip a terminal item (resolved, or user-skipped
-                // deemed_inappropriate/ignored) to blocked — only items that were
-                // actually awaiting this worker's result.
-                if (!stateItem || isTerminalStatus(stateItem.status))
-                    continue;
-                stateItem.status = "blocked";
-                markTerminal(stateItem);
-                stateItem.failure_reason =
-                    `Implementation worker did not produce a result file: ${item.result_path}`;
-            }
-            continue;
-        }
-        const result = await readJsonFile(item.result_path);
-        assertImplementWorkerResult(result, item.result_path);
-        // Gate amended_files through the ownership registry (N-R22).
-        // Unowned amended paths are granted and added to this block's effective scope
-        // for verification; owned/contended paths block the item with a seam conflict.
-        const blockId = item.block_id ?? "";
-        if (result.amended_files && result.amended_files.length > 0) {
-            const { granted, seam_routed } = routeAmendmentRequest(mergeRegistry, blockId, result.amended_files);
-            if (granted.length > 0 && item.access) {
-                // Expand the block's effective write scope for downstream verification.
-                item.access.write_paths = uniquePaths([...item.access.write_paths, ...granted]);
-            }
-            if (seam_routed.length > 0) {
-                // Mark all non-terminal items in this block as blocked with seam conflict detail.
-                const block = state.plan?.blocks.find((b) => b.block_id === blockId);
-                for (const findingId of block?.items ?? []) {
-                    const stateItem = state.items[findingId];
-                    if (!stateItem || isTerminalStatus(stateItem.status))
-                        continue;
-                    stateItem.status = "blocked";
-                    markTerminal(stateItem);
-                    stateItem.failure_reason =
-                        `Seam conflict on amended_files: ${seam_routed
-                            .map((r) => {
-                            const reason = r.reason;
-                            if (reason.outcome === "owned") {
-                                return `${r.path} owned by ${reason.owner_node_id}`;
-                            }
-                            else if (reason.outcome === "contended") {
-                                return `${r.path} contended by ${reason.sibling_node_id}`;
-                            }
-                            return r.path;
-                        })
-                            .join("; ")}`;
-                }
-                // Release any grants we just made before moving on (best-effort cleanup).
-                mergeRegistry.releaseAmendments(blockId);
-                continue;
-            }
-        }
-        // Tolerant seam: remap an obligation/node-alias finding_id to the owning
-        // node's finding, and collapse multi-entry results onto one entry per
-        // finding (blocked dominates), before applying any status. A mislabel can
-        // only ever resolve to a finding that belongs to THIS block.
-        const owningBlock = blockId
-            ? state.plan?.blocks.find((b) => b.block_id === blockId)
-            : undefined;
-        const aliasMap = owningBlock
-            ? buildBlockAliasMap(owningBlock, state)
-            : new Map();
-        const knownFindingIds = new Set(Object.keys(state.items));
-        const { collapsed, unresolved } = collapseItemResults(result.item_results, aliasMap, knownFindingIds);
-        // Track which findings in this block this worker flipped to a resolved
-        // status, so the write-scope gate below can re-block them if the worker's
-        // ACTUAL git edits fall outside the declared scope.
-        const resolvedFindingIds = [];
-        // The recorded per-node accept outcome is the ground truth (never the worker's
-        // result file). Absent on the interim main-tree path (which writes none) → the
-        // gates below stay inert there. A HARD accept failure (outcome=error|timeout with
-        // merged=false) means the node's committed edits were QUARANTINED and are NOT in the
-        // main tree; the worker's own status is then untrustworthy (proven 2026-07-03: a
-        // node whose accept failed on a dirty-main-tree collision reported resolved_no_change
-        // and silently stranded, because the resolvedFindingIds gate below only re-blocks
-        // actual-change `resolved` items). When hard-failed, the collapsed loop's resolve
-        // branch blocks the item outright so no dependent builds on missing code.
-        const acceptOutcome = await loadNodeAcceptOutcome(options.artifactsDir, runId, blockId);
-        const acceptHardFailed = !!acceptOutcome &&
-            !acceptOutcome.merged &&
-            (acceptOutcome.outcome === "error" || acceptOutcome.outcome === "timeout");
-        // M-FRICTION (node_quarantine): a node that committed real edits but hard-failed
-        // the tool's verify/scope/merge had its work QUARANTINED under a durable ref and
-        // NOT landed — a backend-observed step-boundary fact the per-category friction walk
-        // must account for (recovery is a `reverify-node` re-drive). A hard-fail carries a
-        // captured `diagnostic` ONLY on the quarantine paths; a plain worker error/timeout
-        // that never committed sets none, so guarding on it excludes the non-quarantine
-        // failures. Routed through the single CE-005 chokepoint keyed on the node id (one
-        // event per node, deduped across its findings). Best-effort / non-fatal.
-        if (acceptHardFailed && acceptOutcome.diagnostic) {
-            await captureStepBoundaryFriction(options.artifactsDir, runId, {
-                eventType: "node_quarantine",
-                discriminator: blockId,
-                note: `Node ${blockId} committed edits but hard-failed the tool's verify/scope/merge ` +
-                    `(outcome=${acceptOutcome.outcome}); work quarantined and NOT landed — re-drive ` +
-                    `with \`remediate-code reverify-node --id ${blockId} --run-id ${runId}\` once the ` +
-                    `cause is fixed.`,
-                category: "bug",
-            }, "remediate-code");
-        }
-        for (const itemResult of unresolved) {
-            // OBL-INV-RSD-01: do NOT throw on an unknown finding_id that did not remap
-            // to a known node alias. Block the owning block's non-terminal items so the
-            // run cannot advance past an unaccounted result; record a diagnostic.
-            if (owningBlock) {
-                for (const findingId of owningBlock.items) {
-                    const owningItem = state.items[findingId];
-                    if (!owningItem || isTerminalStatus(owningItem.status))
-                        continue;
-                    owningItem.status = "blocked";
-                    markTerminal(owningItem);
-                    owningItem.failure_reason =
-                        `Implementation worker for block ${blockId} reported an unknown ` +
-                            `finding_id "${itemResult.finding_id}" not present in this plan ` +
-                            `(and not a known obligation/node alias of this block); blocking the ` +
-                            `block's items so the run does not advance past an unaccounted result.`;
-                }
-                orphanResults.push({
-                    finding_id: itemResult.finding_id,
-                    result_path: item.result_path,
-                    owning_block_id: blockId,
-                    disposition: "blocked_owning_block",
-                    worker_status: itemResult.status,
-                });
-            }
-            else {
-                orphanResults.push({
-                    finding_id: itemResult.finding_id,
-                    result_path: item.result_path,
-                    owning_block_id: null,
-                    disposition: "orphan",
-                    worker_status: itemResult.status,
-                });
-            }
-        }
-        for (const itemResult of collapsed) {
-            const stateItem = state.items[itemResult.finding_id];
-            if (!stateItem)
-                continue;
-            // A worker may report a finding that is already terminal (user-skipped, or
-            // resolved in a prior wave) — never let a result resurrect or overwrite it.
-            if (isTerminalStatus(stateItem.status)) {
-                continue;
-            }
-            if (itemResult.status === "resolved" || itemResult.status === "resolved_no_change") {
-                if (acceptHardFailed) {
-                    // The tool-owned accept hard-failed (quarantined, not in the main tree), so
-                    // this worker's resolved/resolved_no_change claim can't be trusted — block it
-                    // regardless of label so a mislabeled no-change can't strand and no dependent
-                    // builds on missing code. Routed to triage with the failing output.
-                    stateItem.status = "blocked";
-                    markTerminal(stateItem);
-                    stateItem.failure_reason =
-                        `Node ${blockId} reported finding ${itemResult.finding_id} ` +
-                            `${itemResult.status}, but its tool-owned accept failed ` +
-                            `(outcome=${acceptOutcome.outcome}, merged=false); the edits were quarantined ` +
-                            `and are NOT in the main tree. Routed to triage so dependents never build on ` +
-                            `missing code.` +
-                            (acceptOutcome.diagnostic
-                                ? `\nFailing command output:\n${acceptOutcome.diagnostic}`
-                                : "");
-                    continue;
-                }
-                const spec = stateItem.item_spec;
-                // The worker's explicit `resolved_no_change` is a no-change signal in its
-                // own right; the spec heuristic is the fallback for a plain `resolved`.
-                const isNoChange = itemResult.status === "resolved_no_change" || specIndicatesNoChange(spec);
-                // DC-5 verify gate: an actual-change closure for a finding that covers a
-                // behavior-CHANGE obligation must have a paired positive+scoped-negative
-                // test spec; only-one-polarity (or an unscoped repo-wide negative) is
-                // blocked, never silently resolved. The same single-source pairing/scoping
-                // evaluation the test-plan derivation gate uses. A no-change closure makes
-                // no edits, so it is exempt (the closure path above already proves it).
-                const pairingBlockReason = isNoChange
-                    ? null
-                    : verifyPairingForFinding(obligationIdsForFinding(state, itemResult.finding_id), obligationLedgerPayload, testValidatorPlanPayload);
-                if (isNoChange && !hasExecutableEvidence(itemResult.evidence)) {
-                    // No-prose closure: a "verified-already-satisfied" (no-change) claim must
-                    // be backed by an executable assertion (a test/build/check command +
-                    // result), not prose — otherwise a real requirement silently no-ops.
-                    // Route an unproven no-change claim to triage instead of closing it.
-                    stateItem.status = "blocked";
-                    markTerminal(stateItem);
-                    stateItem.failure_reason =
-                        "verified-already-satisfied requires an executable regression test proving " +
-                            "the behavior (a test/build/check command + result in evidence), not prose.";
-                }
-                else if (pairingBlockReason) {
-                    stateItem.status = "blocked";
-                    markTerminal(stateItem);
-                    stateItem.failure_reason = pairingBlockReason;
-                }
-                else {
-                    stateItem.status = isNoChange ? "resolved_no_change" : "resolved";
-                    markTerminal(stateItem);
-                    // A no-change closure makes no edits, so it is exempt from the
-                    // git-diff write-scope gate; an actual fix is subject to it.
-                    if (!isNoChange) {
-                        resolvedFindingIds.push(itemResult.finding_id);
-                    }
-                    else {
-                        // M-FRICTION (no_change_merge): a resolved_no_change node merged with
-                        // no diff is a backend-observed step-boundary fact. Route it through
-                        // the single CE-005 chokepoint with the pinned discriminator
-                        // (node/block id + finding id) so the de-dup id is collision-free and
-                        // re-recording the same fact is a guaranteed no-op (CE-006). Best-effort
-                        // and non-fatal — capture never throws into the merge loop.
-                        await captureStepBoundaryFriction(options.artifactsDir, runId, {
-                            eventType: "no_change_merge",
-                            discriminator: `${blockId}:${itemResult.finding_id}`,
-                            note: `Node ${blockId} merged finding ${itemResult.finding_id} as ` +
-                                `resolved_no_change (no diff landed).`,
-                            category: "trap",
-                        }, "remediate-code");
-                    }
-                    // OBL-INV-RSD-06 / OBL-SEAM-RSD-03: use the shared REMEDIATION_STEP
-                    // constant, never the bare string literal, so this path and any other
-                    // verify-against-documentation writer agree on one source of truth.
-                    stateItem.last_successful_step =
-                        REMEDIATION_STEP.VERIFY_AGAINST_DOCUMENTATION;
-                    if (itemResult.evidence?.length) {
-                        await writeJsonFile(join(options.artifactsDir, `result_${itemResult.finding_id}_verify_code_against_documentation.json`), {
-                            finding_id: itemResult.finding_id,
-                            passed: true,
-                            reason: itemResult.evidence,
-                        });
-                    }
-                }
-            }
-            else if (itemResult.status === "needs_clarification") {
-                // Mid-run escape hatch (note 3, part B): the worker hit scoping/judgment
-                // ambiguity. Route it to a clarification round (a real user question), not
-                // to triage's retry/ignore/halt. NOT terminal — the answer re-opens it.
-                stateItem.status = "needs_clarification";
-                const question = itemResult.clarification_question ??
-                    itemResult.failure_reason ??
-                    "The worker reported unresolved scoping/judgment ambiguity.";
-                stateItem.failure_reason = question;
-                const category = isClarificationCategory(itemResult.clarification_category)
-                    ? itemResult.clarification_category
-                    : "scope_of_fix";
-                const clarifications = state.clarifications ?? [];
-                if (!clarifications.some((c) => c.finding_id === itemResult.finding_id)) {
-                    clarifications.push({
-                        finding_id: itemResult.finding_id,
-                        category,
-                        description: question,
-                    });
-                }
-                state.clarifications = clarifications;
-                // The run is paused for the batched clarification round at the single
-                // post-loop status decision below (a needs_clarification item outranks
-                // implementing/triage), so the answer is applied before any more work.
-            }
-            else {
-                stateItem.status = "blocked";
-                markTerminal(stateItem);
-                stateItem.failure_reason =
-                    itemResult.failure_reason ?? "Implementation worker blocked.";
-            }
-        }
-        // E2 convergence: a worker may silently OMIT an assigned finding (return no
-        // item_results entry for it) — distinct from reporting it blocked or returning
-        // an unknown id (both handled above). The collapsed loop leaves an omitted
-        // finding untouched (still pending), so without accounting it re-dispatches
-        // forever. Bound it: count each omission and, at the cap, block the finding
-        // (→ triage) so a no-human run converges instead of looping (T2 termination).
-        if (owningBlock) {
-            const coveredFindingIds = new Set(collapsed.map((entry) => entry.finding_id));
-            for (const findingId of owningBlock.items) {
-                if (coveredFindingIds.has(findingId))
-                    continue;
-                const stateItem = state.items[findingId];
-                // Only a still-`pending` item is genuinely awaiting this worker's result;
-                // terminal / needs_clarification / in-flight states are not "omitted".
-                if (!stateItem || stateItem.status !== "pending")
-                    continue;
-                const attempts = (stateItem.incomplete_coverage_attempts ?? 0) + 1;
-                stateItem.incomplete_coverage_attempts = attempts;
-                if (attempts >= MAX_INCOMPLETE_COVERAGE_ATTEMPTS) {
-                    stateItem.status = "blocked";
-                    markTerminal(stateItem);
-                    stateItem.failure_reason =
-                        `Implementation worker for block ${blockId} omitted this finding from its ` +
-                            `item_results across ${attempts} dispatch(es) (no entry returned, neither ` +
-                            `resolved nor blocked); blocking to converge instead of re-dispatching indefinitely.`;
-                }
-            }
-        }
-        // Per-block ACTUAL worktree-branch edits, collected for the post-loop
-        // lost-update / overlapping-edit detection (a file edited by more than one
-        // merged block). The write-scope gate itself is NOT applied here: it runs at
-        // ACCEPT time (`acceptNodeWorktree` → `enforceAcceptWriteScope`), BEFORE the
-        // cherry-pick, so an out-of-scope edit is prevented from landing rather than
-        // reported once already merged — and a node it blocks reaches the merge as
-        // `merged:false`, routed to triage by the merge-state gate below (with the
-        // write-scope reason carried in its diagnostic). A missing branch means the
-        // interim main-tree path was used (no per-worker diff): nothing to collect.
-        const worktreeBranch = worktreeBranchForBlock(blockId, runId);
-        const branchEdited = gitBranchExists(options.root, worktreeBranch)
-            ? gitEditedFilesForBranch(options.root, worktreeBranch)
-            : null;
-        if (branchEdited?.available) {
-            // Resolve the block's ACTUAL edited hunks too, so overlap detection can
-            // spare same-file blocks whose real line-ranges are disjoint. Unavailable
-            // hunks fail closed inside detectOverlappingEdits (still flagged).
-            const branchHunks = gitHunksForBranch(options.root, worktreeBranch);
-            editedByBlock.push({
-                block_id: blockId,
-                files: branchEdited.files,
-                hunks: branchHunks,
-            });
-        }
-        // Merge-state gate (authoritative, OBL-DS-06): a node that self-reported a
-        // finding "resolved" but whose tool-owned verify/merge did NOT land its edits
-        // (acceptNodeWorktree returned merged:false — verify failed, a cherry-pick
-        // conflict, or no actual edit) must never stand as resolved: its fix is not in
-        // the main tree. Keyed on resolvedFindingIds, so a legitimate no-change closure
-        // (which makes no edits by design, and is not in that set) stays exempt. This
-        // covers the outcome=success/merged:false case (worker reported an actual-change
-        // "resolved" but committed nothing); the hard-failure case (outcome=error|timeout)
-        // is caught earlier, in the collapsed loop's resolve branch, so a mislabeled
-        // `resolved_no_change` can't slip past this resolvedFindingIds keying.
-        if (resolvedFindingIds.length > 0) {
-            if (acceptOutcome && !acceptOutcome.merged) {
-                for (const findingId of resolvedFindingIds) {
-                    const stateItem = state.items[findingId];
-                    if (!stateItem || isTerminalStatus(stateItem.status))
-                        continue;
-                    stateItem.status = "blocked";
-                    markTerminal(stateItem);
-                    stateItem.failure_reason =
-                        `Node ${blockId} reported finding ${findingId} resolved, but its tool-owned ` +
-                            `verify/merge did not land the edits (outcome=${acceptOutcome.outcome}, ` +
-                            `verify_passed=${acceptOutcome.verifyPassed}, merged=false); the fix is not in ` +
-                            `the main tree. Routed to triage.` +
-                            (acceptOutcome.diagnostic
-                                ? `\nFailing command output:\n${acceptOutcome.diagnostic}`
-                                : "");
-                }
-            }
-        }
-        // Release this block's amendment claims after it has been merged or blocked.
-        mergeRegistry.releaseAmendments(blockId);
-    }
-    // OBL-INV-RSD-01: persist a deterministic diagnostic for every unmatched
-    // worker result so an orphan is auditable and never silently dropped. This is
-    // a sidecar artifact (not state.json), so it does not affect the single
-    // state-commit invariant (RSD-02).
-    if (orphanResults.length > 0) {
-        await writeJsonFile(join(dir, "orphaned-implement-results.json"), {
-            schema_version: "remediate-code-implement/orphaned-results/v1alpha1",
-            run_id: runId,
-            created_at: new Date().toISOString(),
-            orphans: orphanResults,
-        });
-        process.stderr.write(`[remediate-code] dispatch: ${orphanResults.length} unmatched implement ` +
-            `result finding_id(s) recorded as orphan dispositions (not dropped): ` +
-            `${orphanResults.map((o) => o.finding_id).join(", ")}\n`);
-        // M-FRICTION (artifact_rejected): each unmatched worker result is an artifact
-        // rejected from the merge (referential-integrity reject). Route each through
-        // the single CE-005 chokepoint with the pinned discriminator (artifact id +
-        // cause token = the orphan disposition) so the de-dup id is collision-free
-        // (CE-006). Best-effort / non-fatal — capture never throws into the merge.
-        for (const orphan of orphanResults) {
-            await captureStepBoundaryFriction(options.artifactsDir, runId, {
-                eventType: "artifact_rejected",
-                discriminator: `${orphan.finding_id}:${orphan.disposition}`,
-                note: `Implement worker result for finding ${orphan.finding_id} was rejected ` +
-                    `from the merge (disposition=${orphan.disposition}, ` +
-                    `worker_status=${orphan.worker_status}).`,
-                category: "trap",
-            }, "remediate-code");
-        }
-    }
-    // Lost-update / overlapping-edit detection (ARC-f378135d-2 / ARC-c1693139):
-    // when the rolling engine had multiple nodes in flight, two workers can each
-    // edit the SAME file in their own worktree; cherry-picking both would silently
-    // drop one change. Any file edited by more than one merged block is a
-    // lost-update hazard — block every involved block's still-non-terminal items
-    // and route them to triage so the conflict is reconciled, never lost. Recorded
-    // as a sidecar diagnostic. Single-block runs (the proven host-wave path)
-    // produce zero overlaps, so this is inert on the current default path.
-    const overlappingEdits = detectOverlappingEdits(editedByBlock);
-    if (overlappingEdits.length > 0) {
-        const involvedBlockIds = new Set(overlappingEdits.flatMap((o) => o.block_ids));
-        for (const blockId of involvedBlockIds) {
-            const block = state.plan?.blocks.find((b) => b.block_id === blockId);
-            const conflictPaths = overlappingEdits
-                .filter((o) => o.block_ids.includes(blockId))
-                .map((o) => o.path);
-            for (const findingId of block?.items ?? []) {
-                const stateItem = state.items[findingId];
-                if (!stateItem || isTerminalStatus(stateItem.status))
-                    continue;
-                stateItem.status = "blocked";
-                markTerminal(stateItem);
-                stateItem.failure_reason =
-                    `Lost-update hazard: this block's worker edited file(s) also edited by ` +
-                        `another concurrently-dispatched block (${conflictPaths.join(", ")}). ` +
-                        `Blocking both so the overlapping change is reconciled in triage rather ` +
-                        `than silently dropped by a cherry-pick.`;
-            }
-        }
-        await writeJsonFile(join(dir, "overlapping-edits.json"), {
-            schema_version: "remediate-code-implement/overlapping-edits/v1alpha1",
-            run_id: runId,
-            created_at: new Date().toISOString(),
-            overlaps: overlappingEdits,
-        });
-        process.stderr.write(`[remediate-code] dispatch: ${overlappingEdits.length} overlapping-edit ` +
-            `conflict(s) across concurrently-merged blocks; involved blocks routed to ` +
-            `triage: ${[...involvedBlockIds].join(", ")}\n`);
-    }
-    // Re-baseline affected-file hashes: the implement phase legitimately rewrites
-    // these files, so a later integrity check must not flag the run's own edits as
-    // a stale plan when re-attempting any remaining blocked findings.
-    if (state.plan?.findings?.length) {
-        resnapshotAffectedFileHashes(options.root, state.plan.findings);
-    }
-    // Per-node dispositions (INV-DS-15). One disposition per merged block/node; a
-    // SKIP disposition is never reported as verified_complete. This is a sidecar
-    // artifact (not state.json).
-    const mergedBlocks = itemsToMerge.flatMap((item) => {
-        if (!item.block_id)
-            return [];
-        const block = state.plan?.blocks.find((b) => b.block_id === item.block_id);
-        return block ? [{ block, item }] : [];
-    });
-    const dispositions = mergedBlocks.map(({ block }) => buildNodeDisposition(block, state));
-    // Sibling-red routing (INV-DS-14). For each merged block that ended red
-    // (blocked), attribute the failure against the OTHER merged blocks' write
-    // scopes: an attributable red (exactly one sibling owns the implicated
-    // surface) routes that sibling to triage; an unattributable red is deferred to
-    // the rolling-scheduler's coarse backstop. The state already advances to
-    // triage below; this records the attribution decision deterministically.
-    const siblingRedRoutes = [];
-    for (const { block, item } of mergedBlocks) {
-        const disposition = dispositions.find((d) => d.block_id === block.block_id);
-        if (!disposition || disposition.disposition !== "blocked")
-            continue;
-        // The files implicated by this red node = its declared write scope.
-        const implicatedFiles = item.access?.write_paths ?? [];
-        const siblingScopes = mergedBlocks
-            .filter((m) => m.block.block_id !== block.block_id)
-            .map((m) => ({
-            block_id: m.block.block_id,
-            write_paths: m.item.access?.write_paths ?? [],
-        }));
-        const attributed = attributeSiblingRed(implicatedFiles, siblingScopes, options.root);
-        siblingRedRoutes.push({
-            red_block_id: block.block_id,
-            implicated_files: implicatedFiles.map((p) => toRepoRelative(p, options.root)),
-            routed_to_triage_block_id: attributed,
-            backstop: attributed ? null : "rolling_scheduler_coarse",
-        });
-    }
-    if (dispositions.length > 0) {
-        await writeJsonFile(join(dir, "node-dispositions.json"), {
-            schema_version: "remediate-code-implement/node-dispositions/v1alpha1",
-            run_id: runId,
-            created_at: new Date().toISOString(),
-            dispositions,
-            sibling_red_routes: siblingRedRoutes,
-        });
-    }
-    const mergedFindingIds = new Set(itemsToMerge.flatMap((item) => {
-        if (!item.block_id)
-            return [];
-        const block = state.plan?.blocks.find((b) => b.block_id === item.block_id);
-        return block?.items ?? [];
-    }));
-    let implementResolved = 0;
-    let implementRejected = 0;
-    for (const findingId of mergedFindingIds) {
-        const status = state.items[findingId]?.status;
-        if (isVerifiedCompleteStatus(status))
-            implementResolved++;
-        else if (status === "blocked")
-            implementRejected++;
-    }
-    process.stderr.write(`[remediate-code] dispatch: merged ${implementResolved} implement result(s), ` +
-        `${implementRejected} rejected\n`);
-    // A worker that reported needs_clarification (note 3, part B) outranks both
-    // implementing and triage: pause the run for the batched clarification round so
-    // the user's answer is applied before any more work is dispatched or triaged.
-    // Otherwise route back to implementing while pending work remains (later
-    // dependency waves, or blocks deferred this wave because a prerequisite was
-    // still running); else advance to triage.
-    const needsClarification = Object.values(state.items).some((it) => it.status === "needs_clarification");
-    const moreToImplement = Object.values(state.items).some((it) => it.status === "pending");
-    state.status = needsClarification
-        ? "waiting_for_clarification"
-        : moreToImplement
-            ? "implementing"
-            : "triage";
-    // Single commit: StateStore.mutate writes the returned state once, under the
-    // lock it already holds (OBL-INV-RSD-02 / OBL-SEAM-RSD-04). No saveState here.
-    return state;
-}
-export async function readExtractedPlanIfPresent(artifactsDir) {
-    return readOptionalJsonFile(join(artifactsDir, "extracted-plan.json"));
-}
-export async function readDispatchPlan(artifactsDir, runId, phase) {
-    return readJsonFile(dispatchPlanPath(artifactsDir, runId, phase));
-}
+// dispatch.ts — thin barrel
+//
+// The implementation was split into cohesive sibling modules under
+// `./dispatch/` (CP-NODE-7). This file re-exports the EXACT original public
+// surface so every consumer that imports from `steps/dispatch.js` keeps working
+// unchanged. New code may import directly from the submodules; the barrel is the
+// backwards-compatible aggregate.
+// ---------------------------------------------------------------------------
+export { gitTopLevel, worktreeBranchForBlock, gitEditedFilesForBranch, gitHunksForBranch, parseUnifiedDiffHunks, writeScopeViolations, detectRepoConventionsCache, } from "./dispatch/common.js";
+export { resolveHostActiveSubagentLimit, detectHostConcurrencyFromEnv, normalizeSlotTokens, resolveHostConcurrencyLimit, scheduleWave, buildConfirmedPools, buildDispatchQuota, } from "./dispatch/waveScheduling.js";
+export { createWorktree, seedUntrackedDeclaredPaths, removeWorktree, resetNodeWorktreeAndBranch, verifyNodeInWorktree, mergeWorktree, dirtyMainTreeCollisions, rebaseBranchOntoHead, worktreePath, remediationBranchName, baseBranchLockPath, quarantineRef, quarantineFailedNodeCommit, quarantineUncommittedWorktreeEdits, clearQuarantinedCommit, listQuarantinedCommits, remediationBaseBranchPath, readRemediationBaseBranch, ensureRemediationBranchCheckedOut, commitWorktree, ensureWorktreeNodeModules, } from "./dispatch/worktreeLifecycle.js";
+export { acceptNodeWorktree, nodeAcceptOutcomePath, recordNodeAcceptOutcome, loadNodeAcceptOutcome, executeNodeInWorktree, } from "./dispatch/acceptNode.js";
+// --- verify commands ---
+export { isBuildFreeVerifyCommand, normalizeNodeTestCommand, isWholeSuiteTestCommand, pathTokensInCommand, selfContainedVerifyCommands, verifyCommandsForEdits, deriveVerifyCommandsFromBranch, targetedCommandsForBlock, } from "./dispatch/verifyCommands.js";
+export { buildImplementModelHint, implementResultPath, isInfraModifyingBlock, buildTestFileIndex, collectReferencingTests, } from "./dispatch/implementPrompt.js";
+export { enforceWriteScope, blockScopesFromPlan, declaredPathsFromPlan, adjudicateWriteScope, enforceAcceptWriteScope, buildBlockAliasMap, collapseItemResults, buildNodeDisposition, attributeSiblingRed, detectOverlappingEdits, } from "./dispatch/writeScope.js";
+// --- marshalling (prepare / merge / readers) ---
+export { prepareImplementDispatch, mergeImplementResults, readExtractedPlanIfPresent, readDispatchPlan, } from "./dispatch/marshal.js";
 //# sourceMappingURL=dispatch.js.map