audit-tools 0.30.6 → 0.30.9

package/dist/remediate/steps/nextStep.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { mkdir, readFile, rename } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { StateStore } from "../state/store.js";
-import { readOptionalJsonFile, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, DO_NOT_TOKEN_WRAP_NOTE, DISPATCH_PROMPT_HANDOFF_NOTE, renderQuotaCoverageNudge, coerceJsonObjectArg, createRollingDispatcher, setQuotaStateDir, interpretFreeFormIntent, advance, decideFrictionTriage, planHybridDispatch, readSettledPools, addSettledPool, sourceByPoolId } from "audit-tools/shared";
+import { readOptionalJsonFile, writeJsonFile, writeTextFile, buildAuditDeliverablePair, formatValidationIssues, isRecord, withFsRetry, RunLogger, DO_NOT_TOKEN_WRAP_NOTE, DISPATCH_PROMPT_HANDOFF_NOTE, renderQuotaCoverageNudge, coerceJsonObjectArg, createRollingDispatcher, setQuotaStateDir, interpretFreeFormIntent, advance, decideFrictionTriage, buildFrictionTriageBlock, planHybridDispatch, readSettledPools, addSettledPool, sourceByPoolId } from "audit-tools/shared";
 import { applyPlanPipeline, buildCoverageLedger } from "../phases/plan.js";
 import { groundExtractedFindings } from "../phases/grounding.js";
 import { runTriagePhase } from "../phases/triage.js";
@@ -10,6 +10,7 @@ import { runClosePhase } from "../phases/close.js";
 import { validateRemediationPlan } from "../validation/remediationState.js";
 import { mergeImplementResults, prepareImplementDispatch, readExtractedPlanIfPresent, buildConfirmedPools, executeNodeInWorktree, blockScopesFromPlan, declaredPathsFromPlan, targetedCommandsForBlock, } from "./dispatch.js";
 import { makeProviderNodeDispatcher } from "./providerNodeDispatch.js";
+import { ownershipSubWaves } from "../dispatch/ownershipScheduler.js";
 import { prepareHostRollingDispatch, nodeClaimRegistry, nodeSettledPoolsPath } from "./rollingSession.js";
 import { writeCurrentStep } from "./stepWriter.js";
 import { dependencyVerifiedComplete } from "./stepUtils.js";
