audit-tools 0.46.0 → 0.48.0

package/dist/remediate/steps/contractPipeline.js

@@ -63,23 +63,44 @@ const ARTIFACT_TO_PHASE = {
 const CONTRACT_STEP_KIND = "contract_pipeline";
 const PRE_IMPLEMENTATION_PHASE_ORDER = CONTRACT_PIPELINE_PHASE_ORDER.filter((phase) => phase !== "closing");
 /**
- * Granularity collapse group (T1 slice 4b). The framing phases — goal, context,
- * decomposition — are ONE coherent act of authoring (scope the change top-down):
- * they carry no adversarial judgment and no deterministic derivation interleaves
- * them, so for low-complexity work they fold into a single round-trip producing
- * all three artifacts instead of three gated steps. The group deliberately STOPS
- * at decomposition (before module_contract_drafting): keeping the decomposition→
- * drafting boundary lets the slice-4a escalate-on-evidence intercept inspect the
- * fresh decomposition and raise the tier — un-collapsing every remaining phase —
- * before any contract is drafted or the per-module wave fans out. Collapse is
+ * Granularity collapse GROUPS (T1 slice 4b). Each group is a run of CONSECUTIVE
+ * phases that folds into ONE round-trip at the `collapsed` granularity — i.e.
+ * only at the `low` tier (see `roundTripGranularityForTier`). Collapse is
  * best-effort: any member artifact the worker omits or writes malformed is
  * re-emitted as its own fine-grained step by `nextMissingContractPhase`, so no
- * work is ever lost. See `roundTripGranularityForTier`.
- */
-const FRAMING_COLLAPSE_GROUP = [
-    "goal_normalization",
-    "context_collection",
-    "decomposition",
+ * work is ever lost.
+ *
+ * These are the ONLY two safe groups, and the gaps between them are not
+ * oversights — each is a property worth more than the round-trip it would save.
+ * The full per-phase map is `docs/reviews/low-tier-phase-cost-2026-08-25.md`;
+ * the boundaries that matter here:
+ *
+ *   - The framing group STOPS at `decomposition`. Keeping the decomposition→
+ *     drafting boundary lets the slice-4a escalate-on-evidence intercept read
+ *     the fresh decomposition and raise the tier — un-collapsing everything
+ *     after it — before any contract is drafted or the module wave fans out.
+ *   - `critique`, `critic` and `judge` are independent-adversary phases and can
+ *     never join a group with what they review. Collapsing critic+judge is the
+ *     sharpest case: the judge verdict is the SOLE admission to implementation
+ *     planning, so one worker emitting both artifacts could write zero
+ *     counterexamples plus `approved` and let the loop certify its own exit.
+ *   - `implementation_planning` is the phase `judgeRepairGate` protects, and its
+ *     scaffold is built from the judge's accepted counterexamples, which do not
+ *     exist at judge-render time.
+ *
+ * A collapsed section carries exactly what its fine-grained step would have
+ * carried — see `collapsedSectionExtra`.
+ */
+const COLLAPSE_GROUPS = [
+    // Framing: scope the change top-down. One coherent authoring act, no
+    // adversarial judgment, no deterministic derivation interleaved.
+    ["goal_normalization", "context_collection", "decomposition"],
+    // Authoring tail: the test/validator plan and the author's OWN coverage
+    // self-assessment. `assessment` is deliberately not an independent-critic
+    // phase, and `contract_assessment_report` already depends on
+    // `test_validator_plan` — the same later-reads-earlier shape the framing
+    // group relies on. The critic reviews both afterwards, unchanged.
+    ["test_validator_plan", "assessment"],
 ];
 // ── Bounded-loop caps ─────────────────────────────────────────────────────────
 /**
@@ -1297,8 +1318,25 @@ function writeContractBlockedStep(ctx, params) {
  * overrides the per-section "stop after writing" lines so they are not read as
  * three separate stop points.
  */
-function writeCollapsedFramingStep(ctx, phases) {
-    const sections = phases.map((phase) => ({
+/**
+ * The extra section a collapsed member carries, mirroring the gate that would
+ * have claimed that phase on its own — so collapsing changes the number of
+ * round-trips and nothing else about what the worker is told.
+ *
+ * This is load-bearing, not tidiness. `collapsedRoundTripGate` is registered
+ * BEFORE `scaffoldedPhaseGate`, so without this a group containing
+ * `test_validator_plan` would silently drop the S3 skeleton the worker is
+ * supposed to fill in, and the collapse would quietly make that phase HARDER
+ * rather than cheaper.
+ */
+async function collapsedSectionExtra(phase, artifactsDir) {
+    if (phase === "test_validator_plan" || phase === "implementation_planning") {
+        return await buildScaffoldSection(phase, artifactsDir);
+    }
+    return await buildReReviewSection(phase, artifactsDir);
+}
+async function writeCollapsedRoundTripStep(ctx, phases) {
+    const sections = await Promise.all(phases.map(async (phase) => ({
         phase,
         rendered: renderContractPipelinePrompt({
             role: phase,
@@ -1308,7 +1346,8 @@ function writeCollapsedFramingStep(ctx, phases) {
             pathASeedPath: ctx.pathASeedPath,
             adversarialDepth: ctx.adversarialDepth,
         }),
-    }));
+        extra: await collapsedSectionExtra(phase, ctx.artifactsDir),
+    })));
     const outputPaths = sections.map((s) => s.rendered.outputPath);
     const header = `# Collapsed Authoring Round-Trip — ${phases.length} Phases
 
@@ -1320,11 +1359,13 @@ If you cannot complete a section (an artifact would be malformed), write the one
 
 Artifacts to produce (in order):
 ${outputPaths.map((p, i) => `${i + 1}. \`${p}\` (${phases[i]})`).join("\n")}`;
-    const body = sections.map((s) => `\n---\n\n${s.rendered.prompt}`).join("\n");
+    const body = sections
+        .map((s) => `\n---\n\n${s.extra ? `${s.rendered.prompt}\n${s.extra}` : s.rendered.prompt}`)
+        .join("\n");
     return writeContractPromptStep(ctx, {
         prompt: `${header}\n${body}`,
         outputPath: outputPaths[outputPaths.length - 1],
-        stopCondition: `Stop after writing all ${phases.length} collapsed-framing artifacts (${phases.join(", ")}) and running next-step once.`,
+        stopCondition: `Stop after writing all ${phases.length} collapsed artifacts (${phases.join(", ")}) and running next-step once.`,
     });
 }
 /**
@@ -1420,8 +1461,8 @@ async function writeContractStepPlan(ctx, plan) {
             return await writeContractBlockedStep(ctx, plan);
         case "module_wave":
             return await writeParallelModuleWaveStep(ctx, plan.phase);
-        case "collapsed_framing":
-            return await writeCollapsedFramingStep(ctx, plan.phases);
+        case "collapsed_round_trip":
+            return await writeCollapsedRoundTripStep(ctx, plan.phases);
         case "rederive":
             // A deterministic artifact was just written; the frontier moved, so the
             // whole walk re-runs against the new state rather than guessing the phase.
@@ -2563,25 +2604,27 @@ const phaseCutCritiqueGate = async (ctx) => {
     };
 };
 /**
- * Granularity collapse (T1 slice 4b): for low-complexity work, fold the framing
- * suffix [nextPhase..decomposition] into ONE round-trip producing several
+ * Granularity collapse (T1 slice 4b): for low-complexity work, fold the suffix
+ * [nextPhase .. end of its group] into ONE round-trip producing several
  * artifacts, instead of one gated step per phase. Reads the POST-escalation
  * riskSignal (the escalate-on-evidence intercept may have already raised the
  * tier), so the dial is never frozen at run start — `fine` for medium/high keeps
- * full per-phase isolation. Only collapses a genuine multi-phase suffix.
+ * full per-phase isolation. Only collapses a genuine multi-phase suffix, so a
+ * lone trailing member falls through to its ordinary per-phase step.
  */
-const collapsedFramingGate = (ctx) => {
+const collapsedRoundTripGate = (ctx) => {
     const phase = ctx.nextPhase;
     if (phase === null ||
-        roundTripGranularityForTier(ctx.riskSignal?.tier) !== "collapsed" ||
-        !FRAMING_COLLAPSE_GROUP.includes(phase)) {
+        roundTripGranularityForTier(ctx.riskSignal?.tier) !== "collapsed") {
         return null;
     }
-    const startIdx = FRAMING_COLLAPSE_GROUP.indexOf(phase);
-    const suffix = FRAMING_COLLAPSE_GROUP.slice(startIdx);
+    const group = COLLAPSE_GROUPS.find((g) => g.includes(phase));
+    if (!group)
+        return null;
+    const suffix = group.slice(group.indexOf(phase));
     if (suffix.length <= 1)
         return null;
-    return { via: "collapsed_framing", phases: [...suffix] };
+    return { via: "collapsed_round_trip", phases: [...suffix] };
 };
 /**
  * Skeleton-scaffolded phases (S3): the tool pre-fills structure/ids from the
@@ -2646,7 +2689,7 @@ const CONTRACT_PIPELINE_GATES = {
     pre_critic_structural: preCriticStructuralGate,
     parallel_module_wave: parallelModuleWaveGate,
     phase_cut_critique: phaseCutCritiqueGate,
-    collapsed_framing_round_trip: collapsedFramingGate,
+    collapsed_round_trip: collapsedRoundTripGate,
     scaffolded_phase: scaffoldedPhaseGate,
 };
 /**
@@ -3319,35 +3362,4 @@ export async function readContractPipelinePlanningOutputs(artifactsDir) {
         ].sort((left, right) => compareCodeUnits(left.path, right.path)),
     };
 }
-// ── Lean-path extracted plan (the `low` risk tier's plan emission) ────────────
-//
-// The heavy pipeline above derives its `extracted-plan.json` from the adversarial
-// DAG (`source: "contract_pipeline"`). The `low` risk tier skips that design loop
-// (its findings are a handful of concrete, already-grounded fixes) and emits this
-// lean sibling instead, tagged `source: "lean_fast_path"` so the two producers are
-// distinguished at the artifact level. Both rejoin the SAME plan→implement→close
-// machinery — `normalizeExtractedPlan` synthesizes one block per finding and
-// `applyPlanPipeline` merges blocks sharing a file + splits by context budget, so
-// block derivation is single-sourced, not reimplemented here. The retained safety
-// net (grounding re-pass, affected-file hash snapshot, per-node verify-before-merge,
-// final whole-repo gate) still runs; only the adversarial DESIGN loop + obligation
-// derivation are dropped. (Relocated from the retired `steps/leanFastPath.ts` — DD-21.)
-/** Source tag stamped on a lean-fast-path extracted plan (distinguishes it from `contract_pipeline`). */
-export const LEAN_FAST_PATH_SOURCE = "lean_fast_path";
-/**
- * Build the lean extracted plan from the approved findings. Blocks are
- * intentionally omitted: `normalizeExtractedPlan` synthesizes one block per
- * finding and `applyPlanPipeline` then merges blocks sharing a file + splits by
- * context budget — the same deterministic block derivation the contract pipeline
- * feeds into, single-sourced rather than reimplemented here.
- */
-export function buildLeanExtractedPlan(findings, planId) {
-    return {
-        plan_id: planId,
-        findings,
-        project_type: "unknown",
-        source: LEAN_FAST_PATH_SOURCE,
-        candidate_closing_actions: ["none"],
-    };
-}
 //# sourceMappingURL=contractPipeline.js.map