audit-tools 0.32.20 → 0.32.22

package/dist/audit/types/systemicChallenge.d.ts

@@ -0,0 +1,69 @@
+import type { Finding } from "../types.js";
+import type { Ceiling } from "audit-tools/shared";
+import type { AggregateMetricsDigest } from "../systemic/metricsDigestTypes.js";
+/**
+ * The `systemic_challenge.json` artifact — Phase E of the conceptual design-review:
+ * the SYSTEMIC IMPROVEMENT-SEEKING CHALLENGE LOOP. A second-order adversary (a
+ * SEPARATE agent — [[delegate-adversarial-phases-to-separate-agent]]) re-interrogates
+ * the whole system with human-grade pressure and folds newly-surfaced improvements
+ * back in, LOOP-UNTIL-DRY: the pass is done only when a challenge round yields
+ * NOTHING NEW, not when it first has an answer (design of record
+ * spec/conceptual-design-review-design.md §"Convergence (loop-until-dry)"; backlog
+ * "Systemic reviewers must be pushed adversarially for improvement").
+ *
+ * The mandate is OPTIMIZATION / BETTER-WAY, not only defect-finding: the pass
+ * actively seeks superior alternatives to things that currently WORK — the class no
+ * correctness lens flags because nothing is broken (redundant, serial-that-could-be-
+ * parallel, duplicated, over-built, an unquestioned assumption, a categorically
+ * better approach).
+ *
+ * It is an OUTPUT artifact seeded from the intent checkpoint (ceiling) and the whole
+ * upstream picture (repo_manifest / structure_decomposition / charter register).
+ * `status:"omitted"` when the ceiling did not request the systemic layer (shallow —
+ * the default), so the obligation is satisfied without a host turn.
+ *
+ * Each host-delegation round appends to `rounds`; a round that returns zero new
+ * findings sets `converged:true` and terminates the loop. `findings` are every
+ * distinct improvement surfaced across rounds — carrying their TRUE lens (a
+ * test-parallelization finding is `tests`/`performance`, an ops finding is
+ * `operability`), NEVER a hardcoded `architecture` tag.
+ */
+export interface SystemicChallengeRound {
+    /** 1-based round ordinal (the Nth loop-until-dry challenge). */
+    round: number;
+    /** Distinct finding ids this round surfaced that no prior round had. */
+    new_finding_ids: string[];
+    /** Whether this round yielded nothing new (the loop-until-dry terminator). */
+    dry: boolean;
+}
+export interface SystemicChallengeRegister {
+    generated_at: string;
+    /** The decomposition target — `"systemic_challenge"` at this layer. */
+    target: "systemic_challenge";
+    /**
+     * The ceiling authorized at `intent_checkpoint` — echoed so the register is
+     * self-describing about the depth that produced it.
+     */
+    ceiling: Ceiling;
+    /**
+     * `"omitted"` when the ceiling did not request the systemic layer (shallow — the
+     * default) — the register is written empty so the obligation is satisfied without
+     * a host turn (mirrors the charter-extraction / clarification omit).
+     */
+    status?: "omitted";
+    /**
+     * The language-neutral aggregate-metrics digest fed to the adversary as NECESSARY
+     * supporting evidence — explicitly NOT sufficient alone (the adversary reasons
+     * from the whole picture, not the counts). Absent on an omitted register.
+     */
+    metrics?: AggregateMetricsDigest;
+    /** The loop-until-dry challenge rounds, in order; the last one is `dry`. */
+    rounds: SystemicChallengeRound[];
+    /** True once a challenge round surfaced nothing new (the loop terminated). */
+    converged: boolean;
+    /** Every distinct improvement finding surfaced, carrying its TRUE lens. */
+    findings: Finding[];
+    /** Gate/assembly notes (e.g. a round dropped an ungrounded finding) — surfaced. */
+    validation_issues: string[];
+}
+//# sourceMappingURL=systemicChallenge.d.ts.map

package/dist/audit/types/systemicChallenge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemicChallenge.d.ts","sourceRoot":"","sources":["../../../src/audit/types/systemicChallenge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,sBAAsB;IACrC,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,8EAA8E;IAC9E,GAAG,EAAE,OAAO,CAAC;CACd;AAED,MAAM,WAAW,yBAAyB;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,MAAM,EAAE,oBAAoB,CAAC;IAC7B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,4EAA4E;IAC5E,MAAM,EAAE,sBAAsB,EAAE,CAAC;IACjC,8EAA8E;IAC9E,SAAS,EAAE,OAAO,CAAC;IACnB,2EAA2E;IAC3E,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,mFAAmF;IACnF,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B"}