@@ -112,7 +113,10 @@ function resolveArtifactsDir(root, artifactsDir) {
     return resolve(artifactsDir ?? join(root, ".audit-tools", "remediation"));
 }
 function stateRunId(state) {
-    return state?.plan?.plan_id ?? randomRunId("REMEDIATE");
+    // When the plan is absent (fully-green close deleted the state, or complete
+    // was persisted without a plan), use the stable fallback "run" so the friction
+    // record path is deterministic across multiple next-step calls on the same run.
+    return state?.plan?.plan_id ?? "run";
 }
 function defaultInputCandidates(root) {
     // Prefer the canonical machine contract (audit-findings.json) over its
@@ -245,8 +249,14 @@ function blockedByUnsatisfiedDependency(state) {
  * prerequisite is skipped/blocked, not merely pending) is NOT placed in any
  * level — it is dead-ended by `handlePlanning`.
  *
- * Pure and deterministic: levels and the nodes within a level are ordered by
- * block_id so the interposed-rebuild boundaries are stable across runs.
+ * Pure and deterministic: level MEMBERSHIP is fixed by the dependency predicate
+ * (INV-RS-01) and is independent of node order; the interposed-rebuild boundaries
+ * are therefore stable across runs without an in-level numeric sort. In-level
+ * admission ORDER is no longer decided here — it is owned by the file-ownership
+ * scheduler (`ownershipSubWaves`, INV-SOO-04/08), which applies its own explicit
+ * block_id tie-break AFTER the disjointness filter. The numeric
+ * `block_id.localeCompare` admission ordering that used to live here was removed
+ * atomically with that change (INV-SOO-04).
  */
 export function rollingDependencyLevels(state) {
     const plan = state.plan;
@@ -254,9 +264,7 @@ export function rollingDependencyLevels(state) {
     if (!plan || !items)
         return [];
     const blockById = new Map(plan.blocks.map((b) => [b.block_id, b]));
-    const pendingBlocks = plan.blocks
-        .filter((b) => b.items.some((id) => items[id]?.status === "pending"))
-        .sort((a, b) => a.block_id.localeCompare(b.block_id));
+    const pendingBlocks = plan.blocks.filter((b) => b.items.some((id) => items[id]?.status === "pending"));
     // A dependency edge is "completable" only when the dep node is itself pending
     // (will be satisfied by some level) or already verified-complete. A skipped /
     // blocked dependency makes the dependent permanently ineligible — such nodes
@@ -340,23 +348,34 @@ export async function driveRollingDispatch(levels, options) {
             }
         }
         const blockByPacketId = new Map(level.map((b) => [b.block_id, b]));
-        const packets = level.map((block) => ({
-            id: block.block_id,
-            payload: { block_id: block.block_id },
-            estimatedTokens: estimateTokens(block),
-            complexity: 0.5,
-        }));
-        const dispatcher = createRollingDispatcher({
-            confirmedPools: options.confirmedPools,
-            sessionConfig: options.sessionConfig,
-            dispatchPacket: async (packet, slot) => {
-                const block = blockByPacketId.get(packet.payload.block_id);
-                return options.dispatchNode(block, slot);
-            },
-        });
-        dispatcher.enqueue(packets);
-        const results = await dispatcher.run();
-        out.levels.push({ blockIds: level.map((b) => b.block_id), results });
+        const scopeForBlock = options.scopeForBlock ?? ((b) => b.touched_files ?? []);
+        // File-ownership-disjoint admission (INV-SOO): split the level into ordered
+        // sub-waves, each a maximal file-disjoint subset (deterministic block_id
+        // tie-break AFTER the disjointness filter, INV-SOO-08). Same-file nodes land
+        // in successive sub-waves (serialize, INV-SOO-01/02) and a freed file becomes
+        // schedulable for the next sub-wave; different-file nodes share a sub-wave and
+        // parallelize up to the quota cap the dispatcher enforces (INV-SOO-03/05).
+        const subWaves = ownershipSubWaves(level.map((b) => ({ block_id: b.block_id, write_paths: scopeForBlock(b) })), options.root);
+        const levelResults = [];
+        for (const wave of subWaves) {
+            const packets = wave.map((node) => ({
+                id: node.block_id,
+                payload: { block_id: node.block_id },
+                estimatedTokens: estimateTokens(blockByPacketId.get(node.block_id)),
+                complexity: 0.5,
+            }));
+            const dispatcher = createRollingDispatcher({
+                confirmedPools: options.confirmedPools,
+                sessionConfig: options.sessionConfig,
+                dispatchPacket: async (packet, slot) => {
+                    const block = blockByPacketId.get(packet.payload.block_id);
+                    return options.dispatchNode(block, slot);
+                },
+            });
+            dispatcher.enqueue(packets);
+            levelResults.push(...(await dispatcher.run()));
+        }
+        out.levels.push({ blockIds: level.map((b) => b.block_id), results: levelResults });
     }
     return out;
 }
@@ -543,12 +562,18 @@ export async function driveRollingImplementDispatch(options) {
         }
         return result;
     };
+    // Declared write-scope per block, from the dispatch plan — the same authority
+    // the merge-time write-scope gate reads — for file-ownership-disjoint admission
+    // (INV-SOO). A block with no plan scope falls back to its touched_files.
+    const writePathsByBlock = new Map(allBlockScopes.map((s) => [s.block_id, s.write_paths]));
     await driveRollingDispatch(levels, {
         confirmedPools,
         sessionConfig: options.sessionConfig ?? {},
         dispatchNode: dispatchNodeWithWorktree,
         rebuildSharedBetweenLevels: options.rebuildSharedBetweenLevels,
         quotaStateDir: artifactsDir,
+        root,
+        scopeForBlock: (block) => writePathsByBlock.get(block.block_id) ?? block.touched_files ?? [],
     });
     // Deterministic merge: same path the wave flow uses (tolerant remap, write-scope
     // gate against each verified branch, lost-update detection). Worktrees are
