audit-tools 0.28.0

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

@@ -0,0 +1,434 @@
+import { type RemediationState } from "../state/store.js";
+import { type RemediationBlock } from "../state/types.js";
+import type { SessionConfig, HostConcurrencyLimit, WaveSchedule, QuotaStateEntry, ResolvedProviderName, DispatchCapacityPoolSummary, HostModelRosterEntry, CapacityPool } from "audit-tools/shared";
+import { type DispatchModelHint, type DispatchPhase, type ImplementWorkerResult, type RemediationDispatchPlan, type RemediationDispatchQuota } from "./types.js";
+import { resolveHostActiveSubagentLimit } from "../quota/index.js";
+export { resolveHostActiveSubagentLimit };
+export { detectHostActiveSubagentLimit as detectHostConcurrencyFromEnv, } from "../quota/hostLimits.js";
+export type { HostConcurrencyLimit };
+export interface ScheduleWaveInput {
+    hostMaxConcurrent?: number | null;
+    sessionConfig: SessionConfig | null;
+    itemCount: number;
+    estimatedSlotTokens?: number[];
+    providerName?: ResolvedProviderName;
+    hostModel?: string | null;
+    /** Context window the host reports for its dispatch model (handshake). */
+    hostContextTokens?: number | null;
+    /** Output cap the host reports for its dispatch model (handshake). */
+    hostOutputTokens?: number | null;
+    /**
+     * Ordered model roster (lowest rank first) from the multi-rank handshake
+     * (`--host-models`); outranks the scalar pair. One capacity pool is built per
+     * reported rank, each with its own discovered window.
+     */
+    hostModels?: HostModelRosterEntry[] | null;
+    /**
+     * Opaque model identity for the quota key when no model name resolves —
+     * a key segment ONLY (`provider/<id>`), never a window authority.
+     */
+    hostModelId?: string | null;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function normalizeSlotTokens(tokens: number[] | undefined, count: number): number[];
+export interface WaveScheduleResult extends WaveSchedule {
+    host_concurrency_limit: HostConcurrencyLimit | null;
+    capacity_pools?: DispatchCapacityPoolSummary[];
+}
+export declare function resolveHostConcurrencyLimit(options: {
+    hostMaxConcurrent?: number | null;
+    sessionConfig: SessionConfig | null;
+    env?: NodeJS.ProcessEnv;
+}): HostConcurrencyLimit | null;
+export declare function scheduleWave(input: ScheduleWaveInput): Promise<WaveScheduleResult>;
+/**
+ * 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 declare function buildConfirmedPools(input: {
+    sessionConfig: SessionConfig | null;
+    hostMaxConcurrent?: number | null;
+    hostContextTokens?: number | null;
+    hostOutputTokens?: number | null;
+    hostModels?: HostModelRosterEntry[] | null;
+    hostModelId?: string | null;
+    env?: NodeJS.ProcessEnv;
+}): Promise<CapacityPool[]>;
+export declare function buildDispatchQuota(runId: string, phase: DispatchPhase, schedule: WaveScheduleResult, quotaStateEntry?: QuotaStateEntry | null): RemediationDispatchQuota;
+/** Module-level cache: repo root → formatted conventions string. */
+export declare const detectRepoConventionsCache: Map<string, string>;
+export interface WorktreeVerifyResult {
+    passed: boolean;
+    output: 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;
+/**
+ * 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 declare function createWorktree(root: string, worktreePath: string, branchName: string): void;
+/** Remove a git worktree. Best-effort: logs but does not throw on failure. */
+export declare function removeWorktree(root: string, worktreePath: string): void;
+/**
+ * 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 declare function resetNodeWorktreeAndBranch(root: string, worktreePath: string, branchName: string): void;
+/** Run each targeted command in the worktree directory. Returns pass/fail and combined output. */
+export declare function verifyNodeInWorktree(worktreePath: string, targetedCommands: string[]): WorktreeVerifyResult;
+/** Merge the worktree branch into the current HEAD via cherry-pick. On failure, removes the worktree and returns the error. */
+export declare function mergeWorktree(root: string, worktreePath: string, branchName: string): {
+    success: true;
+} | {
+    success: false;
+    error: string;
+};
+/** Worktree path for a remediation block. */
+export declare function worktreePath(root: string, blockId: string, runId: string): string;
+/**
+ * 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.
+ */
+export declare function commitWorktree(worktreeRoot: string, message: string): {
+    committed: boolean;
+    error?: string;
+};
+/**
+ * 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 declare function ensureWorktreeNodeModules(mainRoot: string, worktreeRoot: string): void;
+/** 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;
+    /** Deduped per-node verify commands (from the block's findings). */
+    targetedCommands: string[];
+}
+export interface AcceptNodeWorktreeResult {
+    /** The LIFECYCLE outcome (verify/merge applied), distinct from the worker transport outcome. */
+    outcome: NodeWorkerOutcome;
+    verifyPassed: boolean;
+    merged: boolean;
+}
+/**
+ * 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): 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>;
+export interface DispatchOptions {
+    root: string;
+    artifactsDir: string;
+}
+/**
+ * The implementation-DAG node fields `promoteImplementationDagToExtractedPlan`
+ * writes onto each Finding (one node ↔ one finding ↔ one block in the contract
+ * pipeline). The shared `Finding` type does not declare these overlay fields, so
+ * they are read through this structural view rather than added to the shared
+ * contract. Every field is optional: a finding sourced from a plain
+ * `audit-findings.json` (not the contract pipeline) carries none of them and the
+ * seam degrades to the block-level behavior.
+ */
+export interface DagNodeFields {
+    /** Relative model rank for the node (small | standard | deep). Never a model name. */
+    model_tier?: "small" | "standard" | "deep";
+    /** Upstream contracts' declared outputs this node builds on. */
+    preconditions?: string[];
+    /** Human-readable description of the concrete changes the node is expected to produce. */
+    expected_changes?: string;
+    /** Human-readable verification checks beyond `targeted_commands`. */
+    verification?: string[];
+    /**
+     * Reconciliation expectations carried from seam reconciliation: what an
+     * upstream/neighbor contract agreed to provide this node, expressed either as
+     * a list of strings or, when richer, as the precondition list. Read tolerantly
+     * because the promotion shape can vary across pipeline versions.
+     */
+    reconciliation_expectations?: string[];
+}
+/**
+ * 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 declare function isBuildFreeVerifyCommand(cmd: string): boolean;
+/**
+ * Best-effort: repo-relative test files that reference any of `sourceFiles` (by
+ * module basename). Pulling them into a block's access lets the worker that
+ * changes or removes a symbol also fix the tests that assert it, instead of
+ * leaving orphaned test breakage for a separate central mop-up. Matching is
+ * deliberately loose (a false positive only grants slightly broader, harmless
+ * write access; a false negative is the failure mode we want to avoid).
+ */
+export interface TestFileEntry {
+    rel: string;
+    content: string;
+}
+/**
+ * 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 declare function buildTestFileIndex(root: string): TestFileEntry[];
+/**
+ * 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 declare function collectReferencingTests(index: TestFileEntry[], sourceFiles: string[], packageRoot?: string): string[];
+export declare function buildImplementModelHint(block: RemediationBlock, state: RemediationState): DispatchModelHint;
+/**
+ * Returns true when any path in `writePaths` matches the set of infra files
+ * (normalised to repo-relative forward-slash strings). Used to gate the
+ * live-surface verification section in the implement prompt.
+ */
+export declare function isInfraModifyingBlock(writePaths: string[]): boolean;
+export declare function prepareImplementDispatch(options: DispatchOptions, runId: string, onlyBlockId?: string, waveOptions?: {
+    hostMaxConcurrent?: number;
+    sessionConfig?: SessionConfig | null;
+    hostContextTokens?: number | null;
+    hostOutputTokens?: number | null;
+    hostModels?: HostModelRosterEntry[] | null;
+    hostModelId?: string | null;
+    /**
+     * Root each node's prompt at its isolated worktree (the deterministic
+     * `worktreePath(root, block_id, runId)`) rather than the main checkout. Set by
+     * the rolling engine (`driveRollingImplementDispatch`) so a worker told its
+     * repository root is the worktree edits there, not the shared main tree.
+     */
+    worktreeRootedPrompts?: boolean;
+}): Promise<RemediationDispatchPlan>;
+/** 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 set of repo-relative paths the worker ACTUALLY edited, read from git
+ * (tracked modifications + staged + untracked-not-ignored). This is the ground
+ * truth for write-scope enforcement; the worker's self-reported `amended_files`
+ * is advisory only and is never trusted for the scope gate.
+ *
+ * Fail-closed: when `root` IS a git repo but a probe errors, returns
+ * `{ available: false, reason: "probe_failed" }` so the caller blocks rather than
+ * silently trusting an unverifiable edit set. When `root` is not a git repo at
+ * all (no worktree workflow, no diff ground truth), returns
+ * `{ available: false, reason: "not_a_repo" }` so the caller skips the gate.
+ */
+export declare function gitEditedFiles(root: string): GitEditedFiles;
+/**
+ * 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[];
+/** Branch name a block's isolated worktree is created on (mirrors `worktreePath`). */
+export declare function worktreeBranchForBlock(blockId: string, runId: string): 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;
+/** The decision a write-scope gate makes given the resolved edit set. */
+export interface WriteScopeDecision {
+    blocked: boolean;
+    reason?: string;
+}
+/**
+ * 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 declare function enforceWriteScope(declaredWritePaths: string[], edited: GitEditedFiles, root: string): WriteScopeDecision;
+/**
+ * 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 declare function buildBlockAliasMap(block: RemediationBlock, state: RemediationState): Map<string, string>;
+/**
+ * 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 declare function collapseItemResults(itemResults: ImplementWorkerResult["item_results"], aliasMap: Map<string, string>, knownFindingIds: Set<string>): {
+    collapsed: ImplementWorkerResult["item_results"];
+    unresolved: ImplementWorkerResult["item_results"];
+};
+export type NodeDispositionStatus = "verified_complete" | "blocked" | "skipped" | "missing_result";
+export interface NodeDisposition {
+    node_id: string;
+    block_id: string;
+    disposition: NodeDispositionStatus;
+    /** The state status the node's finding(s) ended in. */
+    finding_status: string;
+    /** Reconciliation expectations the node was responsible for honoring (INV-DS-12). */
+    reconciliation_expectations: string[];
+    /** Why the node landed in this disposition (failure_reason / skip reason). */
+    reason?: string;
+}
+/**
+ * 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 declare function buildNodeDisposition(block: RemediationBlock, state: RemediationState): NodeDisposition;
+/**
+ * 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 declare function attributeSiblingRed(implicatedFiles: string[], mergedBlockScopes: Array<{
+    block_id: string;
+    write_paths: string[];
+}>, root: string): string | null;
+/** A merged block's ACTUAL edited file set (resolved from its worktree branch diff). */
+export interface BlockEditedFiles {
+    block_id: string;
+    /** Repo-relative forward-slash paths the block's worker actually changed. */
+    files: Set<string>;
+}
+/** One detected overlap: two merged blocks whose actual edits hit the same file. */
+export interface OverlappingEdit {
+    path: string;
+    block_ids: string[];
+}
+/**
+ * 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 declare function detectOverlappingEdits(editedByBlock: BlockEditedFiles[]): OverlappingEdit[];
+export declare function mergeImplementResults(options: DispatchOptions, runId: string): Promise<RemediationState>;
+export declare function readExtractedPlanIfPresent(artifactsDir: string): Promise<unknown | undefined>;
+export declare function readDispatchPlan(artifactsDir: string, runId: string, phase: "implement"): Promise<RemediationDispatchPlan>;
+//# sourceMappingURL=dispatch.d.ts.map

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

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