package/dist/audit/types/systemicChallenge.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=systemicChallenge.js.map

package/dist/audit/types/systemicChallenge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemicChallenge.js","sourceRoot":"","sources":["../../../src/audit/types/systemicChallenge.ts"],"names":[],"mappings":""}

package/dist/remediate/steps/dispatch/acceptNode.d.ts

@@ -0,0 +1,178 @@
+import type { RemediationBlock } from "../../state/types.js";
+import type { ProviderSlot, RollingDispatchResult } from "audit-tools/shared";
+/** Worker transport outcome (mirrors shared `RollingDispatchResult["outcome"]`). */
+export type NodeWorkerOutcome = "success" | "error" | "rate_limited" | "timeout";
+export interface AcceptNodeWorktreeParams {
+    root: string;
+    runId: string;
+    blockId: string;
+    /** The node's isolated worktree directory. */
+    worktreeRoot: string;
+    /** The node's worktree branch (`worktreeBranchForBlock`). */
+    branch: string;
+    /** The worker's transport outcome from the node dispatcher. */
+    workerOutcome: NodeWorkerOutcome;
+    /**
+     * Per-node verify commands. OMIT (leave `undefined`) for the real rolling drivers:
+     * the gate then DERIVES the verify from the node's actually-touched test files
+     * post-commit ({@link deriveVerifyCommandsFromBranch}) — correct paths/runner by
+     * construction, never the whole suite. Pass `[]` to skip the gate (lifecycle unit
+     * tests on a minimal temp repo), or an explicit list to force specific commands.
+     */
+    targetedCommands?: string[];
+    /**
+     * The node's own `targeted_commands` (the auditor/finding-specified verification),
+     * run IN ADDITION to the derived commands — filtered to the build-free subset and
+     * deduped against the derive. The derive gives correct-paths-by-construction; these
+     * add the fix-specific regression checks the derive misses when a fix touches no test
+     * (task_7d35176d). Omit / `[]` → derive-only (the prior behaviour). Ignored when
+     * `targetedCommands` is an explicit override (the lifecycle unit-test path).
+     */
+    additionalVerifyCommands?: string[];
+    /**
+     * Accept-time write-scope inputs (OBL-DS-06). The write-scope gate runs HERE —
+     * after the verify, BEFORE the cherry-pick — so an out-of-scope or seam-conflicting
+     * edit is PREVENTED from landing in the main tree rather than reported post-hoc once
+     * it is already merged. REQUIRED (not optional): both rolling drivers always derive
+     * it from the plan, so a production caller can never silently skip the gate — that
+     * enforcement is the type, not host discretion (E1). A lifecycle test that does not
+     * exercise scope passes `{ allBlockScopes: [] }`: an empty registry owns nothing, so
+     * every edit is unowned-and-granted → the gate is a sound no-op, never a skip.
+     */
+    scope: {
+        /** Every block's declared write scope, for amendment ownership adjudication. */
+        allBlockScopes: Array<{
+            block_id: string;
+            write_paths: string[];
+        }>;
+    };
+    /**
+     * The block's OWN declared write paths (INV-1). Threaded into `commitWorktree`
+     * so worker-created new SOURCE files under scope are force-added past
+     * `.gitignore` and a generated-artifact / out-of-scope new file fails loudly.
+     * Omit (lifecycle unit tests with no scope) → no new-file inclusion.
+     */
+    writePaths?: string[];
+    /**
+     * The cross-package check command (argv) run in the MAIN checkout AFTER the
+     * cherry-pick lands (INV-2): a RED check rolls the base back to its captured HEAD
+     * OID. When omitted, the command is PINNED — derived from the repo via
+     * `mergedBaseCheckArgv` (the `check`-layer of the tool-owned gate set), not a
+     * hardcoded string — and skipped (`null`) on a non-monorepo target. Tests inject a
+     * deterministic pass/fail argv (a `t.mock.module` seam is unusable under tsx/esm).
+     * Pass `null` to skip the merged-base check entirely (legacy lifecycle unit tests
+     * on a minimal repo with no check script).
+     */
+    mergedBaseCheckCommand?: string[] | null;
+}
+export interface AcceptNodeWorktreeResult {
+    /** The LIFECYCLE outcome (verify/merge applied), distinct from the worker transport outcome. */
+    outcome: NodeWorkerOutcome;
+    verifyPassed: boolean;
+    merged: boolean;
+    /**
+     * On a failure outcome, the captured failing command + its output — the verify
+     * stdout/stderr (`$ <cmd>\n<output>`), or the git commit / cherry-pick error text.
+     * Persisted into the accept-outcome sidecar so triage can see the root cause
+     * instead of an `outcome:error` with no captured stderr. Absent on success.
+     */
+    diagnostic?: string;
+}
+/**
+ * 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 declare function acceptNodeWorktree(params: AcceptNodeWorktreeParams): Promise<AcceptNodeWorktreeResult>;
+/**
+ * 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 declare function nodeAcceptOutcomePath(artifactsDir: string, runId: string, blockId: string): string;
+/**
+ * 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 declare function recordNodeAcceptOutcome(artifactsDir: string, runId: string, blockId: string, result: AcceptNodeWorktreeResult): Promise<void>;
+/** Load a node's recorded accept outcome, or null when none was written. */
+export declare function loadNodeAcceptOutcome(artifactsDir: string, runId: string, blockId: string): Promise<AcceptNodeWorktreeResult | null>;
+/**
+ * The per-node worktree worker an in-process driver launches: it edits within the
+ * node's isolated worktree (cwd-confined), writes its result file, and returns the
+ * transport outcome. `makeProviderNodeDispatcher` is the live implementation; tests
+ * inject a stub. Structurally identical to `nextStep`'s `ProgrammaticNodeDispatcher`.
+ */
+export type WorktreeNodeWorker = (args: {
+    block: RemediationBlock;
+    slot: ProviderSlot;
+    worktreeRoot: string;
+    resultPath: string;
+}) => Promise<RollingDispatchResult<{
+    block_id: string;
+}>>;
+/** One node's worktree-lifecycle result: the worker transport outcome + the accept lifecycle. */
+export interface NodeWorktreeExecution {
+    /** Worker transport outcome the rolling engine consumes (success/error/rate_limited/timeout). */
+    result: RollingDispatchResult<{
+        block_id: string;
+    }>;
+    /** Tool-owned accept outcome (commit→verify→merge), already persisted via recordNodeAcceptOutcome. */
+    accept: AcceptNodeWorktreeResult;
+}
+/**
+ * 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 declare function executeNodeInWorktree(args: {
+    block: RemediationBlock;
+    slot: ProviderSlot;
+    root: string;
+    artifactsDir: string;
+    runId: string;
+    resultPath: string;
+    /** Untracked declared targets to seed into the worktree (the node's write set or write∪read). */
+    seedPaths: string[];
+    /** Every block's declared write scope, for the accept-time write-scope gate (OBL-DS-06). */
+    allBlockScopes: Array<{
+        block_id: string;
+        write_paths: string[];
+    }>;
+    /** The node's own targeted_commands, run IN ADDITION to the derived verify (task_7d35176d). */
+    additionalVerifyCommands?: string[];
+    dispatchNode: WorktreeNodeWorker;
+}): Promise<NodeWorktreeExecution>;
+//# sourceMappingURL=acceptNode.d.ts.map