@@ -996,56 +1021,36 @@ async function forceReplanFromExistingIntake(root, artifactsDir, previous, store
 }
 async function presentReportStep(root, artifactsDir, state) {
     const reportPath = join(dirname(artifactsDir), "remediation-report.md");
-    // Tool-emitted terminal friction-TRIAGE close-out, FOLDED into present_report so it
-    // is one bounded step (parity with audit-code; single-sourced in `audit-tools/shared`).
-    // MANDATORY + BLOCKING: stays "dispose" until every captured mechanical event AND
-    // every surfaced agent-feedback reflection carries a keep|discard|annotate
-    // disposition; an empty set (zero events AND zero reflections) is trivially
-    // "disposed". Never couples to any repo's backlog doc.
-    const triage = await decideRemediateFrictionCloseout(artifactsDir, state);
-    const pendingBlock = triage.action === "dispose"
-        ? `
-
-## Triage captured friction (BLOCKING close-out)
-
-This run captured friction that MUST be disposed before it can present complete.
-For EACH item below, record a disposition (\`keep\`, \`discard\`, or \`annotate\`)
-against its id into the run's friction record at \`${triage.recordPath}\` (append to
-\`dispositions[]\` as \`{ "target_id": "<id>", "disposition": "keep|discard|annotate",
-optional "annotation": "..." }\`). This is the run's own record under its artifacts
-dir — do NOT edit any repository's tracking/backlog doc.
-
-${triage.pending
-            .map((subject) => `- \`${subject.id}\` (${subject.source}) — ${subject.note}`)
-            .join("\n")}
-`
-        : `
-
-## Run friction triage
-
-No captured friction or agent-feedback reflections required disposition this run
-(empty set → trivially disposed).
-`;
+    // Terminal friction-TRIAGE close-out, folded into present_report (single-sourced in
+    // `audit-tools/shared`). MANDATORY + BLOCKING: stays "dispose" until every mechanical
+    // event + reflection is disposed AND ≥1 open observation written. Never trivially
+    // satisfied by an empty event set — the host must actively confirm the friction state.
+    //
+    // When `artifactsDir` was deleted by a fully-green close (close.ts rm -rf on a
+    // green run), there is nowhere to persist the friction record and no mechanical
+    // events to triage — skip the triage entirely and go straight to complete.
+    const artifactsDirExists = existsSync(artifactsDir);
+    const triage = artifactsDirExists
+        ? await decideRemediateFrictionCloseout(artifactsDir, state)
+        : null;
+    const frictionBlock = triage ? buildFrictionTriageBlock(triage) : "";
+    const isBlocked = triage?.action === "dispose";
     return writeCurrentStep({
         stepKind: "present_report",
-        status: "complete",
+        status: isBlocked ? "ready" : "complete",
         runId: stateRunId(state),
         repoRoot: root,
         artifactsDir,
-        prompt: `
-# Present Remediation Report
-
-Read \`${reportPath}\` and summarize the remediation outcome for the user.
-Mention the resolved, ignored, and deemed-inappropriate counts plus the closing action.
-${pendingBlock}
-Stop after presenting the summary (and disposing captured friction, if any).
-`,
+        prompt: isBlocked
+            ? `# Remediation Run Friction Triage\n\nComplete friction triage before presenting the report.\n${frictionBlock}`
+            : `# Present Remediation Report\n\nRead \`${reportPath}\` and summarize the remediation outcome.\nMention resolved, ignored, and deemed-inappropriate counts plus the closing action.\n${frictionBlock}`,
         allowedCommands: [],
-        stopCondition: "Stop after presenting the remediation report summary and disposing any captured run friction.",
+        stopCondition: isBlocked
+            ? "Complete friction triage (write dispositions and open_observations), then call next-step again."
+            : "Present the remediation report summary and stop.",
         artifactPaths: {
             final_report: reportPath,
-            // Surface the run's friction record (resolved through the shared path module).
-            friction_record: triage.recordPath,
+            ...(triage ? { friction_record: triage.recordPath } : {}),
         },
     });
 }
@@ -2363,10 +2368,11 @@ async function handleClosing(root, artifactsDir, state, runLogger, store) {
     // Close-complete CROSSES the engine boundary: `complete` is a pre-intake
     // obligation, unreachable from a main-engine transition. Emit the durable
     // report directly, passing exactly what the original recursion reloaded — the
-    // artifact dir is DELETED on a fully-green close (reload → null → randomRunId)
-    // and PRESERVED on a not-green complete (reload → the saved complete state →
-    // its plan_id). `store.loadState()` reproduces both, so present_report is
-    // identical to the cascade. (Regression-locked in next-step-implement-dispatch.)
+    // artifact dir is DELETED on a fully-green close (reload → null → stateRunId
+    // falls back to "run") and PRESERVED on a not-green complete (reload → the
+    // saved complete state → its plan_id). `store.loadState()` reproduces both, so
+    // present_report is identical to the cascade.
+    // (Regression-locked in next-step-implement-dispatch.)
     return {
         kind: "emit",
         step: await handleComplete(root, artifactsDir, await store.loadState()),