gsd-pi 2.41.0 → 2.42.0-dev.eedc83f

package/dist/resources/extensions/gsd/auto/phases.js

@@ -13,6 +13,7 @@ import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
+import { PROJECT_FILES } from "../detection.js";
 import { join } from "node:path";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
@@ -121,6 +122,7 @@ export async function runPreDispatch(ic, loopState) {
     });
     // ── Milestone transition ────────────────────────────────────────────
     if (mid && s.currentMilestoneId && mid !== s.currentMilestoneId) {
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "milestone-transition", data: { from: s.currentMilestoneId, to: mid } });
         ctx.ui.notify(`Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}: ${midTitle}.`, "info");
         deps.sendDesktopNotification("GSD", `Milestone ${s.currentMilestoneId} complete!`, "success", "milestone");
         deps.logCmuxEvent(prefs, `Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}.`, "success");
@@ -248,6 +250,7 @@ export async function runPreDispatch(ic, loopState) {
             await deps.stopAuto(ctx, pi, `No active milestone — ${incomplete.length} incomplete (${ids}), see diagnostic above`);
         }
         debugLog("autoLoop", { phase: "exit", reason: "no-active-milestone" });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "no-active-milestone" } });
         return { action: "break", reason: "no-active-milestone" };
     }
     if (!midTitle) {
@@ -295,6 +298,7 @@ export async function runPreDispatch(ic, loopState) {
         deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");
         await closeoutAndStop(ctx, pi, s, deps, `Milestone ${mid} complete`);
         debugLog("autoLoop", { phase: "exit", reason: "milestone-complete" });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "milestone-complete", milestoneId: mid } });
         return { action: "break", reason: "milestone-complete" };
     }
     // Terminal: blocked
@@ -305,6 +309,7 @@ export async function runPreDispatch(ic, loopState) {
         deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention");
         deps.logCmuxEvent(prefs, blockerMsg, "error");
         debugLog("autoLoop", { phase: "exit", reason: "blocked" });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "blocked", blockers: state.blockers } });
         return { action: "break", reason: "blocked" };
     }
     return { action: "next", data: { state, mid, midTitle } };
@@ -328,6 +333,7 @@ export async function runDispatch(ic, preData, loopState) {
         session: s,
     });
     if (dispatchResult.action === "stop") {
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-stop", rule: dispatchResult.matchedRule, data: { reason: dispatchResult.reason } });
         await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
         debugLog("autoLoop", { phase: "exit", reason: "dispatch-stop" });
         return { action: "break", reason: "dispatch-stop" };
@@ -337,6 +343,7 @@ export async function runDispatch(ic, preData, loopState) {
         await new Promise((r) => setImmediate(r));
         return { action: "continue" };
     }
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-match", rule: dispatchResult.matchedRule, data: { unitType: dispatchResult.unitType, unitId: dispatchResult.unitId } });
     let unitType = dispatchResult.unitType;
     let unitId = dispatchResult.unitId;
     let prompt = dispatchResult.prompt;
@@ -402,6 +409,7 @@ export async function runDispatch(ic, preData, loopState) {
     const preDispatchResult = deps.runPreDispatchHooks(unitType, unitId, prompt, s.basePath);
     if (preDispatchResult.firedHooks.length > 0) {
         ctx.ui.notify(`Pre-dispatch hook${preDispatchResult.firedHooks.length > 1 ? "s" : ""}: ${preDispatchResult.firedHooks.join(", ")}`, "info");
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "pre-dispatch-hook", data: { firedHooks: preDispatchResult.firedHooks, action: preDispatchResult.action } });
     }
     if (preDispatchResult.action === "skip") {
         ctx.ui.notify(`Skipping ${unitType} ${unitId} (pre-dispatch hook).`, "info");
@@ -544,25 +552,27 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         unitType,
         unitId,
     });
-    // ── Worktree health check (#1833) ───────────────────────────────────
+    // ── Worktree health check (#1833, #1843) ────────────────────────────
     // Verify the working directory is a valid git checkout with project
     // files before dispatching work. A broken worktree causes agents to
     // hallucinate summaries since they cannot read or write any files.
