gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.1b44e695b

package/src/resources/extensions/gsd/guided-unit-context.ts

@@ -0,0 +1,30 @@
+// GSD-2 — Guided workflow Unit context.
+// Tracks the guided Unit whose queued turn should use manifest Tool Contract policy.
+
+export interface GuidedUnitContext {
+  basePath: string;
+  unitType: string;
+  startedAt: number;
+}
+
+const guidedUnitContextByBasePath = new Map<string, GuidedUnitContext>();
+
+export function setGuidedUnitContext(basePath: string, unitType: string): GuidedUnitContext {
+  const context = { basePath, unitType, startedAt: Date.now() };
+  guidedUnitContextByBasePath.set(basePath, context);
+  return context;
+}
+
+export function getGuidedUnitContext(basePath?: string): GuidedUnitContext | null {
+  if (basePath) return guidedUnitContextByBasePath.get(basePath) ?? null;
+  if (guidedUnitContextByBasePath.size === 1) return guidedUnitContextByBasePath.values().next().value!;
+  return null;
+}
+
+export function clearGuidedUnitContext(basePath?: string): void {
+  if (basePath) {
+    guidedUnitContextByBasePath.delete(basePath);
+  } else {
+    guidedUnitContextByBasePath.clear();
+  }
+}

package/src/resources/extensions/gsd/init-wizard.ts

@@ -421,7 +421,13 @@ export async function handleReinit(
       {
         id: "prefs",
         label: "Re-configure preferences",
-        description: "Update project preferences without affecting milestones",
+        description: "Run the preferences wizard without affecting milestones",
+        recommended: true,
+      },
+      {
+        id: "skills",
+        label: "Suggest & install skills",
+        description: "Detect project type and offer matching skill packs",
         recommended: true,
       },
       {
@@ -434,7 +440,16 @@ export async function handleReinit(
   });
 
   if (choice === "prefs") {
-    ctx.ui.notify("Use /gsd prefs project to update project preferences.", "info");
+    await handlePrefsWizard(ctx, "project");
+    return;
+  }
+
+  if (choice === "skills") {
+    try {
+      await runSkillInstallStep(ctx, detection.projectSignals);
+    } catch {
+      // Non-fatal — suggestion/install failures should not break re-init flow
+    }
   }
 }
 

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

@@ -65,7 +65,14 @@ export type JournalEventType =
   | "milestone-resquash"
   // dispatch telemetry — measure agent/subagent invocation frequency and shape
   | "subagent-invoked"
-  | "subagent-completed";
+  | "subagent-completed"
+  // auto orchestrator telemetry namespace (kept separate from auto-loop events)
+  | "orchestrator-iteration-start"
+  | "orchestrator-dispatch-match"
+  | "orchestrator-dispatch-stop"
+  | "orchestrator-guard-block"
+  | "orchestrator-terminal"
+  | "orchestrator-iteration-end";
 
 /** A single structured event in the journal. */
 export interface JournalEntry {

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -32,7 +32,7 @@ import {
   resolveMilestoneFile,
   resolveSliceFile,
   resolveSlicePath,
-  resolveTasksDir,
+  gsdProjectionRoot,
   gsdRoot,
   buildTaskFileName,
   buildSliceFileName,
@@ -48,7 +48,11 @@ import { clearPathCache } from "./paths.js";
  * E.g. "/project/.gsd/milestones/M001/M001-ROADMAP.md" → "milestones/M001/M001-ROADMAP.md"
  */
 function toArtifactPath(absPath: string, basePath: string): string {
-  const root = gsdRoot(basePath);
+  const projectionRoot = gsdProjectionRoot(basePath);
+  const projectionRel = relative(projectionRoot, absPath);
+  const root = projectionRel && !projectionRel.startsWith("..") && !projectionRel.startsWith("/")
+    ? projectionRoot
+    : gsdRoot(basePath);
   const rel = relative(root, absPath);
   // Normalize to forward slashes for consistent DB keys
   return rel.replace(/\\/g, "/");
@@ -374,10 +378,9 @@ export async function renderPlanFromDb(
     throw new Error(`no tasks found for ${milestoneId}/${sliceId}`);
   }
 
-  const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-    ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId);
-  const absPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN")
-    ?? join(slicePath, `${sliceId}-PLAN.md`);
+  const slicePath = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId);
+  mkdirSync(slicePath, { recursive: true });
+  const absPath = join(slicePath, `${sliceId}-PLAN.md`);
   const artifactPath = toArtifactPath(absPath, basePath);
   const sliceGates = getGateResults(milestoneId, sliceId, "slice");
   const content = renderSlicePlanMarkdown(slice, tasks, sliceGates);
@@ -408,8 +411,7 @@ export async function renderTaskPlanFromDb(
     throw new Error(`task ${milestoneId}/${sliceId}/${taskId} not found`);
   }
 
-  const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId)
-    ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
+  const tasksDir = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
   mkdirSync(tasksDir, { recursive: true });
   const absPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
   const artifactPath = toArtifactPath(absPath, basePath);
