gsd-pi 2.10.12 → 2.12.0

package/src/resources/extensions/gsd/guided-flow.ts

@@ -9,10 +9,12 @@
 import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 import { showNextAction } from "../shared/next-action-ui.js";
 import { loadFile, parseRoadmap } from "./files.js";
-import { loadPrompt } from "./prompt-loader.js";
+import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { deriveState } from "./state.js";
 import { startAuto } from "./auto.js";
 import { readCrashLock, clearLock, formatCrashInfo } from "./crash-recovery.js";
+import { listUnitRuntimeRecords, clearUnitRuntimeRecord } from "./unit-runtime.js";
+import { resolveExpectedArtifactPath } from "./auto.js";
 import {
   gsdRoot, milestonesDir, resolveMilestoneFile, resolveMilestonePath,
   resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile,
@@ -97,11 +99,19 @@ function dispatchWorkflow(pi: ExtensionAPI, note: string, customType = "gsd-run"
  */
 function buildDiscussPrompt(nextId: string, preamble: string, _basePath: string): string {
   const milestoneRel = `.gsd/milestones/${nextId}`;
+  const inlinedTemplates = [
+    inlineTemplate("project", "Project"),
+    inlineTemplate("requirements", "Requirements"),
+    inlineTemplate("context", "Context"),
+    inlineTemplate("roadmap", "Roadmap"),
+    inlineTemplate("decisions", "Decisions"),
+  ].join("\n\n---\n\n");
   return loadPrompt("discuss", {
     milestoneId: nextId,
     preamble,
     contextPath: `${milestoneRel}/${nextId}-CONTEXT.md`,
     roadmapPath: `${milestoneRel}/${nextId}-ROADMAP.md`,
+    inlinedTemplates,
   });
 }
 
@@ -234,11 +244,13 @@ export async function showQueue(
   ].join(" ");
 
   // ── Dispatch the queue prompt ───────────────────────────────────────
+  const queueInlinedTemplates = inlineTemplate("context", "Context");
   const prompt = loadPrompt("queue", {
     preamble,
     nextId,
     nextIdPlus1,
     existingMilestonesContext: existingContext,
+    inlinedTemplates: queueInlinedTemplates,
   });
 
   pi.sendMessage(
@@ -415,6 +427,7 @@ async function buildDiscussSlicePrompt(
   const sliceDirPath = `.gsd/milestones/${mid}/slices/${sid}`;
   const sliceContextPath = `${sliceDirPath}/${sid}-CONTEXT.md`;
 
+  const inlinedTemplates = inlineTemplate("slice-context", "Slice Context");
   return loadPrompt("guided-discuss-slice", {
     milestoneId: mid,
     sliceId: sid,
@@ -423,6 +436,7 @@ async function buildDiscussSlicePrompt(
     sliceDirPath,
     contextPath: sliceContextPath,
     projectRoot: base,
+    inlinedTemplates,
   });
 }
 
@@ -506,6 +520,42 @@ export async function showDiscuss(
 /**
  * The one wizard. Reads state, shows contextual options, dispatches into the workflow doc.
  */
+/**
+ * Self-heal: scan runtime records and clear stale ones left behind when
+ * auto-mode crashed mid-unit. auto.ts has its own selfHealRuntimeRecords()
+ * but guided-flow (manual /gsd mode) never called it — meaning stale records
+ * persisted until the next /gsd auto run.  This ensures the wizard always
+ * starts from a clean state regardless of how the previous session ended.
+ */
+function selfHealRuntimeRecords(basePath: string, ctx: ExtensionContext): { cleared: number } {
+  try {
+    const records = listUnitRuntimeRecords(basePath);
+    let cleared = 0;
+    for (const record of records) {
+      const { unitType, unitId, phase } = record;
+      // Clear records whose expected artifact already exists (completed but not cleaned up)
+      const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
+      if (artifactPath && existsSync(artifactPath)) {
+        clearUnitRuntimeRecord(basePath, unitType, unitId);
+        cleared++;
+        continue;
+      }
+      // Clear records stuck in dispatched or timeout phase (process died mid-unit)
+      if (phase === "dispatched" || phase === "timeout") {
+        clearUnitRuntimeRecord(basePath, unitType, unitId);
+        cleared++;
+      }
+    }
+    if (cleared > 0) {
+      ctx.ui.notify(`Self-heal: cleared ${cleared} stale runtime record(s) from a previous session.`, "info");
+    }
+    return { cleared };
+  } catch {
+    // Non-fatal — self-heal should never block the wizard
+    return { cleared: 0 };
+  }
+}
+
 export async function showSmartEntry(
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI,
@@ -544,6 +594,9 @@ export async function showSmartEntry(
     }
   }
 
+  // ── Self-heal stale runtime records from crashed auto-mode sessions ──
+  selfHealRuntimeRecords(basePath, ctx);
+
   // Check for crash from previous auto-mode session
   const crashLock = readCrashLock(basePath);
   if (crashLock) {
@@ -683,8 +736,9 @@ export async function showSmartEntry(
     });
 
     if (choice === "discuss_draft") {
+      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       const basePrompt = loadPrompt("guided-discuss-milestone", {
-        milestoneId, milestoneTitle,
+        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
       });
       const seed = draftContent
         ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
@@ -692,9 +746,10 @@ export async function showSmartEntry(
       pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
       dispatchWorkflow(pi, seed, "gsd-discuss");
     } else if (choice === "discuss_fresh") {
+      const discussMilestoneTemplates = inlineTemplate("context", "Context");
       pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
       dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-        milestoneId, milestoneTitle,
+        milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
       }), "gsd-discuss");
     } else if (choice === "skip_milestone") {
       const milestoneIds = findMilestoneIds(basePath);
@@ -753,13 +808,20 @@ export async function showSmartEntry(
       });
 
       if (choice === "plan") {
+        const planMilestoneTemplates = [
+          inlineTemplate("roadmap", "Roadmap"),
+          inlineTemplate("plan", "Slice Plan"),
+          inlineTemplate("task-plan", "Task Plan"),
+          inlineTemplate("secrets-manifest", "Secrets Manifest"),
+        ].join("\n\n---\n\n");
         const secretsOutputPath = relMilestoneFile(basePath, milestoneId, "SECRETS");
         dispatchWorkflow(pi, loadPrompt("guided-plan-milestone", {
-          milestoneId, milestoneTitle, secretsOutputPath,
+          milestoneId, milestoneTitle, secretsOutputPath, inlinedTemplates: planMilestoneTemplates,
         }));
       } else if (choice === "discuss") {
+        const discussMilestoneTemplates = inlineTemplate("context", "Context");
         dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-          milestoneId, milestoneTitle,
+          milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates,
         }));
       } else if (choice === "skip_milestone") {
         const milestoneIds = findMilestoneIds(basePath);
@@ -866,14 +928,19 @@ export async function showSmartEntry(
     });
 
     if (choice === "plan") {
+      const planSliceTemplates = [
+        inlineTemplate("plan", "Slice Plan"),
+        inlineTemplate("task-plan", "Task Plan"),
+      ].join("\n\n---\n\n");
       dispatchWorkflow(pi, loadPrompt("guided-plan-slice", {
-        milestoneId, sliceId, sliceTitle,
+        milestoneId, sliceId, sliceTitle, inlinedTemplates: planSliceTemplates,
       }));
     } else if (choice === "discuss") {
       dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath));
     } else if (choice === "research") {
+      const researchTemplates = inlineTemplate("research", "Research");
       dispatchWorkflow(pi, loadPrompt("guided-research-slice", {
-        milestoneId, sliceId, sliceTitle,
+        milestoneId, sliceId, sliceTitle, inlinedTemplates: researchTemplates,
       }));
     } else if (choice === "status") {
       const { fireStatusViaCommand } = await import("./commands.js");
@@ -904,8 +971,12 @@ export async function showSmartEntry(
     });
 
     if (choice === "complete") {
+      const completeSliceTemplates = [
+        inlineTemplate("slice-summary", "Slice Summary"),
+        inlineTemplate("uat", "UAT"),
+      ].join("\n\n---\n\n");
       dispatchWorkflow(pi, loadPrompt("guided-complete-slice", {
-        milestoneId, sliceId, sliceTitle,
+        milestoneId, sliceId, sliceTitle, inlinedTemplates: completeSliceTemplates,
       }));
     } else if (choice === "status") {
       const { fireStatusViaCommand } = await import("./commands.js");
@@ -965,8 +1036,9 @@ export async function showSmartEntry(
           milestoneId, sliceId,
         }));
       } else {
+        const executeTaskTemplates = inlineTemplate("task-summary", "Task Summary");
         dispatchWorkflow(pi, loadPrompt("guided-execute-task", {
-          milestoneId, sliceId, taskId, taskTitle,
+          milestoneId, sliceId, taskId, taskTitle, inlinedTemplates: executeTaskTemplates,
         }));
       }
     } else if (choice === "status") {

package/src/resources/extensions/gsd/index.ts

@@ -39,6 +39,8 @@ import {
   loadEffectiveGSDPreferences,
   renderPreferencesForSystemPrompt,
   resolveAllSkillReferences,
+  resolveModelWithFallbacksForUnit,
+  getNextFallbackModel,
 } from "./preferences.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "./skill-discovery.js";
 import {
@@ -339,12 +341,71 @@ export default function (pi: ExtensionAPI) {
         "errorMessage" in lastMsg && lastMsg.errorMessage
           ? `: ${lastMsg.errorMessage}`
           : "";
+
+      const dash = getAutoDashboardData();
+      if (dash.currentUnit) {
+        const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
+        if (modelConfig && modelConfig.fallbacks.length > 0) {
+          const availableModels = ctx.modelRegistry.getAvailable();
+          const currentModelId = ctx.model?.id;
+
+          const nextModelId = getNextFallbackModel(currentModelId, modelConfig);
+
+          if (nextModelId) {
+            let modelToSet;
+            const slashIdx = nextModelId.indexOf("/");
+            if (slashIdx !== -1) {
+              const provider = nextModelId.substring(0, slashIdx);
+              const id = nextModelId.substring(slashIdx + 1);
+              modelToSet = availableModels.find(
+                m => m.provider.toLowerCase() === provider.toLowerCase()
+                  && m.id.toLowerCase() === id.toLowerCase()
+              );
+            } else {
+              const currentProvider = ctx.model?.provider;
+              const exactProviderMatch = availableModels.find(
+                m => m.id === nextModelId && m.provider === currentProvider
+              );
+              modelToSet = exactProviderMatch ?? availableModels.find(m => m.id === nextModelId);
+            }
+
+            if (modelToSet) {
+              const ok = await pi.setModel(modelToSet, { persist: false });
+              if (ok) {
+                ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
+                // Trigger a generic "Continue execution" to resume the task since the previous attempt failed
+                pi.sendMessage(
+                  { customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false },
+                  { triggerTurn: true }
+                );
+                return;
+              }
+            }
+          }
+        }
+      }
+
       (ctx as any).log(`Auto-mode paused due to provider error${errorDetail}`);
       await pauseAuto(ctx, pi);
       return;
     }
 
-    await handleAgentEnd(ctx, pi);
+    try {
+      await handleAgentEnd(ctx, pi);
+    } catch (err) {
+      // Safety net: if handleAgentEnd throws despite its internal try-catch,
+      // ensure auto-mode stops gracefully instead of silently stalling (#381).
+      const message = err instanceof Error ? err.message : String(err);
+      ctx.ui.notify(
+        `Auto-mode error in agent_end handler: ${message}. Stopping auto-mode.`,
+        "error",
+      );
+      try {
+        await pauseAuto(ctx, pi);
+      } catch {
+        // Last resort — at least log
+      }
+    }
   });
 
   // ── session_before_compact ────────────────────────────────────────────────