+    // Uses the shared PROJECT_FILES list from detection.ts to support all
+    // ecosystems (Rust, Go, Python, Java, etc.), not just JS.
     if (s.basePath && unitType === "execute-task") {
         const gitMarker = join(s.basePath, ".git");
         const hasGit = deps.existsSync(gitMarker);
-        const hasPackageJson = deps.existsSync(join(s.basePath, "package.json"));
-        const hasSrcDir = deps.existsSync(join(s.basePath, "src"));
         if (!hasGit) {
             const msg = `Worktree health check failed: ${s.basePath} has no .git — refusing to dispatch ${unitType} ${unitId}`;
-            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasGit, hasPackageJson, hasSrcDir });
+            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasGit });
             ctx.ui.notify(msg, "error");
             await deps.stopAuto(ctx, pi, msg);
             return { action: "break", reason: "worktree-invalid" };
         }
-        if (!hasPackageJson && !hasSrcDir) {
-            const msg = `Worktree health check failed: ${s.basePath} has no package.json or src/ — refusing to dispatch ${unitType} ${unitId}`;
-            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasGit, hasPackageJson, hasSrcDir });
+        const hasProjectFile = PROJECT_FILES.some((f) => deps.existsSync(join(s.basePath, f)));
+        const hasSrcDir = deps.existsSync(join(s.basePath, "src"));
+        if (!hasProjectFile && !hasSrcDir) {
+            const msg = `Worktree health check failed: ${s.basePath} has no recognized project files — refusing to dispatch ${unitType} ${unitId}`;
+            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasProjectFile, hasSrcDir });
             ctx.ui.notify(msg, "error");
             await deps.stopAuto(ctx, pi, msg);
             return { action: "break", reason: "worktree-invalid" };
@@ -574,6 +584,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
+    const unitStartSeq = ic.nextSeq();
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
     deps.captureAvailableSkills();
     deps.writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
         phase: "dispatched",
@@ -683,7 +695,12 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         unitId,
         prefs,
         buildSnapshotOpts: () => deps.buildSnapshotOpts(unitType, unitId),
-        buildRecoveryContext: () => ({}),
+        buildRecoveryContext: () => ({
+            basePath: s.basePath,
+            verbose: s.verbose,
+            currentUnitStartedAt: s.currentUnit?.startedAt ?? Date.now(),
+            unitRecoveryCount: s.unitRecoveryCount,
+        }),
         pauseAuto: deps.pauseAuto,
     });
     // Write preliminary lock (no session path yet — runUnit creates a new session).
@@ -759,8 +776,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     if (s.currentUnitRouting) {
         deps.recordOutcome(unitType, s.currentUnitRouting.tier, true);
     }