@@ -786,11 +788,12 @@ export function detectStaleRenders(basePath: string): StaleEntry[] {
   const _require = createRequire(import.meta.url);
   let parseRoadmap: Function, parsePlan: Function;
   try {
-    const m = _require("./parsers-legacy.ts");
+    // Prefer compiled JS for packaged/runtime installs; TS exists only in source/dev contexts.
+    const m = _require("./parsers-legacy.js");
     parseRoadmap = m.parseRoadmap; parsePlan = m.parsePlan;
   } catch (e) {
-    logWarning("renderer", `parsers-legacy.ts require failed, falling back to .js: ${(e as Error).message}`);
-    const m = _require("./parsers-legacy.js");
+    logWarning("renderer", `parsers-legacy.js require failed, falling back to .ts: ${(e as Error).message}`);
+    const m = _require("./parsers-legacy.ts");
     parseRoadmap = m.parseRoadmap; parsePlan = m.parsePlan;
   }
 

package/src/resources/extensions/gsd/mcp-filter.ts

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import type { ClaudeCodeMcpConfig } from "./preferences-types.js";
+import { resolveModelMcpConfig } from "./preferences-mcp.js";
+
+interface McpJsonFile {
+  mcpServers?: Record<string, unknown>;
+}
+
+interface ClaudeSettingsFile {
+  mcpServers?: Record<string, unknown>;
+}
+
+export function discoverMcpServerNames(projectDir: string): string[] {
+  const mcpJsonPath = resolve(projectDir, ".mcp.json");
+  const settingsPath = resolve(projectDir, ".claude", "settings.json");
+
+  let mcpJsonServers: string[] = [];
+  if (existsSync(mcpJsonPath)) {
+    const raw = readFileSync(mcpJsonPath, "utf-8");
+    const parsed = JSON.parse(raw) as McpJsonFile;
+    mcpJsonServers = Object.keys(parsed.mcpServers ?? {});
+  }
+
+  let settingsServers: string[] = [];
+  if (existsSync(settingsPath)) {
+    try {
+      const raw = readFileSync(settingsPath, "utf-8");
+      const parsed = JSON.parse(raw) as ClaudeSettingsFile;
+      if (parsed.mcpServers) {
+        settingsServers = Object.keys(parsed.mcpServers);
+      }
+    } catch {
+      // settings.json parse errors are silently ignored
+    }
+  }
+
+  return [...new Set([...mcpJsonServers, ...settingsServers])];
+}
+
+export function computeMcpDisallowedTools(
+  modelId: string,
+  mcpConfig: ClaudeCodeMcpConfig | undefined,
+  discoveredServers: string[],
+  workflowServerName: string | undefined,
+): string[] {
+  if (!mcpConfig) return [];
+
+  const entry = resolveModelMcpConfig(modelId, mcpConfig);
+  if (!entry) return [];
+
+  const allServers = [...discoveredServers, ...(workflowServerName ? [workflowServerName] : [])];
+  const blocked = new Set<string>();
+
+  // Allowlist phase: block every server NOT in the allowlist (except workflowServerName)
+  if (entry.allowed_servers !== undefined) {
+    const allowSet = new Set(entry.allowed_servers);
+    for (const server of allServers) {
+      if (server === workflowServerName) continue;
+      if (!allowSet.has(server)) {
+        blocked.add(server);
+      }
+    }
+  }
+
+  // Blocklist phase: explicitly blocked servers are added
+  if (entry.blocked_servers !== undefined) {
+    for (const server of entry.blocked_servers) {
+      blocked.add(server);
+    }
+  }
+
+  // gsd-workflow implicit allow: remove unless explicitly in blocked_servers
+  if (workflowServerName && !(entry.blocked_servers ?? []).includes(workflowServerName)) {
+    blocked.delete(workflowServerName);
+  }
+
+  return [...blocked].map((name) => `mcp__${name}__*`);
+}

package/src/resources/extensions/gsd/migrate/parsers.ts

@@ -67,6 +67,7 @@ function parsePhaseEntry(line: string): PlanningRoadmapEntry | null {
     let title = fmtPhaseColon[3].trim();
     // Strip trailing parentheticals, plan counts, and completion notes
     title = title.replace(/\s*\(\d+\/\d+\s+plans?\)/, '')
+                 .replace(/\s*[—–]\s+.*$/, '') // strip em/en-dash description suffix
                  .replace(/\s*--\s+.*$/, '')
                  .replace(/\s*-\s+.*$/, '')  // strip "- description" suffix
                  .replace(/\s*\(completed.*\)$/i, '')
@@ -95,6 +96,17 @@ function parsePhaseEntry(line: string): PlanningRoadmapEntry | null {
     };
   }
 
+  // Format 3: - ✅ v1.0 MVP — Phases 1-6
+  const fmtVersionPhases = stripped.match(/^-\s+([✅🚧])\s+v\d+(?:\.\d+)*\s+(.+?)\s*[—–]\s*Phases?\s+(\d+(?:\.\d+)?)(?:\s*-\s*\d+(?:\.\d+)?)?(?:\s+\(.*\))?\s*$/iu);
+  if (fmtVersionPhases) {
+    return {
+      number: parseFloat(fmtVersionPhases[3]),
+      title: fmtVersionPhases[2].trim(),
+      done: fmtVersionPhases[1] === '✅',
+      raw: line,
+    };
+  }
+
   return null;
 }
 
