gsd-pi 2.77.0-dev.1d17f366c → 2.77.0-dev.2daa994b6

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -23,7 +23,16 @@ import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMil
 import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { selectReactiveDispatchBatch } from "./uok/execution-graph.js";
+import { getMilestonePipelineVariant } from "./milestone-scope-classifier.js";
 import { EXECUTION_ENTRY_PHASES, hasFinalizedMilestoneContext } from "./uok/plan-v2.js";
+let reassessmentChecker = checkNeedsReassessment;
+export function setReassessmentCheckerForTest(checker) {
+    const previous = reassessmentChecker;
+    reassessmentChecker = checker;
+    return () => {
+        reassessmentChecker = previous;
+    };
+}
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -272,12 +281,16 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
             if (prefs?.phases?.skip_reassess)
                 return null;
-            // Default reassess_after_slice to true — reassessment after slice completion
-            // is essential for roadmap integrity. Opt-out via explicit `false`.
-            const reassessEnabled = prefs?.phases?.reassess_after_slice ?? true;
+            // Default reassess_after_slice to false per ADR-003 §4 — most reassess
+            // units conclude "roadmap is fine" and burn a session for no change.
+            // The plan-slice prompt now carries a reassessment preamble so the
+            // next slice's planner does JIT roadmap verification at zero extra
+            // cost. Opt-in via explicit `reassess_after_slice: true` (e.g.
+            // burn-max profile) when you want the dedicated reassess session.
+            const reassessEnabled = prefs?.phases?.reassess_after_slice ?? false;
             if (!reassessEnabled)
                 return null;