-    const isHookUnit = unitType.startsWith("hook/");
-    const artifactVerified = isHookUnit ||
+    const skipArtifactVerification = unitType.startsWith("hook/") || unitType === "custom-step";
+    const artifactVerified = skipArtifactVerification ||
         deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
     if (artifactVerified) {
         s.completedUnits.push({
@@ -783,6 +800,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.unitDispatchCount.delete(`${unitType}/${unitId}`);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
     return { action: "next", data: { unitStartedAt: s.currentUnit.startedAt } };
 }
 // ─── runFinalize ──────────────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/auto/session.js

@@ -27,6 +27,8 @@ export class AutoSession {
     paused = false;
     stepMode = false;
     verbose = false;
+    activeEngineId = null;
+    activeRunDir = null;
     cmdCtx = null;
     // ── Paths ────────────────────────────────────────────────────────────────
     basePath = "";
@@ -113,6 +115,8 @@ export class AutoSession {
         this.paused = false;
         this.stepMode = false;
         this.verbose = false;
+        this.activeEngineId = null;
+        this.activeRunDir = null;
         this.cmdCtx = null;
         // Paths
         this.basePath = "";
@@ -156,6 +160,8 @@ export class AutoSession {
             paused: this.paused,
             stepMode: this.stepMode,
             basePath: this.basePath,
+            activeEngineId: this.activeEngineId,
+            activeRunDir: this.activeRunDir,
             currentMilestoneId: this.currentMilestoneId,
             currentUnit: this.currentUnit,
             completedUnits: this.completedUnits.length,

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

@@ -18,6 +18,7 @@ import { GLYPH, INDENT } from "../shared/mod.js";
 import { computeProgressScore } from "./progress-score.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -45,6 +46,7 @@ export function unitVerb(unitType) {
         case "rewrite-docs": return "rewriting";
         case "reassess-roadmap": return "reassessing";
         case "run-uat": return "running UAT";
+        case "custom-step": return "executing workflow step";
         default: return unitType;
     }
 }
@@ -63,6 +65,7 @@ export function unitPhaseLabel(unitType) {
         case "rewrite-docs": return "REWRITE";
         case "reassess-roadmap": return "REASSESS";
         case "run-uat": return "UAT";
+        case "custom-step": return "WORKFLOW";
         default: return unitType.toUpperCase();
     }
 }
@@ -370,6 +373,8 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     }
     // Pre-fetch last commit for display
     refreshLastCommit(accessors.getBasePath());
+    // Cache the effective service tier at widget creation time (reads preferences)
+    const effectiveServiceTier = getEffectiveServiceTier();
     ctx.ui.setWidget("gsd-progress", (tui, theme) => {
         let pulseBright = true;
         let cachedLines;
@@ -471,9 +476,10 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 // Model display — shown in context section, not stats
                 const modelId = cmdCtx?.model?.id ?? "";
                 const modelProvider = cmdCtx?.model?.provider ?? "";
-                const modelDisplay = modelProvider && modelId
+                const tierIcon = resolveServiceTierIcon(effectiveServiceTier, modelId);
+                const modelDisplay = (modelProvider && modelId
                     ? `${modelProvider}/${modelId}`
-                    : modelId;
+                    : modelId) + (tierIcon ? ` ${tierIcon}` : "");
                 // ── Mode: off — return empty ──────────────────────────────────
                 if (widgetMode === "off") {
                     cachedLines = [];

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

@@ -24,7 +24,7 @@ function missingSliceStop(mid, phase) {
 // ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
 const MAX_REWRITE_ATTEMPTS = 3;
 // ─── Rules ────────────────────────────────────────────────────────────────
-const DISPATCH_RULES = [
+export const DISPATCH_RULES = [
     {
         name: "rewrite-docs (override gate)",
         match: async ({ mid, midTitle, state, basePath, session }) => {
@@ -480,22 +480,39 @@ const DISPATCH_RULES = [
         },
     },
 ];
+import { getRegistry } from "./rule-registry.js";
 // ─── Resolver ─────────────────────────────────────────────────────────────
 /**
  * Evaluate dispatch rules in order. Returns the first matching action,
  * or a "stop" action if no rule matches (unhandled phase).
+ *
+ * Delegates to the RuleRegistry when initialized; falls back to inline
+ * loop over DISPATCH_RULES for backward compatibility (tests that import
+ * resolveDispatch directly without registry initialization).
  */
 export async function resolveDispatch(ctx) {
+    // Delegate to registry when available
+    try {
+        const registry = getRegistry();
+        return await registry.evaluateDispatch(ctx);
+    }
+    catch {
+        // Registry not initialized — fall back to inline loop
+    }
     for (const rule of DISPATCH_RULES) {
         const result = await rule.match(ctx);
-        if (result)
+        if (result) {
+            if (result.action !== "skip")
+                result.matchedRule = rule.name;
             return result;
+        }
     }
     // No rule matched — unhandled phase
     return {
         action: "stop",
         reason: `Unhandled phase "${ctx.state.phase}" — run /gsd doctor to diagnose.`,
         level: "info",
+        matchedRule: "<no-match>",
     };
 }
 /** Exposed for testing — returns the rule names in evaluation order. */

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

@@ -31,6 +31,7 @@ import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { uncheckTaskInPlan } from "./undo.js";
 import { atomicWriteSync } from "./atomic-write.js";
+import { _resetHasChangesCache } from "./native-git-bridge.js";
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 /**
@@ -103,6 +104,12 @@ export async function postUnitPreVerification(pctx, opts) {
                     }
                 }
             }
+            // Invalidate the nativeHasChanges cache before auto-commit (#1853).
+            // The cache has a 10-second TTL and is keyed by basePath.  A stale
+            // `false` result causes autoCommit to skip staging entirely, leaving
+            // code files only in the working tree where they are destroyed by
+            // `git worktree remove --force` during teardown.
+            _resetHasChangesCache();
             const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
             if (commitMsg) {
                 ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");

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

@@ -849,7 +849,7 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const prefs = loadEffectiveGSDPreferences();
     const commitDocsEnabled = prefs?.preferences?.git?.commit_docs !== false;
     const commitInstruction = commitDocsEnabled
-        ? `Commit the plan files only: \`git add ${relSlicePath(base, mid, sid)}/ .gsd/DECISIONS.md .gitignore && git commit -m "docs(${sid}): add slice plan"\`. Do not stage .gsd/STATE.md or other runtime files — the system manages those.`
+        ? `Commit the plan files only: \`git add --force ${relSlicePath(base, mid, sid)}/ .gsd/DECISIONS.md .gitignore && git commit -m "docs(${sid}): add slice plan"\`. Do not stage .gsd/STATE.md or other runtime files — the system manages those.`
         : "Do not commit — planning docs are not tracked in git for this project.";
     return loadPrompt("plan-slice", {
         workingDirectory: base,

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

@@ -263,10 +263,15 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // plan has no tasks, creating an infinite skip loop (#699).
     if (unitType === "plan-slice") {
         const planContent = readFileSync(absPath, "utf-8");
-        if (!/^- \[[xX ]\] \*\*T\d+:/m.test(planContent))
+        // Accept checkbox-style (- [x] **T01: ...) or heading-style (### T01 -- / ### T01: / ### T01 —)
+        const hasCheckboxTask = /^- \[[xX ]\] \*\*T\d+:/m.test(planContent);
+        const hasHeadingTask = /^#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
+        if (!hasCheckboxTask && !hasHeadingTask)
             return false;
     }
-    // execute-task must also have its checkbox marked [x] in the slice plan
+    // execute-task must also have its checkbox marked [x] in the slice plan.
+    // Heading-style plans (### T01 -- Title) have no checkbox — the task summary
+    // file existence (checked above via resolveExpectedArtifactPath) is sufficient.
     if (unitType === "execute-task") {
         const parts = unitId.split("/");
         const mid = parts[0];
@@ -277,8 +282,11 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             if (planAbs && existsSync(planAbs)) {
                 const planContent = readFileSync(planAbs, "utf-8");
                 const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                const re = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
-                if (!re.test(planContent))
+                const cbRe = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
+                const hdRe = new RegExp(`^#{2,4}\\s+${escapedTid}\\s*(?:--|—|:)`, "m");
+                // Heading-style entries count as verified (no checkbox to toggle);
+                // checkbox-style entries require [x].
+                if (!cbRe.test(planContent) && !hdRe.test(planContent))
                     return false;
             }
         }

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

@@ -11,7 +11,7 @@
 import { deriveState } from "./state.js";
 import { loadFile, getManifestStatus } from "./files.js";
 import { loadEffectiveGSDPreferences, resolveSkillDiscoveryMode, getIsolationMode, } from "./preferences.js";
-import { ensureGsdSymlink, validateProjectId } from "./repo-identity.js";
+import { ensureGsdSymlink, isInheritedRepo, validateProjectId } from "./repo-identity.js";
 import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
 import { gsdRoot, resolveMilestoneFile } from "./paths.js";
@@ -69,8 +69,13 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             ctx.ui.notify(`GSD_PROJECT_ID must contain only alphanumeric characters, hyphens, and underscores. Got: "${customProjectId}"`, "error");
             return releaseLockAndReturn();
         }
-        // Ensure git repo exists
-        if (!nativeIsRepo(base)) {
+        // Ensure git repo exists.
+        // Guard against inherited repos: if `base` is a subdirectory of another
+        // git repo that has no .gsd (i.e. the parent project was never initialised
+        // with GSD), create a fresh git repo at `base` so it gets its own identity
+        // hash. Without this, repoIdentity() resolves to the parent repo's hash
+        // and loads milestones from an unrelated project (#1639).
+        if (!nativeIsRepo(base) || isInheritedRepo(base)) {
             const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
             nativeInit(base, mainBranch);
         }

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

@@ -5,21 +5,21 @@
  * manual `/worktree` which uses `worktree/<name>` branches). This module
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
-import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync, unlinkSync, lstatSync as lstatSyncFn, } from "node:fs";
+import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync, rmSync, unlinkSync, lstatSync as lstatSyncFn, } from "node:fs";
 import { isAbsolute, join } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import { copyWorktreeDb, reconcileWorktreeDb, isDbAvailable, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
-import { execSync, execFileSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { gsdRoot } from "./paths.js";
-import { createWorktree, removeWorktree, worktreePath, } from "./worktree-manager.js";
+import { createWorktree, removeWorktree, resolveGitDir, worktreePath, } from "./worktree-manager.js";
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
 import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
 import { debugLog } from "./debug-logger.js";
 import { parseRoadmap } from "./files.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, nativeDiffNumstat, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, } from "./native-git-bridge.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 /** Original project root before chdir into auto-worktree. */
 let originalBase = null;
@@ -133,7 +133,7 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
             const mainMilestones = readdirSync(mainMilestonesDir, {
                 withFileTypes: true,
             })
-                .filter((d) => d.isDirectory() && /^M\d{3}/.test(d.name))
+                .filter((d) => d.isDirectory())
                 .map((d) => d.name);
             for (const mid of mainMilestones) {
                 const srcDir = join(mainMilestonesDir, mid);
@@ -287,7 +287,7 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
         return { synced };
     try {
         const wtMilestones = readdirSync(wtMilestonesDir, { withFileTypes: true })
-            .filter((d) => d.isDirectory() && /^M\d{3}/.test(d.name))
+            .filter((d) => d.isDirectory())
             .map((d) => d.name);
         for (const mid of wtMilestones) {
             syncMilestoneDir(wtGsd, mainGsd, mid, synced);
@@ -405,13 +405,24 @@ export function runWorktreePostCreateHook(sourceDir, worktreeDir, hookPath) {
     }
     if (!hookPath)
         return null;
-    // Resolve relative paths against the source project root
-    const resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
+    // Resolve relative paths against the source project root.
+    // On Windows, convert 8.3 short paths (e.g. RUNNER~1) to long paths
+    // so execFileSync can locate the file correctly.
+    let resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
     if (!existsSync(resolved)) {
         return `Worktree post-create hook not found: ${resolved}`;
     }
+    if (process.platform === "win32") {
+        try {
+            resolved = realpathSync.native(resolved);
+        }
+        catch { /* keep original */ }
+    }
     try {
-        execSync(resolved, {
+        // .bat/.cmd files on Windows require shell mode — execFileSync cannot
+        // spawn them directly (EINVAL).
+        const needsShell = process.platform === "win32" && /\.(bat|cmd)$/i.test(resolved);
+        execFileSync(resolved, [], {
             cwd: worktreeDir,
             env: {
                 ...process.env,
@@ -421,6 +432,7 @@ export function runWorktreePostCreateHook(sourceDir, worktreeDir, hookPath) {
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf-8",
             timeout: 30_000, // 30 second timeout
+            shell: needsShell,
         });
         return null;
     }
@@ -661,6 +673,22 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
         branch,
         deleteBranch: !preserveBranch,
     });
+    // Verify cleanup succeeded — warn if the worktree directory is still on disk.
+    // On Windows, bash-based cleanup can silently fail when paths contain
+    // backslashes (#1436), leaving ~1 GB+ orphaned directories.
+    const wtDir = worktreePath(originalBasePath, milestoneId);
+    if (existsSync(wtDir)) {
+        console.error(`[GSD] WARNING: Worktree directory still exists after teardown: ${wtDir}\n` +
+            `  This is likely an orphaned directory consuming disk space.\n` +
+            `  Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`);
+        // Attempt a direct filesystem removal as a fallback
+        try {
+            rmSync(wtDir, { recursive: true, force: true });
+        }
+        catch {
+            // Non-fatal — the warning above tells the user how to clean up
+        }
+    }
 }
 /**
  * Detect if the process is currently inside an auto-worktree.
@@ -858,6 +886,56 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         body = `\n\nCompleted slices:\n${sliceLines}\n\nBranch: ${milestoneBranch}`;
     }
     const commitMessage = subject + body;
+    // 6b. Reconcile worktree HEAD with milestone branch ref (#1846).
+    //     When the worktree HEAD detaches and advances past the named branch,
+    //     the branch ref becomes stale. Squash-merging the stale ref silently
+    //     orphans all commits between the branch ref and the actual worktree HEAD.
+    //     Fix: fast-forward the branch ref to the worktree HEAD before merging.
+    //     Only applies when merging from an actual worktree (worktreeCwd differs
+    //     from originalBasePath_).
+    if (worktreeCwd !== originalBasePath_) {
+        try {
+            const worktreeHead = execFileSync("git", ["rev-parse", "HEAD"], {
+                cwd: worktreeCwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+            }).trim();
+            const branchHead = execFileSync("git", ["rev-parse", milestoneBranch], {
+                cwd: originalBasePath_,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+            }).trim();
+            if (worktreeHead && branchHead && worktreeHead !== branchHead) {
+                if (nativeIsAncestor(originalBasePath_, branchHead, worktreeHead)) {
+                    // Worktree HEAD is strictly ahead — fast-forward the branch ref
+                    nativeUpdateRef(originalBasePath_, `refs/heads/${milestoneBranch}`, worktreeHead);
+                    debugLog("mergeMilestoneToMain", {
+                        action: "fast-forward-branch-ref",
+                        milestoneBranch,
+                        oldRef: branchHead.slice(0, 8),
+                        newRef: worktreeHead.slice(0, 8),
+                    });
+                }
+                else {
+                    // Diverged — fail loudly rather than silently losing commits
+                    process.chdir(previousCwd);
+                    throw new GSDError(GSD_GIT_ERROR, `Worktree HEAD (${worktreeHead.slice(0, 8)}) diverged from ` +
+                        `${milestoneBranch} (${branchHead.slice(0, 8)}). ` +
+                        `Manual reconciliation required before merge.`);
+                }
+            }
+        }
+        catch (err) {
+            // Re-throw GSDError (divergence); swallow rev-parse failures
+            // (e.g. worktree dir already removed by external cleanup)
+            if (err instanceof GSDError)
+                throw err;
+            debugLog("mergeMilestoneToMain", {
+                action: "reconcile-skipped",
+                reason: String(err),
+            });
+        }
+    }
     // 7. Squash merge — auto-resolve .gsd/ state file conflicts (#530)
     const mergeResult = nativeMergeSquash(originalBasePath_, milestoneBranch);
     if (!mergeResult.success) {
@@ -905,6 +983,17 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // 8. Commit (handle nothing-to-commit gracefully)
     const commitResult = nativeCommit(originalBasePath_, commitMessage);
     const nothingToCommit = commitResult === null;
+    // 8a. Clean up SQUASH_MSG left by git merge --squash (#1853).
+    // git only removes SQUASH_MSG when the commit reads it directly (plain
+    // `git commit`).  nativeCommit uses `-F -` (stdin) or libgit2, neither
+    // of which trigger git's SQUASH_MSG cleanup.  If left on disk, doctor
+    // reports `corrupt_merge_state` on every subsequent run.
+    try {
+        const squashMsgPath = join(resolveGitDir(originalBasePath_), "SQUASH_MSG");
+        if (existsSync(squashMsgPath))
+            unlinkSync(squashMsgPath);
+    }
+    catch { /* best-effort */ }
     // 8b. Safety check (#1792): if nothing was committed, verify the milestone
     // work is already on the integration branch before allowing teardown.
     // Compare only non-.gsd/ paths — .gsd/ state files diverge normally and
@@ -920,12 +1009,27 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
                 `Aborting worktree teardown to prevent data loss.`);
         }
     }
+    // 8c. Detect whether any non-.gsd/ code files were actually merged (#1906).
+    // When a milestone only produced .gsd/ metadata (summaries, roadmaps) but no
+    // real code, the user sees "milestone complete" but nothing changed in their
+    // codebase. Surface this so the caller can warn the user.
+    let codeFilesChanged = false;
+    if (!nothingToCommit) {
+        try {
+            const mergedFiles = nativeDiffNumstat(originalBasePath_, "HEAD~1", "HEAD");
+            codeFilesChanged = mergedFiles.some((entry) => !entry.path.startsWith(".gsd/"));
+        }
+        catch {
+            // If HEAD~1 doesn't exist (first commit), assume code was changed
+            codeFilesChanged = true;
+        }
+    }
     // 9. Auto-push if enabled
     let pushed = false;
     if (prefs.auto_push === true && !nothingToCommit) {
         const remote = prefs.remote ?? "origin";
         try {
-            execSync(`git push ${remote} ${mainBranch}`, {
+            execFileSync("git", ["push", remote, mainBranch], {
                 cwd: originalBasePath_,
                 stdio: ["ignore", "pipe", "pipe"],
                 encoding: "utf-8",
@@ -943,13 +1047,19 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         const prTarget = prefs.pr_target_branch ?? mainBranch;
         try {
             // Push the milestone branch to remote first
-            execSync(`git push ${remote} ${milestoneBranch}`, {
+            execFileSync("git", ["push", remote, milestoneBranch], {
                 cwd: originalBasePath_,
                 stdio: ["ignore", "pipe", "pipe"],
                 encoding: "utf-8",
             });
             // Create PR via gh CLI
-            execSync(`gh pr create --base "${prTarget}" --head "${milestoneBranch}" --title "Milestone ${milestoneId} complete" --body "Auto-created by GSD on milestone completion."`, {
+            execFileSync("gh", [
+                "pr", "create",
+                "--base", prTarget,
+                "--head", milestoneBranch,
+                "--title", `Milestone ${milestoneId} complete`,
+                "--body", "Auto-created by GSD on milestone completion.",
+            ], {
                 cwd: originalBasePath_,
                 stdio: ["ignore", "pipe", "pipe"],
                 encoding: "utf-8",
@@ -963,6 +1073,30 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // 10. Guard removed — step 8b (#1792) now handles this with a smarter check:
     //     throws only when the milestone has unanchored code changes, passes
     //     through when the code is genuinely already on the integration branch.
+    // 10a. Pre-teardown safety net (#1853): if the worktree still has uncommitted
+    // changes (e.g. nativeHasChanges cache returned stale false, or auto-commit
+    // silently failed), force one final commit so code is not destroyed by
+    // `git worktree remove --force`.
+    if (existsSync(worktreeCwd)) {
+        try {
+            const dirtyCheck = nativeWorkingTreeStatus(worktreeCwd);
+            if (dirtyCheck) {
+                debugLog("mergeMilestoneToMain", {
+                    phase: "pre-teardown-dirty",
+                    worktreeCwd,
+                    status: dirtyCheck.slice(0, 200),
+                });
+                nativeAddAllWithExclusions(worktreeCwd, RUNTIME_EXCLUSION_PATHS);
+                nativeCommit(worktreeCwd, "chore: pre-teardown auto-commit of uncommitted worktree changes");
+            }
+        }
+        catch (e) {
+            debugLog("mergeMilestoneToMain", {
+                phase: "pre-teardown-commit-error",
+                error: String(e),
+            });
+        }
+    }
     // 11. Remove worktree directory first (must happen before branch deletion)
     try {
         removeWorktree(originalBasePath_, milestoneId, {
@@ -983,5 +1117,5 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // 13. Clear module state
     originalBase = null;
     nudgeGitBranchCache(previousCwd);
-    return { commitMessage, pushed, prCreated };
+    return { commitMessage, pushed, prCreated, codeFilesChanged };
 }