gsd-pi 2.41.0 → 2.42.0-dev.97e9e30

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 };
 }

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

@@ -46,7 +46,9 @@ import { createAutoWorktree, enterAutoWorktree, teardownAutoWorktree, isInAutoWo
 import { pruneQueueOrder } from "./queue-order.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { verifyExpectedArtifact, reconcileMergeState, } from "./auto-recovery.js";
-import { resolveDispatch } from "./auto-dispatch.js";
+import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
+import { initRegistry, convertDispatchRules } from "./rule-registry.js";
+import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
 import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, hideFooter, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable } from "./gsd-db.js";
@@ -159,6 +161,18 @@ export function isAutoActive() {
 export function isAutoPaused() {
     return s.paused;
 }
+export function setActiveEngineId(id) {
+    s.activeEngineId = id;
+}
+export function getActiveEngineId() {
+    return s.activeEngineId;
+}
+export function setActiveRunDir(runDir) {
+    s.activeRunDir = runDir;
+}
+export function getActiveRunDir() {
+    return s.activeRunDir;
+}
 /**
  * Return the model captured at auto-mode start for this session.
  * Used by error-recovery to fall back to the session's own model
@@ -298,6 +312,31 @@ function handleLostSessionLock(ctx, lockStatus) {
     ctx?.ui.setWidget("gsd-progress", undefined);
     ctx?.ui.setFooter(undefined);
 }
+/**
+ * Lightweight cleanup after autoLoop exits via step-wizard break.
+ *
+ * Unlike stopAuto (which tears down the entire session), this only clears
+ * the stale unit state, progress widget, status badge, and restores CWD so
+ * the dashboard does not show an orphaned timer and the shell is usable.
+ */
+function cleanupAfterLoopExit(ctx) {
+    s.currentUnit = null;
+    s.active = false;
+    clearUnitTimeout();
+    ctx.ui.setStatus("gsd-auto", undefined);
+    ctx.ui.setWidget("gsd-progress", undefined);
+    ctx.ui.setFooter(undefined);
+    // Restore CWD out of worktree back to original project root
+    if (s.originalBasePath) {
+        s.basePath = s.originalBasePath;
+        try {
+            process.chdir(s.basePath);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}
 export async function stopAuto(ctx, pi, reason) {
     if (!s.active && !s.paused)
         return;
@@ -504,6 +543,8 @@ export async function pauseAuto(ctx, _pi) {
             stepMode: s.stepMode,
             pausedAt: new Date().toISOString(),
             sessionFile: s.pausedSessionFile,
+            activeEngineId: s.activeEngineId,
+            activeRunDir: s.activeRunDir,
         };
         const runtimeDir = join(gsdRoot(s.originalBasePath || s.basePath), "runtime");
         mkdirSync(runtimeDir, { recursive: true });
@@ -585,6 +626,10 @@ function buildResolver() {
  * This bundles all private functions that autoLoop needs without exporting them.
  */
 function buildLoopDeps() {
+    // Initialize the unified rule registry with converted dispatch rules.
+    // Must happen before LoopDeps is assembled so facade functions
+    // (resolveDispatch, runPreDispatchHooks, etc.) delegate to the registry.
+    initRegistry(convertDispatchRules(DISPATCH_RULES));
     return {
         lockBase,
         buildSnapshotOpts,
@@ -679,6 +724,8 @@ function buildLoopDeps() {
                 return "";
             }
         },
+        // Journal
+        emitJournalEvent: (entry) => _emitJournalEvent(s.basePath, entry),
     };
 }
 export async function startAuto(ctx, pi, base, verboseMode, options) {
@@ -692,7 +739,20 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             const pausedPath = join(gsdRoot(base), "runtime", "paused-session.json");
             if (existsSync(pausedPath)) {
                 const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
-                if (meta.milestoneId) {
+                if (meta.activeEngineId && meta.activeEngineId !== "dev") {
+                    // Custom workflow resume — restore engine state
+                    s.activeEngineId = meta.activeEngineId;
+                    s.activeRunDir = meta.activeRunDir ?? null;
+                    s.originalBasePath = meta.originalBasePath || base;
+                    s.stepMode = meta.stepMode ?? requestedStepMode;
+                    s.paused = true;
+                    try {
+                        unlinkSync(pausedPath);
+                    }
+                    catch { /* non-fatal */ }
+                    ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
+                }
+                else if (meta.milestoneId) {
                     // Validate the milestone still exists and isn't already complete (#1664).
                     const mDir = resolveMilestonePath(base, meta.milestoneId);
                     const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
@@ -802,6 +862,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // Clear orphaned runtime records from prior process deaths before entering the loop
         await selfHealRuntimeRecords(s.basePath, ctx);
         await autoLoop(ctx, pi, s, buildLoopDeps());
+        cleanupAfterLoopExit(ctx);
         return;
     }
     // ── Fresh start path — delegated to auto-start.ts ──
@@ -825,6 +886,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     await selfHealRuntimeRecords(s.basePath, ctx);
     // Dispatch the first unit
     await autoLoop(ctx, pi, s, buildLoopDeps());
+    cleanupAfterLoopExit(ctx);
 }
 // ─── Agent End Handler ────────────────────────────────────────────────────────
 /**