package/dist/remediate/steps/dispatch/acceptNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptNode.d.ts","sourceRoot":"","sources":["../../../../src/remediate/steps/dispatch/acceptNode.ts"],"names":[],"mappings":"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"}

package/dist/remediate/steps/dispatch/acceptNode.js

@@ -0,0 +1,351 @@
+import { join } from "node:path";
+import { spawnSyncHidden } from "audit-tools/shared";
+import { withFileLock } from "audit-tools/shared";
+import { runCommand } from "../../utils/commands.js";
+import { mergedBaseCheckArgv } from "../gateCommands.js";
+import { writeJsonFile, readOptionalJsonFile } from "audit-tools/shared";
+import { runDir, worktreeBranchForBlock, gitEditedFilesForBranch, } from "./common.js";
+import { removeWorktree, commitWorktree, quarantineUncommittedWorktreeEdits, quarantineFailedNodeCommit, clearQuarantinedCommit, rebaseBranchOntoHead, dirtyMainTreeCollisions, mergeWorktree, baseBranchLockPath, resetNodeWorktreeAndBranch, createWorktree, seedUntrackedDeclaredPaths, worktreePath, verifyNodeInWorktree, } from "./worktreeLifecycle.js";
+import { deriveVerifyCommandsFromBranch, selfContainedVerifyCommands, buildFreeVerifyCommands, } from "./verifyCommands.js";
+import { enforceAcceptWriteScope } from "./writeScope.js";
+/**
+ * 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,
+        };
+    }
+}
+//# sourceMappingURL=acceptNode.js.map

package/dist/remediate/steps/dispatch/acceptNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptNode.js","sourceRoot":"","sources":["../../../../src/remediate/steps/dispatch/acceptNode.ts"],"names":[],"mappings":"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"}