@@ -147,7 +159,14 @@ export function parseOldRoadmap(content: string): PlanningRoadmap {
     return result;
   }
 
-  // ─── Strategy 2: Detect ## heading-sectioned milestones ───
+  // ─── Strategy 2: Detect ## Milestones summary + ### vN.N subsections ───
+  const summaryMilestones = parseMilestoneSummaryFormat(lines);
+  if (summaryMilestones.length > 0) {
+    result.milestones = summaryMilestones;
+    return result;
+  }
+
+  // ─── Strategy 3: Detect ## heading-sectioned milestones ───
   const milestoneHeadingRegex = /^##\s+(.+)$/;
   const milestoneHeadings: { index: number; id: string; title: string }[] = [];
 
@@ -196,7 +215,7 @@ export function parseOldRoadmap(content: string): PlanningRoadmap {
       result.milestones.push(milestone);
     }
   } else {
-    // ─── Strategy 3: Flat format — just extract all phase checkbox lines ───
+    // ─── Strategy 4: Flat format — just extract all phase checkbox lines ───
     for (const line of lines) {
       const entry = parsePhaseEntry(line.trim());
       if (entry) {
@@ -259,6 +278,124 @@ function parseDetailsBlockMilestones(lines: string[]): PlanningRoadmapMilestone[
   return milestones;
 }
 
+/**
+ * Parse a `## Milestones` summary section paired with `### vN.N ... (Phases N-M)` subsections.
+ * Returns empty array if not detected.
+ */
+function parseMilestoneSummaryFormat(lines: string[]): PlanningRoadmapMilestone[] {
+  let milestoneSectionStart = -1;
+  let milestoneSectionEnd = lines.length;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (/^##\s+Milestones?\s*$/i.test(lines[i].trim())) {
+      milestoneSectionStart = i + 1;
+      for (let j = i + 1; j < lines.length; j++) {
+        if (/^##\s+/.test(lines[j])) {
+          milestoneSectionEnd = j;
+          break;
+        }
+      }
+      break;
+    }
+  }
+
+  if (milestoneSectionStart === -1) return [];
+
+  type MilestoneSummaryEntry = {
+    id: string;
+    title: string;
+    done: boolean;
+    phaseStart: number;
+    phaseEnd: number;
+  };
+
+  const summaryEntries: MilestoneSummaryEntry[] = [];
+  for (let i = milestoneSectionStart; i < milestoneSectionEnd; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith('-')) continue;
+    const stripped = line.replace(/\*\*/g, '');
+    const match = stripped.match(
+      /^-\s+\[([ xX])\]\s+(?:Phase\s+)?\d+(?:\.\d+)?\s*:\s*(v[\d.]+)\s+(.+?)(?:\s*[—–]\s*Phases?\s+(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?))?(?:\s*\(.*\))?\s*$/
+    );
+    if (!match) continue;
+
+    const id = match[2];
+    const titleSuffix = match[3]
+      .replace(/\s*[—–]\s*Phases?\s+\d+(?:\.\d+)?\s*-\s*\d+(?:\.\d+)?.*$/, '')
+      .replace(/\s*\(.*\)\s*$/, '')
+      .trim();
+
+    summaryEntries.push({
+      id,
+      title: `${id} ${titleSuffix}`.trim(),
+      done: match[1].toLowerCase() === 'x',
+      phaseStart: match[4] ? parseFloat(match[4]) : 0,
+      phaseEnd: match[5] ? parseFloat(match[5]) : 0,
+    });
+  }
+
+  if (summaryEntries.length === 0) return [];
+
+  const subsectionPhases = new Map<string, PlanningRoadmapEntry[]>();
+  for (let i = 0; i < lines.length; i++) {
+    const headingMatch = lines[i].trim().match(/^###\s+(v[\d.]+)\s+(.+?)(?:\s*\(Phases?\s+[\d.]+\s*-\s*[\d.]+\))?\s*$/i);
+    if (!headingMatch) continue;
+
+    const id = headingMatch[1];
+    const phases: PlanningRoadmapEntry[] = [];
+    for (let j = i + 1; j < lines.length; j++) {
+      const sectionLine = lines[j].trim();
+      if (/^##\s+/.test(sectionLine) || /^###\s+/.test(sectionLine)) break;
+      const entry = parsePhaseEntry(sectionLine);
+      if (entry) phases.push(entry);
+    }
+
+    if (phases.length > 0) subsectionPhases.set(id, phases);
+  }
+
+  const milestones: PlanningRoadmapMilestone[] = [];
+  for (const entry of summaryEntries) {
+    const phases = subsectionPhases.get(entry.id);
+    if (phases && phases.length > 0) {
+      milestones.push({
+        id: entry.id,
+        title: entry.title,
+        collapsed: false,
+        phases,
+      });
+      continue;
+    }
+
+    if (entry.done && entry.phaseStart > 0 && entry.phaseEnd >= entry.phaseStart) {
+      const synthetic: PlanningRoadmapEntry[] = [];
+      for (let n = entry.phaseStart; n <= entry.phaseEnd; n += 1) {
+        synthetic.push({
+          number: n,
+          title: `Phase ${n}`,
+          done: true,
+          raw: `synthetic:${entry.id}:${n}`,
+        });
+      }
+      milestones.push({
+        id: entry.id,
+        title: entry.title,
+        collapsed: false,
+        phases: synthetic,
+      });
+      continue;
+    }
+
+    milestones.push({
+      id: entry.id,
+      title: entry.title,
+      collapsed: false,
+      phases: [],
+    });
+  }
+
+  return milestones;
+}
+
 // ─── Plan Parser (XML-in-Markdown) ─────────────────────────────────────────
 
 /** Strip surrounding quotes from YAML string values */

package/src/resources/extensions/gsd/migration-auto-check.ts

@@ -2,21 +2,17 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import {
-  clearEngineHierarchy,
   getAllMilestones,
   getMilestoneSlices,
   getSliceTasks,
   isDbAvailable,
-  transaction,
 } from "./gsd-db.js";
-import { migrateHierarchyToDb } from "./md-importer.js";
 import { parsePlan, parseRoadmap } from "./parsers-legacy.js";
 import {
   milestonesDir,
   resolveMilestoneFile,
   resolveSliceFile,
 } from "./paths.js";
-import { invalidateStateCache } from "./state.js";
 
 export interface HierarchyCounts {
   milestones: number;
@@ -25,11 +21,13 @@ export interface HierarchyCounts {
 }
 
 export interface MigrationAutoCheckResult {
-  action: "none" | "imported";
+  action: "none" | "recovery-required";
   reason: "no-markdown" | "in-sync" | "db-empty" | "count-mismatch";
   markdown: HierarchyCounts;
   beforeDb: HierarchyCounts;
   afterDb: HierarchyCounts;
+  recoveryCommand?: string;
+  message?: string;
 }
 
 function zeroCounts(): HierarchyCounts {
@@ -83,7 +81,7 @@ export function countDbHierarchy(): HierarchyCounts {
   return counts;
 }
 
-export async function autoImportMarkdownHierarchyIfDbMismatch(
+export async function checkMarkdownHierarchyAgainstDb(
   basePath: string,
 ): Promise<MigrationAutoCheckResult> {
   const markdown = countMarkdownHierarchy(basePath);
@@ -108,22 +106,16 @@ export async function autoImportMarkdownHierarchyIfDbMismatch(
   }
 
   const reason = sameCounts(beforeDb, zeroCounts()) ? "db-empty" : "count-mismatch";
-  const imported = transaction(() => {
-    clearEngineHierarchy();
-    return migrateHierarchyToDb(basePath);
-  });
-  invalidateStateCache();
-
-  const afterDb = {
-    milestones: imported.milestones,
-    slices: imported.slices,
-    tasks: imported.tasks,
+  return {
+    action: "recovery-required",
+    reason,
+    markdown,
+    beforeDb,
+    afterDb: beforeDb,
+    recoveryCommand: "gsd recover",
+    message:
+      `Markdown planning artifacts (${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T) ` +
+      `do not match the authoritative DB (${beforeDb.milestones}M/${beforeDb.slices}S/${beforeDb.tasks}T). ` +
+      "Runtime startup will not import markdown automatically; run explicit GSD recovery if markdown should repopulate the database.",
   };
-  if (!sameCounts(markdown, afterDb)) {
-    throw new Error(
-      `migration auto-import verification failed: markdown ${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T, db ${afterDb.milestones}M/${afterDb.slices}S/${afterDb.tasks}T`,
-    );
-  }
-
-  return { action: "imported", reason, markdown, beforeDb, afterDb };
 }

package/src/resources/extensions/gsd/milestone-actions.ts

@@ -24,6 +24,7 @@ import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } f
 import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 import { isAutoActive } from "./auto.js";
+import { isClosedStatus } from "./status-guards.js";
 
 /**
  * Writer-side assert for mutations that race with auto-mode's squash merge (#4704).
@@ -44,7 +45,7 @@ function assertNotAutoActive(action: string): void {
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
  * Parked milestones are skipped during active-milestone discovery but stay on disk.
- * Returns true if successfully parked, false if milestone not found or already parked.
+ * Returns true if successfully parked, false if milestone not found, already parked, or complete.
  */
 export function parkMilestone(basePath: string, milestoneId: string, reason: string): boolean {
   assertNotAutoActive("park milestone");
@@ -52,8 +53,13 @@ export function parkMilestone(basePath: string, milestoneId: string, reason: str
   if (!mDir || !existsSync(mDir)) return false;
 
   // Guard: do not park a completed milestone — it would corrupt depends_on satisfaction
-  const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
-  if (summaryFile) return false;
+  const dbAvailable = isDbAvailable();
+  const milestone = dbAvailable ? getMilestone(milestoneId) : null;
+  if (milestone && isClosedStatus(milestone.status)) return false;
+  if (!dbAvailable) {
+    const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
+    if (summaryFile) return false;
+  }
 
   const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
   if (existsSync(parkedPath)) return false; // already parked
@@ -72,7 +78,7 @@ export function parkMilestone(basePath: string, milestoneId: string, reason: str
 
   writeFileSync(parkedPath, content, "utf-8");
   // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
-  if (isDbAvailable()) {
+  if (dbAvailable) {
     try {
       updateMilestoneStatus(milestoneId, "parked");
     } catch (err) {

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

@@ -6,6 +6,7 @@
 // execSync calls because git2 credential handling is too complex.
 
 import { execSync, execFileSync } from "node:child_process";
+import type { ExecFileSyncOptionsWithStringEncoding } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
@@ -16,6 +17,8 @@ import { isInfrastructureError } from "./auto/infra-errors.js";
 // Issue #453: keep auto-mode bookkeeping on the stable git CLI path unless a
 // caller explicitly opts into the native helper.
 const NATIVE_GSD_GIT_ENABLED = process.env.GSD_ENABLE_NATIVE_GSD_GIT === "1";
+const TRANSIENT_GIT_RETRY_CODES = new Set(["ENOBUFS", "EAGAIN"]);
+const GIT_RETRY_DELAY_MS = 200;
 
 // ─── Native Module Types ──────────────────────────────────────────────────
 
@@ -144,9 +147,46 @@ function gitExec(basePath: string, args: string[], allowFailure = false): string
       encoding: "utf-8",
       env: GIT_NO_PROMPT_ENV,
     }).trim();
-  } catch {
+  } catch (err) {
     if (allowFailure) return "";
-    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}`);
+    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}: ${getErrorMessage(err)}`);
+  }
+}
+
+/** sleepSync uses Atomics.wait for a blocking pause without busy-waiting; it blocks the current thread and requires Atomics.wait support. */
+function sleepSync(ms: number): void {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function isRetryableGitError(err: unknown): boolean {
+  const code = isInfrastructureError(err)
+    ?? isInfrastructureError((err as { stderr?: string })?.stderr ?? "");
+  return code !== null && TRANSIENT_GIT_RETRY_CODES.has(code);
+}
+
+function execGitFileSyncWithRetry(
+  basePath: string,
+  args: string[],
+  options: Partial<ExecFileSyncOptionsWithStringEncoding>,
+): string {
+  try {
+    return execFileSync("git", args, {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+      ...options,
+    }).trim();
+  } catch (err) {
+    if (!isRetryableGitError(err)) throw err;
+    sleepSync(GIT_RETRY_DELAY_MS);
+    return execFileSync("git", args, {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+      ...options,
+    }).trim();
   }
 }
 
@@ -159,9 +199,9 @@ function gitFileExec(basePath: string, args: string[], allowFailure = false): st
       encoding: "utf-8",
       env: GIT_NO_PROMPT_ENV,
     }).trim();
-  } catch {
+  } catch (err) {
     if (allowFailure) return "";
-    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}`);
+    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}: ${getErrorMessage(err)}`);
   }
 }
 
@@ -428,16 +468,21 @@ export function nativeDiffNameStatus(
 
 /**
  * Get numstat diff between two refs.
+ * useMergeBase: if true, uses three-dot semantics.
  * Native: libgit2 patch line stats.
  * Fallback: `git diff --numstat`.
  */
-export function nativeDiffNumstat(basePath: string, fromRef: string, toRef: string): GitNumstat[] {
+export function nativeDiffNumstat(basePath: string, fromRef: string, toRef: string, useMergeBase?: boolean): GitNumstat[] {
   const native = loadNative();
-  if (native) {
+  if (native && !useMergeBase) {
     return native.gitDiffNumstat(basePath, fromRef, toRef);
   }
 
-  const result = gitExec(basePath, ["diff", "--numstat", fromRef, toRef], true);
+  const refspec = useMergeBase ? `${fromRef}...${toRef}` : undefined;
+  const args = refspec
+    ? ["diff", "--numstat", refspec]
+    : ["diff", "--numstat", fromRef, toRef];
+  const result = gitExec(basePath, args, true);
   if (!result) return [];
 
   return result.split("\n").filter(Boolean).map(line => {
@@ -553,7 +598,10 @@ export function nativeBranchList(basePath: string, pattern?: string): string[] {
   const result = gitFileExec(basePath, args, true);
   if (!result) return [];
 
-  return result.split("\n").map(b => b.trim().replace(/^\* /, "")).filter(Boolean);
+  return result
+    .split("\n")
+    .map(b => b.trim().replace(/^[*+]\s+/, ""))
+    .filter(Boolean);
 }
 
 /**
@@ -935,13 +983,10 @@ export function nativeCommit(
   try {
     const args = ["commit", "-F", "-"];
     if (options?.allowEmpty) args.push("--allow-empty");
-    const result = execFileSync("git", args, {
-      cwd: basePath,
+    const result = execGitFileSyncWithRetry(basePath, args, {
       stdio: ["pipe", "pipe", "pipe"],
-      encoding: "utf-8",
-      env: GIT_NO_PROMPT_ENV,
       input: message,
-    }).trim();
+    });
     return result;
   } catch (err: unknown) {
     const errObj = err as { stdout?: string; stderr?: string; message?: string };
@@ -949,7 +994,11 @@ export function nativeCommit(
     if (combined.includes("nothing to commit") || combined.includes("nothing added to commit") || combined.includes("no changes added")) {
       return null;
     }
-    throw err;
+    const commitDetail = errObj.stderr?.trim() || errObj.message || "git commit failed";
+    const wrapped = new Error(`git commit failed: ${commitDetail}`);
+    (wrapped as Error & { stdout?: string; stderr?: string }).stdout = errObj.stdout;
+    (wrapped as Error & { stdout?: string; stderr?: string }).stderr = errObj.stderr;
+    throw wrapped;
   }
 }
 

package/src/resources/extensions/gsd/parallel-orchestrator.ts

@@ -1005,6 +1005,9 @@ export function refreshWorkerStatuses(
   for (const [mid, worker] of state.workers) {
     const diskStatus = statusMap.get(mid);
     if (!diskStatus) {
+      if (worker.state === "stopped" || worker.state === "error") {
+        continue;
+      }
       if (!isPidAlive(worker.pid)) {
         worker.cleanup?.();
         worker.cleanup = undefined;