package/src/resources/extensions/gsd/native-git-bridge.ts

@@ -0,0 +1,181 @@
+// Native Git Bridge
+// Provides fast READ-ONLY git operations backed by libgit2 via the Rust native module.
+// Falls back to execSync git commands when the native module is unavailable.
+//
+// Only READ operations are native — WRITE operations (commit, merge, checkout, push)
+// remain as execSync calls in git-service.ts.
+
+import { execSync } from "node:child_process";
+
+/** Env overlay that suppresses interactive git credential prompts and git-svn noise. */
+const GIT_NO_PROMPT_ENV = {
+  ...process.env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_ASKPASS: "",
+  GIT_SVN_ID: "",
+};
+
+let nativeModule: {
+  gitCurrentBranch: (repoPath: string) => string | null;
+  gitMainBranch: (repoPath: string) => string;
+  gitBranchExists: (repoPath: string, branch: string) => boolean;
+  gitHasMergeConflicts: (repoPath: string) => boolean;
+  gitWorkingTreeStatus: (repoPath: string) => string;
+  gitHasChanges: (repoPath: string) => boolean;
+  gitCommitCountBetween: (repoPath: string, fromRef: string, toRef: string) => number;
+} | null = null;
+
+let loadAttempted = false;
+
+function loadNative(): typeof nativeModule {
+  if (loadAttempted) return nativeModule;
+  loadAttempted = true;
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require("@gsd/native");
+    if (mod.gitCurrentBranch && mod.gitHasChanges) {
+      nativeModule = mod;
+    }
+  } catch {
+    // Native module not available — all functions fall back to git CLI
+  }
+
+  return nativeModule;
+}
+
+/** Run a git command via execSync. Returns trimmed stdout. */
+function gitExec(basePath: string, args: string[], allowFailure = false): string {
+  try {
+    return execSync(`git ${args.join(" ")}`, {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+    }).trim();
+  } catch {
+    if (allowFailure) return "";
+    throw new Error(`git ${args.join(" ")} failed in ${basePath}`);
+  }
+}
+
+/**
+ * Get the current branch name.
+ * Native: reads HEAD symbolic ref via libgit2.
+ * Fallback: `git branch --show-current`.
+ */
+export function nativeGetCurrentBranch(basePath: string): string {
+  const native = loadNative();
+  if (native) {
+    const branch = native.gitCurrentBranch(basePath);
+    return branch ?? "";
+  }
+  return gitExec(basePath, ["branch", "--show-current"]);
+}
+
+/**
+ * Detect the repo-level main branch (origin/HEAD → main → master → current).
+ * Native: checks refs via libgit2.
+ * Fallback: `git symbolic-ref` + `git show-ref` chain.
+ *
+ * Note: milestone integration branch and worktree detection are handled
+ * by the caller (GitServiceImpl.getMainBranch) — this only covers the
+ * repo-level default detection that spawned multiple git processes.
+ */
+export function nativeDetectMainBranch(basePath: string): string {
+  const native = loadNative();
+  if (native) {
+    return native.gitMainBranch(basePath);
+  }
+
+  // Fallback: same logic as GitServiceImpl.getMainBranch() repo-level detection
+  const symbolic = gitExec(basePath, ["symbolic-ref", "refs/remotes/origin/HEAD"], true);
+  if (symbolic) {
+    const match = symbolic.match(/refs\/remotes\/origin\/(.+)$/);
+    if (match) return match[1]!;
+  }
+
+  const mainExists = gitExec(basePath, ["show-ref", "--verify", "refs/heads/main"], true);
+  if (mainExists) return "main";
+
+  const masterExists = gitExec(basePath, ["show-ref", "--verify", "refs/heads/master"], true);
+  if (masterExists) return "master";
+
+  return gitExec(basePath, ["branch", "--show-current"]);
+}
+
+/**
+ * Check if a local branch exists.
+ * Native: checks refs/heads/<name> via libgit2.
+ * Fallback: `git show-ref --verify`.
+ */
+export function nativeBranchExists(basePath: string, branch: string): boolean {
+  const native = loadNative();
+  if (native) {
+    return native.gitBranchExists(basePath, branch);
+  }
+  const result = gitExec(basePath, ["show-ref", "--verify", `refs/heads/${branch}`], true);
+  return result !== "";
+}
+
+/**
+ * Check if the index has unmerged entries (merge conflicts).
+ * Native: reads index conflict state via libgit2.
+ * Fallback: `git diff --name-only --diff-filter=U`.
+ */
+export function nativeHasMergeConflicts(basePath: string): boolean {
+  const native = loadNative();
+  if (native) {
+    return native.gitHasMergeConflicts(basePath);
+  }
+  const result = gitExec(basePath, ["diff", "--name-only", "--diff-filter=U"], true);
+  return result !== "";
+}
+
+/**
+ * Get working tree status (porcelain format).
+ * Native: reads status via libgit2.
+ * Fallback: `git status --porcelain`.
+ */
+export function nativeWorkingTreeStatus(basePath: string): string {
+  const native = loadNative();
+  if (native) {
+    return native.gitWorkingTreeStatus(basePath);
+  }
+  return gitExec(basePath, ["status", "--porcelain"], true);
+}
+
+/**
+ * Quick check: any staged or unstaged changes?
+ * Native: libgit2 status check (single syscall).
+ * Fallback: `git status --short`.
+ */
+export function nativeHasChanges(basePath: string): boolean {
+  const native = loadNative();
+  if (native) {
+    return native.gitHasChanges(basePath);
+  }
+  const result = gitExec(basePath, ["status", "--short"], true);
+  return result !== "";
+}
+
+/**
+ * Count commits between two refs (from..to).
+ * Native: libgit2 revwalk.
+ * Fallback: `git rev-list --count from..to`.
+ */
+export function nativeCommitCountBetween(basePath: string, fromRef: string, toRef: string): number {
+  const native = loadNative();
+  if (native) {
+    return native.gitCommitCountBetween(basePath, fromRef, toRef);
+  }
+  const result = gitExec(basePath, ["rev-list", "--count", `${fromRef}..${toRef}`], true);
+  return parseInt(result, 10) || 0;
+}
+
+/**
+ * Check if the native git module is available.
+ */
+export function isNativeGitAvailable(): boolean {
+  return loadNative() !== null;
+}

