gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

package/dist/resources/extensions/gsd/guided-unit-context.js

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

package/dist/resources/extensions/gsd/init-wizard.js

@@ -353,7 +353,13 @@ export async function handleReinit(ctx, detection) {
             {
                 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,
             },
             {
@@ -365,7 +371,16 @@ export async function handleReinit(ctx, detection) {
         notYetMessage: "Run /gsd init when ready.",
     });
     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
+        }
     }
 }
 // ─── Git Preferences Customization ──────────────────────────────────────────────

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -14,7 +14,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getTask, getSlice, getArtifact, insertArtifact, getGateResults, } from "./gsd-db.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, gsdProjectionRoot, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
 import { saveFile, clearParseCache } from "./files.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache } from "./paths.js";
@@ -24,7 +24,11 @@ import { clearPathCache } from "./paths.js";
  * E.g. "/project/.gsd/milestones/M001/M001-ROADMAP.md" → "milestones/M001/M001-ROADMAP.md"
  */
 function toArtifactPath(absPath, basePath) {
-    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, "/");
@@ -305,10 +309,9 @@ export async function renderPlanFromDb(basePath, milestoneId, sliceId) {
     if (tasks.length === 0) {
         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);
@@ -329,8 +332,7 @@ export async function renderTaskPlanFromDb(basePath, milestoneId, sliceId, taskI
     if (!task) {
         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);
@@ -610,13 +612,14 @@ export function detectStaleRenders(basePath) {
     const _require = createRequire(import.meta.url);
     let parseRoadmap, parsePlan;
     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.message}`);
-        const m = _require("./parsers-legacy.js");
+        logWarning("renderer", `parsers-legacy.js require failed, falling back to .ts: ${e.message}`);
+        const m = _require("./parsers-legacy.ts");
         parseRoadmap = m.parseRoadmap;
         parsePlan = m.parsePlan;
     }

package/dist/resources/extensions/gsd/mcp-filter.js

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { resolveModelMcpConfig } from "./preferences-mcp.js";
+export function discoverMcpServerNames(projectDir) {
+    const mcpJsonPath = resolve(projectDir, ".mcp.json");
+    const settingsPath = resolve(projectDir, ".claude", "settings.json");
+    let mcpJsonServers = [];
+    if (existsSync(mcpJsonPath)) {
+        const raw = readFileSync(mcpJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        mcpJsonServers = Object.keys(parsed.mcpServers ?? {});
+    }
+    let settingsServers = [];
+    if (existsSync(settingsPath)) {
+        try {
+            const raw = readFileSync(settingsPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            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, mcpConfig, discoveredServers, workflowServerName) {
+    if (!mcpConfig)
+        return [];
+    const entry = resolveModelMcpConfig(modelId, mcpConfig);
+    if (!entry)
+        return [];
+    const allServers = [...discoveredServers, ...(workflowServerName ? [workflowServerName] : [])];
+    const blocked = new Set();
+    // 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/dist/resources/extensions/gsd/migrate/parsers.js

@@ -45,6 +45,7 @@ function parsePhaseEntry(line) {
         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, '')
@@ -71,6 +72,16 @@ function parsePhaseEntry(line) {
             raw: line,
         };
     }
+    // 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;
 }
 /**
@@ -120,7 +131,13 @@ export function parseOldRoadmap(content) {
         }
         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 = [];
     for (let i = 0; i < lines.length; i++) {
@@ -165,7 +182,7 @@ export function parseOldRoadmap(content) {
         }
     }
     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) {
@@ -219,6 +236,108 @@ function parseDetailsBlockMilestones(lines) {
     }
     return milestones;
 }
+/**
+ * Parse a `## Milestones` summary section paired with `### vN.N ... (Phases N-M)` subsections.
+ * Returns empty array if not detected.
+ */
+function parseMilestoneSummaryFormat(lines) {
+    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 [];
+    const summaryEntries = [];
+    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();
+    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 = [];
+        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 = [];
+    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 = [];
+            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 */
 function unquote(val) {

package/dist/resources/extensions/gsd/migration-auto-check.js

@@ -1,10 +1,8 @@
 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 { getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, } from "./gsd-db.js";
 import { parsePlan, parseRoadmap } from "./parsers-legacy.js";
 import { milestonesDir, resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
-import { invalidateStateCache } from "./state.js";
 function zeroCounts() {
     return { milestones: 0, slices: 0, tasks: 0 };
 }
@@ -50,7 +48,7 @@ export function countDbHierarchy() {
     }
     return counts;
 }
-export async function autoImportMarkdownHierarchyIfDbMismatch(basePath) {
+export async function checkMarkdownHierarchyAgainstDb(basePath) {
     const markdown = countMarkdownHierarchy(basePath);
     if (sameCounts(markdown, zeroCounts())) {
         return {
@@ -70,18 +68,15 @@ export async function autoImportMarkdownHierarchyIfDbMismatch(basePath) {
         return { action: "none", reason: "in-sync", markdown, beforeDb, afterDb: beforeDb };
     }
     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/dist/resources/extensions/gsd/milestone-actions.js

@@ -19,6 +19,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).
  * Auto-mode is confirmed not to call parkMilestone/discardMilestone/unparkMilestone
@@ -34,7 +35,7 @@ function assertNotAutoActive(action) {
 /**
  * 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, milestoneId, reason) {
     assertNotAutoActive("park milestone");
@@ -42,9 +43,15 @@ export function parkMilestone(basePath, milestoneId, reason) {
     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)
+    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
@@ -61,7 +68,7 @@ export function parkMilestone(basePath, milestoneId, reason) {
     ].join("\n");
     writeFileSync(parkedPath, content, "utf-8");
     // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
-    if (isDbAvailable()) {
+    if (dbAvailable) {
         try {
             updateMilestoneStatus(milestoneId, "parked");
         }

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -14,6 +14,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 Loading ──────────────────────────────────────────────────
 let nativeModule = null;
 let loadAttempted = false;
@@ -46,10 +48,42 @@ function gitExec(basePath, args, allowFailure = false) {
             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) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function isRetryableGitError(err) {
+    const code = isInfrastructureError(err)
+        ?? isInfrastructureError(err?.stderr ?? "");
+    return code !== null && TRANSIENT_GIT_RETRY_CODES.has(code);
+}
+function execGitFileSyncWithRetry(basePath, args, options) {
+    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();
     }
 }
 /** Run a git command via execFileSync. Returns trimmed stdout. */
@@ -62,10 +96,10 @@ function gitFileExec(basePath, args, allowFailure = false) {
             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)}`);
     }
 }
 // ─── Existing Read Functions ──────────────────────────────────────────────
@@ -303,15 +337,20 @@ export function nativeDiffNameStatus(basePath, fromRef, toRef, pathspec, useMerg
 }
 /**
  * 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, fromRef, toRef) {
+export function nativeDiffNumstat(basePath, fromRef, toRef, useMergeBase) {
     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 => {
@@ -409,7 +448,10 @@ export function nativeBranchList(basePath, pattern) {
     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);
 }
 /**
  * List branches merged into target.
@@ -777,13 +819,10 @@ export function nativeCommit(basePath, message, options) {
         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) {
@@ -792,7 +831,11 @@ export function nativeCommit(basePath, message, options) {
         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.stdout = errObj.stdout;
+        wrapped.stderr = errObj.stderr;
+        throw wrapped;
     }
 }
 /**

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -849,6 +849,9 @@ export function refreshWorkerStatuses(basePath, options = {}) {
     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;

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

@@ -320,6 +320,10 @@ export function resolveGsdPathContract(workRoot, originalProjectRoot) {
         isWorktree,
     };
 }
+export function gsdProjectionRoot(basePath) {
+    const contract = resolveGsdPathContract(basePath);
+    return normalizeRealPath(contract.worktreeGsd ?? contract.projectGsd);
+}
 /**
  * Invalidate the gsdRoot cache.
  * Use ONLY at session-reset boundaries: workspace switch, process exit, or

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

@@ -0,0 +1,52 @@
+// GSD-2 — Pending auto-start handoff state.
+// Stores discuss-to-auto handoff entries keyed by project root.
+import { createWorkspace, scopeMilestone } from "./workspace.js";
+const pendingAutoStartMap = new Map();
+export function getPendingAutoStart(basePath) {
+    if (basePath)
+        return pendingAutoStartMap.get(basePath) ?? null;
+    if (pendingAutoStartMap.size === 1)
+        return pendingAutoStartMap.values().next().value;
+    return null;
+}
+export const _getPendingAutoStart = getPendingAutoStart;
+export function hasPendingAutoStart(basePath) {
+    if (basePath)
+        return pendingAutoStartMap.has(basePath);
+    return pendingAutoStartMap.size > 0;
+}
+export function setPendingAutoStart(basePath, entry) {
+    if (!entry.ctx || !entry.pi) {
+        throw new Error("setPendingAutoStart requires ctx and pi");
+    }
+    const ws = createWorkspace(entry.basePath);
+    const scope = scopeMilestone(ws, entry.milestoneId);
+    pendingAutoStartMap.set(basePath, {
+        createdAt: Date.now(),
+        planBlockedRecoveryCount: 0,
+        ...entry,
+        scope,
+        ctx: entry.ctx,
+        pi: entry.pi,
+    });
+}
+export function deletePendingAutoStart(basePath) {
+    pendingAutoStartMap.delete(basePath);
+}
+export function clearPendingAutoStart(basePath) {
+    if (basePath) {
+        pendingAutoStartMap.delete(basePath);
+    }
+    else {
+        pendingAutoStartMap.clear();
+    }
+}
+export function getDiscussionMilestoneId(basePath) {
+    if (basePath) {
+        return pendingAutoStartMap.get(basePath)?.milestoneId ?? null;
+    }
+    if (pendingAutoStartMap.size === 1) {
+        return pendingAutoStartMap.values().next().value.milestoneId;
+    }
+    return null;
+}

package/dist/resources/extensions/gsd/planning-path-scope.js

@@ -6,20 +6,26 @@ function isInsideBase(basePath, candidate) {
     const rel = relative(base, abs);
     return rel === "" || (!!rel && !rel.startsWith("..") && !isAbsolute(rel));
 }
+function isInsideAnyBase(bases, candidate) {
+    return bases.some((base) => isInsideBase(base, candidate));
+}
 /**
  * Planning IO fields are execution contracts. Absolute paths are only safe when
  * they stay inside the active working directory; in worktree mode, an absolute
  * path to the original checkout makes executors edit the wrong tree.
  */
-export function validatePlanningPathScope(basePath, fields) {
+export function validatePlanningPathScope(basePath, fields, allowedAbsoluteRoots) {
+    const absoluteRoots = (allowedAbsoluteRoots && allowedAbsoluteRoots.length > 0)
+        ? allowedAbsoluteRoots
+        : [basePath];
     for (const { field, values } of fields) {
         for (const raw of values) {
             const candidate = normalizePlannedFileReference(raw);
             if (!isAbsolute(candidate))
                 continue;
-            if (isInsideBase(basePath, candidate))
+            if (isInsideAnyBase(absoluteRoots, candidate))
                 continue;
-            return `${field} contains absolute path outside working directory: ${candidate}. Use a path relative to ${basePath}.`;
+            return `${field} contains absolute path outside allowed repository roots: ${candidate}. Use a path relative to one of: ${absoluteRoots.join(", ")}.`;
         }
     }
     return null;