-            const needsReassess = await checkNeedsReassessment(basePath, mid, state);
+            const needsReassess = await reassessmentChecker(basePath, mid, state);
             if (!needsReassess)
                 return null;
             return {
@@ -383,6 +396,12 @@ export const DISPATCH_RULES = [
                 return null;
             if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
                 return null;
+            // #4781 phase 2: trivial-scope milestones skip dedicated slice research.
+            // plan-slice absorbs the lightweight discovery a trivial deliverable
+            // needs. Null result (DB unavailable / unknown) falls through to today's
+            // behavior.
+            if (await getMilestonePipelineVariant(mid) === "trivial")
+                return null;
             // Load roadmap to find all slices
             const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
             const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
@@ -432,6 +451,9 @@ export const DISPATCH_RULES = [
             // Phase skip: skip research when preference or profile says so
             if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
                 return null;
+            // #4781 phase 2: trivial-scope milestones skip dedicated slice research.
+            if (await getMilestonePipelineVariant(mid) === "trivial")
+                return null;
             if (!state.activeSlice)
                 return missingSliceStop(mid, state.phase);
             const sid = state.activeSlice.id;
@@ -713,22 +735,29 @@ export const DISPATCH_RULES = [
                     level: "error",
                 };
             }
-            // Skip preference: write a minimal pass-through VALIDATION file
-            if (prefs?.phases?.skip_milestone_validation) {
+            // #4781 phase 2: trivial-scope milestones skip the dedicated validate
+            // unit — complete-milestone's own verification steps (3/4/5 in the
+            // closer prompt) are sufficient proof for contained deliverables.
+            const trivialVariant = await getMilestonePipelineVariant(mid) === "trivial";
+            // Skip preference OR trivial scope: write a minimal pass-through VALIDATION file.
+            if (prefs?.phases?.skip_milestone_validation || trivialVariant) {
                 const mDir = resolveMilestonePath(basePath, mid);
                 if (mDir) {
                     if (!existsSync(mDir))
                         mkdirSync(mDir, { recursive: true });
                     const validationPath = join(mDir, buildMilestoneFileName(mid, "VALIDATION"));
+                    const skipSource = trivialVariant
+                        ? "trivial-scope pipeline variant (#4781)"
+                        : "`skip_milestone_validation` preference";
                     const content = [
                         "---",
                         "verdict: pass",
                         "remediation_round: 0",
                         "---",
                         "",
-                        "# Milestone Validation (skipped by preference)",
+                        "# Milestone Validation (skipped)",
                         "",
-                        "Milestone validation was skipped via `skip_milestone_validation` preference.",
+                        `Milestone validation was skipped via ${skipSource}.`,
                     ].join("\n");
                     writeFileSync(validationPath, content, "utf-8");
                 }

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -521,6 +521,85 @@ export async function postUnitPreVerification(pctx, opts) {
                     clearReactiveState(s.basePath, mid, sid);
                 }
             });
+            // #4765 — slice-cadence collapse. When `git.collapse_cadence: "slice"`
+            // is set, squash-merge the slice's commits from the milestone branch
+            // onto main right here, so orphan risk shrinks from milestone-size to
+            // slice-size. Only runs in worktree isolation mode — the feature needs
+            // a milestone branch to squash from.
+            let sliceMergeStopped = false;
+            await runSafely("postUnit", "slice-cadence-merge", async () => {
+                const prefsResult = loadEffectiveGSDPreferences(s.basePath);
+                const prefs = prefsResult?.preferences;
+                const { getCollapseCadence, mergeSliceToMain } = await import("./slice-cadence.js");
+                if (getCollapseCadence(prefs) !== "slice")
+                    return;
+                if (prefs?.git?.isolation !== "worktree")
+                    return;
+                if (s.isolationDegraded)
+                    return;
+                const projectRoot = s.originalBasePath || s.basePath;
+                const { milestone: mid, slice: sid } = parseUnitId(unit.id);
+                if (!mid || !sid)
+                    return;
+                // Record the milestone start SHA before the first slice merge, so
+                // resquashMilestoneOnMain has a target at milestone completion.
+                // Resolve main branch dynamically — hard-coding "main" breaks repos
+                // that use "master" or a custom default branch.
+                if (!s.milestoneStartShas.has(mid)) {
+                    try {
+                        const { nativeDetectMainBranch } = await import("./native-git-bridge.js");
+                        const mainBranch = nativeDetectMainBranch(projectRoot);
+                        const { execFileSync } = await import("node:child_process");
+                        const sha = execFileSync("git", ["rev-parse", mainBranch], {
+                            cwd: projectRoot, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8",
+                        }).trim();
+                        if (sha)
+                            s.milestoneStartShas.set(mid, sha);
+                    }
+                    catch (err) {
+                        logWarning("engine", `slice-cadence: failed to record milestone start SHA: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+                try {
+                    const result = mergeSliceToMain(projectRoot, mid, sid);
+                    if (result.skipped) {
+                        logWarning("engine", `slice-cadence: merge skipped for ${sid} — ${result.skippedReason}`);
+                        return;
+                    }
+                    ctx.ui.notify(`slice-cadence: ${sid} merged to main (${result.durationMs}ms).`, "info");
+                }
+                catch (err) {
+                    const { MergeConflictError } = await import("./git-service.js");
+                    if (err instanceof MergeConflictError) {
+                        ctx.ui.notify(`slice-cadence merge conflict in ${sid}: ${err.conflictedFiles.join(", ")}. ` +
+                            `Resolve manually on main and run \`/gsd auto\` to resume.`, "error");
+                        // Stop auto AND signal the outer postUnit flow to exit early.
+                        // Without the flag, subsequent hooks (triage, rogue detection,
+                        // DB writes) would keep running against a conflicted main
+                        // checkout after the loop was already told to stop.
+                        const { stopAuto } = await import("./auto.js");
+                        await stopAuto(ctx, undefined, `slice-merge-conflict on ${sid}`);
+                        sliceMergeStopped = true;
+                        return;
+                    }
+                    logError("engine", `slice-cadence merge failed for ${sid}`, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                    // Non-conflict failures (dirty main, rev-walk error, etc.) can
+                    // leave the checkout in an unexpected state. Stop auto-mode so
+                    // the next slice doesn't dispatch on top of it.
+                    const { stopAuto } = await import("./auto.js");
+                    await stopAuto(ctx, undefined, `slice-merge-error on ${sid}`);
+                    sliceMergeStopped = true;
+                }
+            });
+            // Exit early after stopAuto so the rest of post-unit processing
+            // (triage, rogue detection, hook dispatch, DB writes) doesn't run
+            // against a conflicted main checkout. Return "dispatched" to match
+            // the convention used by other stop/pauseAuto paths in this function
+            // (see signal handling earlier: stop/pause also return "dispatched").
+            if (sliceMergeStopped)
+                return "dispatched";
         }
         // Post-triage: execute actionable resolutions
         if (s.currentUnit.type === "triage-captures") {