audit-tools 0.32.19 → 0.32.22

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":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAgB,aAAa,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAGvF,OAAO,EACL,MAAM,EACN,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,cAAc,EACd,cAAc,EACd,kCAAkC,EAClC,0BAA0B,EAC1B,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,EACvB,aAAa,EACb,kBAAkB,EAClB,0BAA0B,EAC1B,cAAc,EACd,0BAA0B,EAC1B,YAAY,EACZ,oBAAoB,GACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,EAC3B,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAgF1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,MAAgC;IAEhC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,GAAG,MAAM,CAAC;IAC7H,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,IAAI,MAAM,GAAG,KAAK,CAAC;IAEnB,IAAI,aAAa,KAAK,cAAc,EAAE,CAAC;QACrC,4EAA4E;QAC5E,+EAA+E;QAC/E,6EAA6E;QAC7E,gFAAgF;QAChF,8EAA8E;QAC9E,gDAAgD;QAChD,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IAC1D,CAAC;IAED,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;QAChC,+EAA+E;QAC/E,gFAAgF;QAChF,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACzB,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IAC1D,CAAC;IAED,MAAM,MAAM,GAAG,cAAc,CAAC,EAAE,EAAE,aAAa,OAAO,KAAK,KAAK,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;IACxF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,6EAA6E;QAC7E,6EAA6E;QAC7E,8EAA8E;QAC9E,+EAA+E;QAC/E,2EAA2E;QAC3E,qCAAqC;QACrC,kCAAkC,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QACrE,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACzB,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;IAC9E,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;QACtB,kFAAkF;QAClF,2FAA2F;QAC3F,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACzB,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IACtD,CAAC;IAED,qFAAqF;IACrF,qFAAqF;IACrF,sFAAsF;IACtF,4EAA4E;IAC5E,qFAAqF;IACrF,mFAAmF;IACnF,iFAAiF;IACjF,4EAA4E;IAC5E,OAAO,YAAY,CAAC,kBAAkB,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK,IAAI,EAAE;QAC9D,iFAAiF;QACjF,gFAAgF;QAChF,mFAAmF;QACnF,iFAAiF;QACjF,+EAA+E;QAC/E,mCAAmC;QACnC,MAAM,MAAM,GAAG,oBAAoB,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;QACtD,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;YACf,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;YACzD,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACzB,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;QAC9E,CAAC;QAED,6EAA6E;QAC7E,wEAAwE;QACxE,8EAA8E;QAC9E,4EAA4E;QAC5E,+EAA+E;QAC/E,8EAA8E;QAC9E,yDAAyD;QACzD,MAAM,UAAU,GAAG,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACzD,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1B,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;YACzD,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACzB,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3D,MAAM,EAAE,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;YACjD,OAAO;gBACL,OAAO,EAAE,OAAO;gBAChB,YAAY;gBACZ,MAAM;gBACN,UAAU,EACR,wCAAwC,KAAK,sBAAsB,EAAE,GAAG;oBACxE,uEAAuE;oBACvE,2EAA2E;oBAC3E,wEAAwE;aAC3E,CAAC;QACJ,CAAC;QAED,gFAAgF;QAChF,gFAAgF;QAChF,+EAA+E;QAC/E,sFAAsF;QACtF,mFAAmF;QACnF,mFAAmF;QACnF,6EAA6E;QAC7E,MAAM,YAAY,GAChB,gBAAgB,KAAK,SAAS;YAC5B,CAAC,CAAC,8BAA8B,CAAC,IAAI,EAAE,MAAM,CAAC;YAC9C,CAAC,CAAC,gBAAgB,CAAC;QACvB,IAAI,cAAwB,CAAC;QAC7B,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACnC,+EAA+E;YAC/E,iFAAiF;YACjF,kFAAkF;YAClF,iFAAiF;YACjF,+EAA+E;YAC/E,0EAA0E;YAC1E,MAAM,MAAM,GAAG,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YACrD,MAAM,QAAQ,GAAG;gBACf,GAAG,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC;gBAC5B,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;aAC1C,CAAC;YACF,MAAM,UAAU,GAAG,2BAA2B,CAC5C,uBAAuB,CAAC,wBAAwB,CAAC,EACjD,QAAQ,EACR,EAAE,CACH,CAAC;YACF,cAAc,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,YAAY,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAClE,CAAC;aAAM,CAAC;YACN,cAAc,GAAG,YAAY,CAAC;QAChC,CAAC;QACD,MAAM,MAAM,GACV,cAAc,CAAC,MAAM,GAAG,CAAC;YACvB,CAAC,CAAC,oBAAoB,CAAC,EAAE,EAAE,cAAc,CAAC;YAC1C,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;QACnC,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACnB,+EAA+E;YAC/E,8EAA8E;YAC9E,6EAA6E;YAC7E,4EAA4E;YAC5E,2DAA2D;YAC3D,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;YACzD,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACzB,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;QAC/E,CAAC;QAED,2EAA2E;QAC3E,+EAA+E;QAC/E,6EAA6E;QAC7E,6EAA6E;QAC7E,8EAA8E;QAC9E,4EAA4E;QAC5E,mCAAmC;QACnC,MAAM,QAAQ,GAAG,uBAAuB,CAAC;YACvC,IAAI;YACJ,MAAM;YACN,OAAO;YACP,cAAc,EAAE,MAAM,CAAC,KAAK,CAAC,cAAc;SAC5C,CAAC,CAAC;QACH,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;YACrB,6EAA6E;YAC7E,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;YACzD,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACzB,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC;QACxF,CAAC;QAED,kFAAkF;QAClF,+CAA+C;QAC/C,MAAM,cAAc,GAAG,eAAe,CAAC,KAAK,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE;YACnE,GAAG,EAAE,IAAI;YACT,QAAQ,EAAE,MAAM;YAChB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;QACH,IAAI,cAAc,CAAC,KAAK,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxD,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;YACzD,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACzB,OAAO;gBACL,OAAO,EAAE,OAAO;gBAChB,YAAY;gBACZ,MAAM;gBACN,UAAU,EAAE,6CACV,CAAC,cAAc,CAAC,MAAM,IAAI,cAAc,CAAC,KAAK,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,IAAI,EAChF,EAAE;aACH,CAAC;QACJ,CAAC;QACD,MAAM,OAAO,GAAG,cAAc,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAE7C,8EAA8E;QAC9E,+EAA+E;QAC/E,MAAM,QAAQ,GAAG,aAAa,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;QACjD,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC;QAC1B,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;YACtB,sFAAsF;YACtF,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;YACzD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;QAChF,CAAC;QAED,gFAAgF;QAChF,kFAAkF;QAClF,kFAAkF;QAClF,mFAAmF;QACnF,mFAAmF;QACnF,qFAAqF;QACrF,MAAM,SAAS,GACb,MAAM,CAAC,sBAAsB,KAAK,SAAS;YACzC,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC;YAC3B,CAAC,CAAC,MAAM,CAAC,sBAAsB,CAAC;QACpC,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;YACvB,2EAA2E;YAC3E,qEAAqE;YACrE,MAAM,WAAW,GAAG,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC1D,iFAAiF;YACjF,4DAA4D;YAC5D,MAAM,CAAC,QAAQ,EAAE,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;YAC3C,MAAM,KAAK,GAAG,UAAU,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;YAC/E,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;YACxD,IAAI,WAAW,EAAE,CAAC;gBAChB,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK;oBACxB,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO;oBACrB,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,EAAE,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACxE,yDAAyD;gBACzD,eAAe,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;gBAClF,4EAA4E;gBAC5E,4EAA4E;gBAC5E,kCAAkC;gBAClC,IAAI,WAAW,CAAC,SAAS,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;oBACxD,eAAe,CACb,KAAK,EACL,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAClD,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAC5B,CAAC;gBACJ,CAAC;gBACD,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;gBACzD,OAAO;oBACL,OAAO,EAAE,OAAO;oBAChB,YAAY;oBACZ,MAAM,EAAE,KAAK;oBACb,UAAU,EAAE,KAAK,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,MAAM,EAAE;iBAClD,CAAC;YACJ,CAAC;QACH,CAAC;QAED,kFAAkF;QAClF,4EAA4E;QAC5E,8BAA8B;QAC9B,sBAAsB,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAC7C,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IACtD,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CACnC,YAAoB,EACpB,KAAa,EACb,OAAe;IAEf,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,EAAE,WAAW,CAAC,EAAE,kBAAkB,OAAO,OAAO,CAAC,CAAC;AAC1F,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,YAAoB,EACpB,KAAa,EACb,OAAe,EACf,MAAgC;IAEhC,MAAM,aAAa,CAAC,qBAAqB,CAAC,YAAY,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE;QACvE,cAAc,EAAE,uDAAuD;QACvE,QAAQ,EAAE,OAAO;QACjB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,aAAa,EAAE,MAAM,CAAC,YAAY;QAClC,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,gFAAgF;QAChF,GAAG,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC9E,CAAC,CAAC;AACL,CAAC;AAED,4EAA4E;AAC5E,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,YAAoB,EACpB,KAAa,EACb,OAAe;IAEf,MAAM,GAAG,GAAG,MAAM,oBAAoB,CAKnC,qBAAqB,CAAC,YAAY,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;IACxD,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IACtB,OAAO;QACL,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,YAAY,EAAE,GAAG,CAAC,aAAa;QAC/B,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,GAAG,CAAC,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACxE,CAAC;AACJ,CAAC;AAuBD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,IAc3C;IACC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,wBAAwB,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IACvI,MAAM,MAAM,GAAG,sBAAsB,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC7D,MAAM,EAAE,GAAG,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACrD,IAAI,CAAC;QACH,gFAAgF;QAChF,gFAAgF;QAChF,iFAAiF;QACjF,yEAAyE;QACzE,wEAAwE;QACxE,0BAA0B,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;QAC7C,cAAc,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;QACjC,0BAA0B,CAAC,IAAI,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;QACjF,4EAA4E;QAC5E,kFAAkF;QAClF,mFAAmF;QACnF,yDAAyD;QACzD,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC;YACtC,IAAI;YACJ,KAAK;YACL,OAAO,EAAE,KAAK,CAAC,QAAQ;YACvB,YAAY,EAAE,EAAE;YAChB,MAAM;YACN,aAAa,EAAE,MAAM,CAAC,OAAO;YAC7B,wBAAwB;YACxB,KAAK,EAAE,EAAE,cAAc,EAAE;YACzB,mEAAmE;YACnE,UAAU,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,CAAC,EAAE,WAAW,IAAI,EAAE;SACzF,CAAC,CAAC;QACH,MAAM,uBAAuB,CAAC,YAAY,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC3E,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAC5B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACzB,MAAM,MAAM,GAA6B,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;QAClG,MAAM,uBAAuB,CAAC,YAAY,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC3E,OAAO;YACL,MAAM,EAAE;gBACN,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,eAAe,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE;gBAC1G,OAAO,EAAE,OAAO;gBAChB,KAAK,EAAE,GAAG;aACX;YACD,MAAM;SACP,CAAC;IACJ,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,123 @@
+export interface DispatchOptions {
+    root: string;
+    artifactsDir: string;
+}
+/** Normalize a declared path (absolute, repo-relative, or back-slashed) to a repo-relative forward-slash string. */
+export declare function toRepoRelative(p: string, root: string): string;
+export declare function uniquePaths(paths: string[]): string[];
+export declare function runDir(artifactsDir: string, runId: string, phase: string): string;
+export declare function dispatchPlanPath(artifactsDir: string, runId: string, phase: string): string;
+/**
+ * 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).
+ */
+export declare function canonicalPathKey(p: string): string;
+/**
+ * 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.
+ */
+export declare function refSafeSegment(s: string, fallback: string): string;
+/**
+ * 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 declare function gitTopLevel(cwd: string): string | null;
+/** True when `root` is inside a git work tree (the git tool is present and it's a repo). */
+export declare function isGitWorkTree(root: string): boolean;
+/** True when `branch` resolves to a commit in the repo at `root`. */
+export declare function gitBranchExists(root: string, branch: string): boolean;
+/** Branch name a block's isolated worktree is created on (mirrors `worktreePath`). */
+export declare function worktreeBranchForBlock(blockId: string, runId: string): string;
+/** Outcome of resolving the worker's ACTUAL edited files from git. */
+export type GitEditedFiles = {
+    available: true;
+    files: Set<string>;
+}
+/** git is present but a probe failed against a real repo → fail closed. */
+ | {
+    available: false;
+    reason: "probe_failed";
+    error: string;
+}
+/** root is not under version control at all → no ground truth, gate is skipped. */
+ | {
+    available: false;
+    reason: "not_a_repo";
+    error: string;
+};
+/**
+ * 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 declare function gitEditedFilesForBranch(root: string, branch: string): GitEditedFiles;
+/** A single edited hunk on the NEW side of a branch diff (repo-relative path). */
+export interface GitBranchHunk {
+    /** Repo-relative forward-slash path the hunk belongs to. */
+    file: string;
+    /** 1-based first line of the hunk on the new side. */
+    startLine: number;
+    /** Number of new-side lines the hunk spans (a pure deletion has 0). */
+    lineCount: number;
+}
+/**
+ * Outcome of resolving a branch's ACTUAL edited HUNKS from git. Fail-closed like
+ * {@link gitEditedFilesForBranch}: on a non-repo, a failed probe, or a diff we
+ * cannot parse, `available` is false and callers MUST treat hunk info as absent
+ * (conservatively assume same-file blocks overlap — never silently drop a
+ * collision).
+ */
+export type GitBranchHunks = {
+    available: true;
+    hunks: GitBranchHunk[];
+} | {
+    available: false;
+    reason: "not_a_repo";
+    error: string;
+} | {
+    available: false;
+    reason: "probe_failed";
+    error: string;
+};
+/**
+ * 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 declare function gitHunksForBranch(root: string, branch: string): GitBranchHunks;
+/**
+ * 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 declare function parseUnifiedDiffHunks(diffText: string): GitBranchHunks;
+/**
+ * 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 declare function writeScopeViolations(declaredWritePaths: string[], editedFiles: Set<string>, root: string): string[];
+/** Fixed prompt overhead per dispatch slot (prompt instructions, JSON schema, etc.). */
+export declare const PROMPT_OVERHEAD_TOKENS = 2000;
+/** Estimate slot tokens for an implement dispatch slot from readFiles byte sizes. */
+export declare function estimateImplementSlotTokens(readFiles: string[], root: string): number;
+/** Module-level cache: repo root → formatted conventions string. */
+export declare const detectRepoConventionsCache: Map<string, string>;
+export declare function getCachedConventions(root: string): string;
+//# sourceMappingURL=common.d.ts.map

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

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