package/src/resources/extensions/gsd/paths.ts

@@ -9,9 +9,40 @@
  * via prefix matching, so existing projects work without migration.
  */
 
-import { readdirSync, existsSync } from "node:fs";
+import { readdirSync, existsSync, Dirent } from "node:fs";
 import { join } from "node:path";
 
+// ─── Directory Listing Cache ──────────────────────────────────────────────────
+
+const dirEntryCache = new Map<string, Dirent[]>();
+const dirListCache = new Map<string, string[]>();
+
+function cachedReaddirWithTypes(dirPath: string): Dirent[] {
+  const cached = dirEntryCache.get(dirPath);
+  if (cached) return cached;
+  const entries = readdirSync(dirPath, { withFileTypes: true });
+  dirEntryCache.set(dirPath, entries);
+  return entries;
+}
+
+function cachedReaddir(dirPath: string): string[] {
+  const cached = dirListCache.get(dirPath);
+  if (cached) return cached;
+  const entries = readdirSync(dirPath);
+  dirListCache.set(dirPath, entries);
+  return entries;
+}
+
+/**
+ * Clear the directory listing cache.
+ * Call after milestone transitions, file creation in planning directories,
+ * or at the start/end of a dispatch cycle.
+ */
+export function clearPathCache(): void {
+  dirEntryCache.clear();
+  dirListCache.clear();
+}
+
 // ─── Name Builders ─────────────────────────────────────────────────────────
 
 /**
@@ -58,7 +89,7 @@ export function buildTaskFileName(taskId: string, suffix: string): string {
 export function resolveDir(parentDir: string, idPrefix: string): string | null {
   if (!existsSync(parentDir)) return null;
   try {
-    const entries = readdirSync(parentDir, { withFileTypes: true });
+    const entries = cachedReaddirWithTypes(parentDir);
     // Exact match first (current convention: bare ID)
     const exact = entries.find(e => e.isDirectory() && e.name === idPrefix);
     if (exact) return exact.name;
@@ -83,7 +114,7 @@ export function resolveFile(dir: string, idPrefix: string, suffix: string): stri
   if (!existsSync(dir)) return null;
   const target = `${idPrefix}-${suffix}.md`.toUpperCase();
   try {
-    const entries = readdirSync(dir);
+    const entries = cachedReaddir(dir);
     // Direct match: ID-SUFFIX.md
     const direct = entries.find(e => e.toUpperCase() === target);
     if (direct) return direct;
@@ -113,7 +144,7 @@ export function resolveTaskFiles(tasksDir: string, suffix: string): string[] {
     const currentPattern = new RegExp(`^T\\d+-${suffix}\\.md$`, "i");
     // Legacy convention: T01-INSTALL-PACKAGES-PLAN.md
     const legacyPattern = new RegExp(`^T\\d+-.*-${suffix}\\.md$`, "i");
-    return readdirSync(tasksDir)
+    return cachedReaddir(tasksDir)
       .filter(f => currentPattern.test(f) || legacyPattern.test(f))
       .sort();
   } catch {