@opengsd/gsd-pi 1.2.0-dev.4c756166 → 1.2.0-dev.6ccd27b3

package/dist/resources/extensions/gsd/mcp-tool-name.js

@@ -1,20 +1,12 @@
 // Project/App: gsd-pi
-// File Purpose: Shared parsing and formatting helpers for MCP-scoped tool names.
+// File Purpose: GSD-facing face over the shared @gsd/pi-ai MCP tool-name helpers.
+import { parseMcpToolName as parsePiAiMcpToolName, stripMcpToolPrefix } from "@gsd/pi-ai";
 const MCP_TOOL_PREFIX = "mcp__";
 export function parseMcpToolName(toolName) {
-    if (!toolName.startsWith(MCP_TOOL_PREFIX))
-        return null;
-    const toolSeparator = toolName.indexOf("__", MCP_TOOL_PREFIX.length);
-    if (toolSeparator < 0)
-        return null;
-    return {
-        serverName: toolName.slice(MCP_TOOL_PREFIX.length, toolSeparator),
-        toolName: toolName.slice(toolSeparator + 2),
-    };
-}
-export function stripMcpToolPrefix(toolName) {
-    return parseMcpToolName(toolName)?.toolName ?? toolName;
+    const parsed = parsePiAiMcpToolName(toolName);
+    return parsed ? { serverName: parsed.server, toolName: parsed.tool } : null;
 }
+export { stripMcpToolPrefix };
 export function toMcpToolName(serverName, toolName) {
     return `${MCP_TOOL_PREFIX}${serverName}__${toolName}`;
 }

package/dist/resources/extensions/gsd/memory-consolidation-scanner.js

@@ -211,7 +211,7 @@ export function reportConsolidationGaps(basePath) {
         const report = scanConsolidationGaps(basePath);
         if (report.totalGaps === 0)
             return report;
-        appendNotification(report.summary, "warning", "workflow-logger");
+        appendNotification(report.summary, "warning", "workflow-logger", { kind: "memory-consolidation" });
         logWarning("memory-consolidation", report.summary);
         return report;
     }

package/dist/resources/extensions/gsd/migrate/safety.js

@@ -8,6 +8,7 @@ import { readCrashLock, isLockProcessAlive } from "../crash-recovery.js";
 import { closeWorkflowDatabase } from "../db-workspace.js";
 import { readPausedSessionMetadata } from "../interrupted-session.js";
 import { gsdRoot } from "../paths.js";
+import { canonicalWorktreesDir } from "../worktree-placement.js";
 export class MigrationBlockedError extends Error {
     constructor(message) {
         super(message);
@@ -78,16 +79,26 @@ export function assertMigrationHasSlices(preview) {
     throw new MigrationBlockedError("Migration blocked - the legacy project would produce zero slices. Add a ROADMAP.md or phases/ content before migrating.");
 }
 function hasWorktreeState(targetRoot) {
-    const worktreesDir = join(gsdRoot(targetRoot), "worktrees");
-    if (!existsSync(worktreesDir))
-        return false;
-    try {
-        return readdirSync(worktreesDir, { withFileTypes: true })
-            .some((entry) => entry.isDirectory() || entry.isFile());
-    }
-    catch {
-        return true;
+    // Legacy container is probed via gsdRoot() (symlink-resolved) on purpose —
+    // migration targets may have .gsd in the external-state layout.
+    const containers = [
+        canonicalWorktreesDir(targetRoot),
+        join(gsdRoot(targetRoot), "worktrees"),
+    ];
+    for (const worktreesDir of containers) {
+        if (!existsSync(worktreesDir))
+            continue;
+        try {
+            if (readdirSync(worktreesDir, { withFileTypes: true })
+                .some((entry) => entry.isDirectory() || entry.isFile())) {
+                return true;
+            }
+        }
+        catch {
+            return true;
+        }
     }
+    return false;
 }
 export async function assertMigrationTargetAvailable(targetRoot) {
     const targetGsdPath = gsdRoot(targetRoot);

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

@@ -8,7 +8,13 @@ function zeroCounts() {
     return { milestones: 0, slices: 0, tasks: 0 };
 }
 function emptyScan() {
-    return { counts: zeroCounts(), milestones: new Set(), slices: new Set(), tasks: new Set() };
+    return {
+        counts: zeroCounts(),
+        milestones: new Set(),
+        slices: new Set(),
+        tasks: new Set(),
+        milestonesWithoutRoadmap: new Set(),
+    };
 }
 function sameCounts(a, b) {
     return a.milestones === b.milestones && a.slices === b.slices && a.tasks === b.tasks;
@@ -65,8 +71,10 @@ export function scanMarkdownHierarchy(basePath) {
         scan.counts.milestones++;
         scan.milestones.add(milestoneId);
         const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
-        if (!roadmapPath || !existsSync(roadmapPath))
+        if (!roadmapPath || !existsSync(roadmapPath)) {
+            scan.milestonesWithoutRoadmap.add(milestoneId);
             continue;
+        }
         const roadmap = parseRoadmap(readFileSync(roadmapPath, "utf-8"));
         scan.counts.slices += roadmap.slices.length;
         for (const slice of roadmap.slices) {
@@ -112,7 +120,6 @@ export function countDbHierarchy() {
 }
 export async function checkMarkdownHierarchyAgainstDb(basePath) {
     const markdownScan = scanMarkdownHierarchy(basePath);
-    const markdown = markdownScan.counts;
     // Always open the DB before deciding. An empty markdown tree does NOT imply
     // an empty project — the DB may hold authoritative rows whose markdown was
     // lost, which is itself recoverable drift. The previous early return here
@@ -128,6 +135,20 @@ export async function checkMarkdownHierarchyAgainstDb(basePath) {
     refreshWorkflowDatabaseFromDisk();
     const dbScan = scanDbHierarchy();
     const beforeDb = dbScan.counts;
+    // Discussion-phase scratch: a milestone dir with no ROADMAP and no DB row is
+    // a pre-registration discussion artifact (CONTEXT/CONTEXT-DRAFT only — the
+    // queued DB row is inserted only at discussion handoff). Treating it as
+    // drift would warn on every live discussion and recommend
+    // `/gsd recover --confirm`, an import that materializes abandoned-discussion
+    // dirs as ghost active milestones. Exclude such dirs from this comparison
+    // only; recover preflights use the raw scans and still see them.
+    for (const id of markdownScan.milestonesWithoutRoadmap) {
+        if (dbScan.milestones.has(id))
+            continue;
+        markdownScan.milestones.delete(id);
+        markdownScan.counts.milestones--;
+    }
+    const markdown = markdownScan.counts;
     const markdownEmpty = sameCounts(markdown, zeroCounts());
     const dbEmpty = sameCounts(beforeDb, zeroCounts());
     // Genuinely empty project: nothing on disk, nothing in the DB.

package/dist/resources/extensions/gsd/milestone-closeout.js

@@ -4,13 +4,16 @@
 // - preflight: dispatch git clean before complete-milestone agent (auto-dispatch)
 // - postUnit: git commit, artifact verify, DB settle, then GitHub finalize
 // - recovery: DB repair from artifacts, then GitHub finalize
+import { existsSync } from "node:fs";
 import { loadFile } from "./files.js";
-import { parseRoadmap } from "./parsers-legacy.js";
 import { resolveMilestoneFile } from "./paths.js";
-import { getMilestone, getMilestoneSlices, isDbAvailable } from "./gsd-db.js";
+import { getMilestone, getClosedSliceIds, getLatestAssessmentByScope, getMilestoneSlices, isDbAvailable, } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
+import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import { handleCompleteMilestone } from "./tools/complete-milestone.js";
 import { runSafely } from "./auto-utils.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
+import { uatSignoffBlockerGuidance } from "./guidance.js";
 import { logWarning } from "./workflow-logger.js";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { buildCompleteMilestonePrompt } from "./auto-prompts.js";
@@ -19,6 +22,60 @@ import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { commitPendingMilestoneCloseoutChanges, findMissingSummaries, isVerificationNotApplicable, readUatGateVerdict, } from "./auto-dispatch.js";
 const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
 const COMPLETE_MILESTONE_DB_SETTLE_POLL_MS = 100;
+/**
+ * True when a milestone is terminal for git cleanup (orphaned worktrees, stale branches).
+ * DB-authoritative (ADR-017): closed status, or validation-pass with all slices closed.
+ * When the DB is unavailable we cannot make this decision and conservatively
+ * return false so callers leave the worktree/branch alone instead of cleaning
+ * up based on parsed projections.
+ */
+export async function isCompletedMilestoneTerminal(_basePath, milestoneId) {
+    if (!isDbAvailable())
+        return false;
+    const milestone = getMilestone(milestoneId);
+    if (!milestone)
+        return false;
+    if (isClosedStatus(milestone.status)) {
+        return true;
+    }
+    const validation = getLatestAssessmentByScope(milestoneId, "milestone-validation");
+    if (validation?.status !== "pass") {
+        return false;
+    }
+    const slices = getMilestoneSlices(milestoneId);
+    if (slices.length === 0)
+        return false;
+    return slices.every((slice) => isClosedStatus(slice.status));
+}
+/** Write a missing milestone SUMMARY projection when canonical DB closeout already settled. */
+export async function repairMissingMilestoneSummaryProjection(basePath, milestoneId) {
+    const milestone = getMilestone(milestoneId);
+    if (!milestone) {
+        return { ok: false, error: `milestone not found: ${milestoneId}` };
+    }
+    const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, milestoneId);
+    const summaryPath = resolveExpectedArtifactPath("complete-milestone", milestoneId, artifactBasePath);
+    if (summaryPath && existsSync(summaryPath)) {
+        return { ok: true };
+    }
+    const result = await handleCompleteMilestone({
+        milestoneId,
+        title: milestone.title,
+        oneLiner: "Canonical closeout completed; summary projection repaired automatically.",
+        narrative: "The workflow database recorded this milestone as complete, but the milestone SUMMARY artifact was missing on disk. " +
+            "Dispatch policy repaired the projection so closeout proof and cleanup can proceed.",
+        verificationPassed: true,
+        triggerReason: "closeout-projection-repair",
+    }, basePath);
+    if ("error" in result) {
+        return { ok: false, error: result.error };
+    }
+    const writtenSummaryPath = result.summaryPath;
+    if (result.stale || !writtenSummaryPath || !existsSync(writtenSummaryPath)) {
+        return { ok: false, error: "milestone SUMMARY projection write failed" };
+    }
+    return { ok: true };
+}
 /**
  * True when the milestone is closed in the DB and the completion summary artifact exists.
  * Polls briefly so post-unit verification can observe the tool's DB write.
@@ -65,38 +122,42 @@ export async function evaluateCompleteMilestoneDispatch(ctx) {
     if (isDbAvailable()) {
         const milestone = getMilestone(mid);
         if (milestone && isClosedStatus(milestone.status)) {
-            return { action: "skip" };
+            const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, mid);
+            const summaryPath = resolveExpectedArtifactPath("complete-milestone", mid, artifactBasePath);
+            const summaryMissing = !summaryPath || !existsSync(summaryPath);
+            if (summaryMissing) {
+                const repair = await repairMissingMilestoneSummaryProjection(basePath, mid);
+                if (!repair.ok) {
+                    logWarning("dispatch", `Milestone ${mid} is closed in DB but SUMMARY repair failed: ${repair.error}. Dispatching complete-milestone to retry.`);
+                }
+                else {
+                    return { action: "skip" };
+                }
+            }
+            else {
+                return { action: "skip" };
+            }
         }
     }
     const closeoutGitStop = commitPendingMilestoneCloseoutChanges(basePath, mid);
     if (closeoutGitStop)
         return closeoutGitStop;
     if (prefs?.uat_dispatch) {
-        let closedSliceIds;
-        if (isDbAvailable()) {
-            closedSliceIds = getMilestoneSlices(mid)
-                .filter((slice) => isClosedStatus(slice.status))
-                .map((slice) => slice.id);
-        }
-        else {
-            const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (!roadmapContent) {
-                return {
-                    action: "stop",
-                    reason: `Cannot complete milestone ${mid}: unable to verify UAT verdicts because ROADMAP is unavailable while DB is not accessible.`,
-                    level: "warning",
-                };
-            }
-            const roadmap = parseRoadmap(roadmapContent);
-            closedSliceIds = roadmap.slices.filter((slice) => slice.done).map((slice) => slice.id);
+        // DB-authoritative (ADR-017): UAT sign-off gating never parses the
+        // ROADMAP projection. Without a DB we cannot verify — stop conservatively.
+        if (!isDbAvailable()) {
+            return {
+                action: "stop",
+                reason: `Cannot complete milestone ${mid}: unable to verify UAT verdicts because the workflow DB is not accessible.`,
+                level: "warning",
+            };
         }
-        for (const sliceId of closedSliceIds) {
+        for (const sliceId of getClosedSliceIds(mid)) {
             const result = await readUatGateVerdict(basePath, mid, sliceId);
             if (!result) {
                 return {
                     action: "stop",
-                    reason: `Cannot complete milestone ${mid}: missing UAT PASS verdict for ${sliceId}. Manual UAT sign-off (PASS) is required before milestone closure.`,
+                    reason: uatSignoffBlockerGuidance(mid, sliceId),
                     level: "warning",
                 };
             }
@@ -104,7 +165,7 @@ export async function evaluateCompleteMilestoneDispatch(ctx) {
             if (!isAcceptableUatVerdict(verdict, uatType)) {
                 return {
                     action: "stop",
-                    reason: `Cannot complete milestone ${mid}: UAT verdict for ${sliceId} is "${verdict}". Manual UAT sign-off (PASS) is required before milestone closure.`,
+                    reason: uatSignoffBlockerGuidance(mid, sliceId, verdict),
                     level: "warning",
                 };
             }

package/dist/resources/extensions/gsd/milestone-planning-persistence.js

@@ -5,7 +5,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { transaction, getMilestone, getMilestoneSlices, getSlice, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "./gsd-db.js";
 import { invalidateStateCache } from "./state.js";
 import { renderRoadmapFromDb } from "./markdown-renderer.js";
-import { renderAllProjections } from "./workflow-projections.js";
+import { flushWorkflowProjections } from "./projection-flush.js";
 import { writeManifest } from "./workflow-manifest.js";
 import { appendEvent } from "./workflow-events.js";
 import { logWarning } from "./workflow-logger.js";
@@ -109,7 +109,7 @@ async function renderPlanArtifacts(basePath, params) {
 }
 async function runPostPlanHooks(basePath, params) {
     try {
-        await renderAllProjections(basePath, params.milestoneId);
+        await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
         writeManifest(basePath);
         appendEvent(basePath, {
             cmd: "plan-milestone",

package/dist/resources/extensions/gsd/milestone-reopen-events.js

@@ -1,11 +1,9 @@
-import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
+import { workflowEventArchivePath, workflowEventLogPath } from "./workflow-event-ledger.js";
 import { readEvents } from "./workflow-events.js";
 export function latestExplicitReopenAt(basePath, milestoneId) {
-    const root = gsdRoot(basePath);
     const candidates = [
-        join(root, "event-log.jsonl"),
-        join(root, `event-log-${milestoneId}.jsonl.archived`),
+        workflowEventLogPath(basePath),
+        workflowEventArchivePath(basePath, milestoneId),
     ];
     let latest = null;
     for (const file of candidates) {

package/dist/resources/extensions/gsd/milestone-settlement.js

@@ -43,8 +43,8 @@ export function evaluateAllCompleteSettlement(input) {
         reason: "merge-pending",
         action: "pause",
         message: `Milestone ${milestoneId} is complete, but its worktree branch has not been merged to main. ` +
-            `Retry with \`/gsd dispatch complete-milestone ${milestoneId}\` or merge manually.`,
-        nextAction: `Retry \`/gsd dispatch complete-milestone ${milestoneId}\` or merge manually.`,
+            `Retry with \`/gsd dispatch complete-milestone ${milestoneId}\` to finish the system-owned merge.`,
+        nextAction: `Retry \`/gsd dispatch complete-milestone ${milestoneId}\`.`,
         milestoneId,
     };
 }

package/dist/resources/extensions/gsd/model-cost-table.js

@@ -13,6 +13,7 @@ export const BUNDLED_COST_TABLE = [
     { id: "claude-opus-4-6", inputPer1k: 0.005, outputPer1k: 0.025, updatedAt: "2026-04-16" },
     { id: "claude-opus-4-7", inputPer1k: 0.005, outputPer1k: 0.025, updatedAt: "2026-04-16" },
     { id: "claude-opus-4-8", inputPer1k: 0.005, outputPer1k: 0.025, updatedAt: "2026-05-28" },
+    { id: "claude-fable-5", inputPer1k: 0.010, outputPer1k: 0.050, updatedAt: "2026-06-09" },
     { id: "claude-sonnet-4-6", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
     { id: "claude-haiku-4-5", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
     { id: "claude-sonnet-4-5-20250514", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },

package/dist/resources/extensions/gsd/model-router.js

@@ -35,6 +35,7 @@ export const MODEL_CAPABILITY_TIER = {
     "claude-opus-4-6": "heavy",
     "claude-opus-4-7": "heavy",
     "claude-opus-4-8": "heavy",
+    "claude-fable-5": "heavy",
     "claude-3-opus-latest": "heavy",
     "gpt-4-turbo": "heavy",
     "gpt-5": "heavy",
@@ -61,6 +62,7 @@ const MODEL_COST_PER_1K_INPUT = {
     "claude-opus-4-6": 0.005,
     "claude-opus-4-7": 0.005,
     "claude-opus-4-8": 0.005,
+    "claude-fable-5": 0.010,
     "gpt-4o-mini": 0.00015,
     "gpt-4o": 0.0025,
     "gpt-4.1": 0.002,
@@ -94,6 +96,7 @@ export const MODEL_CAPABILITY_PROFILES = {
     "claude-opus-4-6": { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
     "claude-opus-4-7": { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
     "claude-opus-4-8": { coding: 97, debugging: 92, research: 87, reasoning: 97, speed: 30, longContext: 85, instruction: 92 },
+    "claude-fable-5": { coding: 97, debugging: 92, research: 87, reasoning: 97, speed: 30, longContext: 85, instruction: 92 },
     "claude-sonnet-4-6": { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
     "claude-sonnet-4-5-20250514": { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
     "claude-3-5-sonnet-latest": { coding: 82, debugging: 78, research: 72, reasoning: 78, speed: 62, longContext: 70, instruction: 82 },

package/dist/resources/extensions/gsd/notification-store.js

@@ -34,13 +34,16 @@ export function initNotificationStore(basePath) {
  * Append a notification entry to the store. Synchronous — safe to call
  * from the notify() shim which is declared void (not async).
  */
-export function appendNotification(message, severity, source = "notify") {
+export function appendNotification(message, severity, source = "notify", meta) {
     if (!_basePath)
         return;
     if (_suppressCount > 0)
         return;
     const persistedMessage = message.length > 500 ? message.slice(0, 500) + "…" : message;
-    const dedupKey = `${_basePath}:${severity}:${source}:${persistedMessage}`;
+    // Structured identity (kind + scope) keys dedup when present, so a rephrased
+    // message of the same event still dedups; otherwise fall back to the prose.
+    const identity = meta?.kind ? `${meta.kind}:${meta.scope ?? ""}` : persistedMessage;
+    const dedupKey = `${_basePath}:${severity}:${source}:${identity}`;
     const now = Date.now();
     const lastSeen = _recentMessageTimestamps.get(dedupKey);
     if (lastSeen !== undefined && now - lastSeen < DEDUP_WINDOW_MS)
@@ -59,6 +62,8 @@ export function appendNotification(message, severity, source = "notify") {
         message: persistedMessage,
         source,
         read: false,
+        ...(meta?.kind ? { kind: meta.kind } : {}),
+        ...(meta?.scope ? { scope: meta.scope } : {}),
     };
     try {
         const dir = join(_basePath, ".gsd");
@@ -77,12 +82,14 @@ export function appendNotification(message, severity, source = "notify") {
 }
 /**
  * Read all notification entries from disk. Returns newest-first.
+ * An optional filter narrows by structured identity (kind and/or scope).
  */
-export function readNotifications(basePath) {
+export function readNotifications(basePath, filter) {
     const bp = basePath ?? _basePath;
     if (!bp)
         return [];
-    return _readEntriesFromDisk(bp).reverse();
+    const entries = _readEntriesFromDisk(bp).filter((e) => (!filter?.kind || e.kind === filter.kind) && (!filter?.scope || e.scope === filter.scope));
+    return entries.reverse();
 }
 /**
  * Mark all notifications as read. Atomic rewrite via temp-file + rename.

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

@@ -2,31 +2,36 @@
 // Cross-platform desktop notifications for auto-mode events.
 import { execFileSync } from "node:child_process";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { sendRemoteNotification } from "../remote-questions/notify.js";
+import { sendRemoteNotification as _sendRemoteNotification } from "../remote-questions/notify.js";
+/** Swappable dispatcher for remote notifications — exported so tests can mock it. */
+export const remoteNotificationDispatcher = {
+    send: _sendRemoteNotification,
+};
 /**
  * Send a native desktop notification. Non-blocking, non-fatal.
  * macOS: osascript, Linux: notify-send, Windows: skipped.
  */
-export function sendDesktopNotification(title, message, level = "info", kind = "complete", projectName) {
+export function sendDesktopNotification(title, message, level = "info", kind = "complete", projectName, deps = {}) {
     // When a projectName is provided and the title is the default "GSD",
     // replace it with a project-qualified title for multi-project clarity.
     if (projectName && title === "GSD") {
         title = formatNotificationTitle(projectName);
     }
-    const loaded = loadEffectiveGSDPreferences()?.preferences;
+    const loadedPreferences = loadEffectiveGSDPreferences()?.preferences;
+    const notifications = deps.notifications ?? loadedPreferences?.notifications;
     // Remote notifications fire independently of desktop preferences.
     // sendRemoteNotification handles "not configured" gracefully (early return).
-    void sendRemoteNotification(title, message).catch(() => { });
-    if (!shouldSendDesktopNotification(kind, loaded?.notifications))
+    void remoteNotificationDispatcher.send(title, message).catch(() => { });
+    if (!shouldSendDesktopNotification(kind, notifications))
         return;
     // cmux delivery and desktop delivery are independent — if cmux import or
     // delivery fails, we must still attempt the native desktop notification.
     const runCmux = async () => {
         try {
             const { CmuxClient, emitOsc777Notification, resolveCmuxConfig } = await import("../cmux/index.js");
-            const cmux = resolveCmuxConfig(loaded);
+            const cmux = resolveCmuxConfig(loadedPreferences);
             if (cmux.notifications) {
-                const delivered = CmuxClient.fromPreferences(loaded).notify(title, message);
+                const delivered = CmuxClient.fromPreferences(loadedPreferences).notify(title, message);
                 if (delivered)
                     return true;
                 emitOsc777Notification(title, message);

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

@@ -5,9 +5,9 @@
  * with safety checks for parallel execution context.
  */
 import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { resolveGsdPathContract } from "./paths.js";
+import { worktreePathFor, worktreesDirs } from "./worktree-placement.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { buildWorktreeLifecycleDeps } from "./auto.js";
 import { mergeMilestoneStandalone, } from "./worktree-lifecycle.js";
@@ -22,7 +22,7 @@ import { logWarning } from "./workflow-logger.js";
  * Returns true when milestones.status = 'complete' in project gsd.db.
  */
 export function isMilestoneCompleteInProjectDb(basePath, mid) {
-    const workRoot = join(basePath, ".gsd", "worktrees", mid);
+    const workRoot = worktreePathFor(basePath, mid);
     const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
     if (!existsSync(dbPath))
         return false;
@@ -41,16 +41,19 @@ export function isMilestoneCompleteInProjectDb(basePath, mid) {
  */
 function discoverDbCompletedMilestones(basePath) {
     const completed = new Set();
-    const worktreeDir = join(basePath, ".gsd", "worktrees");
-    try {
-        for (const entry of readdirSync(worktreeDir)) {
-            if (entry.startsWith("M") && isMilestoneCompleteInProjectDb(basePath, entry)) {
-                completed.add(entry);
+    for (const worktreeDir of worktreesDirs(basePath)) {
+        if (!existsSync(worktreeDir))
+            continue;
+        try {
+            for (const entry of readdirSync(worktreeDir)) {
+                if (entry.startsWith("M") && isMilestoneCompleteInProjectDb(basePath, entry)) {
+                    completed.add(entry);
+                }
             }
         }
-    }
-    catch (e) {
-        logWarning("parallel", `readdirSync for completed set failed: ${e.message}`);
+        catch (e) {
+            logWarning("parallel", `readdirSync for completed set failed: ${e.message}`);
+        }
     }
     return completed;
 }
@@ -88,7 +91,7 @@ export function determineMergeOrder(workers, order = "sequential", basePath) {
                 title: mid,
                 pid: 0,
                 process: null,
-                worktreePath: basePath ? join(basePath, ".gsd", "worktrees", mid) : "",
+                worktreePath: basePath ? worktreePathFor(basePath, mid) : "",
                 startedAt: 0,
                 state: "stopped",
                 cost: 0,

package/dist/resources/extensions/gsd/parallel-monitor-overlay.js

@@ -7,6 +7,7 @@ import { matchesKey, Key } from "@gsd/pi-tui";
 import { formatDuration } from "../shared/mod.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { resolveGsdPathContract } from "./paths.js";
+import { worktreePathFor, worktreesDirs } from "./worktree-placement.js";
 import { renderBar, renderDialogFrame, renderKeyHints, renderProgressBar, safeLine, statusGlyph, } from "./tui/render-kit.js";
 // ─── Data Helpers ─────────────────────────────────────────────────────────
 function readJsonSafe(filePath) {
@@ -42,7 +43,6 @@ function tailRead(filePath, maxBytes) {
 }
 function discoverWorkers(basePath) {
     const parallelDir = join(basePath, ".gsd", "parallel");
-    const worktreeDir = join(basePath, ".gsd", "worktrees");
     const mids = new Set();
     if (existsSync(parallelDir)) {
         try {
@@ -56,7 +56,9 @@ function discoverWorkers(basePath) {
         }
         catch { /* skip */ }
     }
-    if (existsSync(worktreeDir)) {
+    for (const worktreeDir of worktreesDirs(basePath)) {
+        if (!existsSync(worktreeDir))
+            continue;
         try {
             for (const d of readdirSync(worktreeDir)) {
                 if (d.startsWith("M") && existsSync(join(worktreeDir, d, ".gsd", "auto.lock"))) {
@@ -68,8 +70,7 @@ function discoverWorkers(basePath) {
     }
     return [...mids].sort();
 }
-function querySliceProgress(basePath, mid) {
-    const workRoot = join(basePath, ".gsd", "worktrees", mid);
+function querySliceProgress(basePath, mid, workRoot = worktreePathFor(basePath, mid)) {
     const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
     if (!existsSync(dbPath))
         return [];
@@ -115,7 +116,7 @@ function extractCostFromNdjson(basePath, mid) {
     }
 }
 function queryRecentCompletions(basePath, mid) {
-    const workRoot = join(basePath, ".gsd", "worktrees", mid);
+    const workRoot = worktreePathFor(basePath, mid);
     const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
     if (!existsSync(dbPath))
         return [];
@@ -139,9 +140,12 @@ function collectWorkerData(basePath) {
     const parallelDir = join(basePath, ".gsd", "parallel");
     const workers = [];
     for (const mid of mids) {
+        // Resolve the worktree path once per worker per tick — this runs on a
+        // 5-second refresh interval and worktreePathFor probes the filesystem.
+        const workRoot = worktreePathFor(basePath, mid);
         const status = readJsonSafe(join(parallelDir, `${mid}.status.json`));
-        const lock = readJsonSafe(join(basePath, ".gsd", "worktrees", mid, ".gsd", "auto.lock"));
-        const slices = querySliceProgress(basePath, mid);
+        const lock = readJsonSafe(join(workRoot, ".gsd", "auto.lock"));
+        const slices = querySliceProgress(basePath, mid, workRoot);
         const pid = lock?.pid || status?.pid || 0;
         const alive = pid ? isPidAlive(pid) : false;
         // Heartbeat: prefer status.json if PID matches, else use file mtime

package/dist/resources/extensions/gsd/parsers-legacy.js

@@ -1,10 +1,22 @@
 // GSD Extension - Legacy Parsers
 // parseRoadmap() and parsePlan() extracted from files.ts.
-// Used only by: md-importer.ts (migration), state.ts (pre-migration fallback),
-// markdown-renderer.ts (detectStaleRenders disk-vs-DB comparison),
-// commands-maintenance.ts (cold-path branch cleanup), and tests.
 //
-// NOT used in the dispatch loop or any hot-path runtime code.
+// ADR-017: the DB is the single source of truth; `.gsd/*.md` files are
+// projections. These parsers may be imported ONLY for:
+//   - migration/import (md-importer, workflow-migration, migration-auto-check)
+//   - drift detection that compares both sources by design
+//     (state-reconciliation/drift, markdown-renderer stale-render detection)
+//   - explicit pre-migration / DB-unavailable fallbacks (state.ts,
+//     reactive-graph.ts, auto-recovery.ts)
+//   - diagnostics and display/telemetry-only surfaces (doctor,
+//     doctor-git-checks, workspace-index, visualizer-data, auto-prompts
+//     context text, commands-maintenance, milestone-closeout, github-sync)
+//   - tests
+//
+// Dispatch/gate/completion DECISION paths must NOT import this module — they
+// read the DB via gsd-db queries (e.g. getMilestoneSliceSummaries). Enforced
+// by tests/parsers-legacy-importers.test.ts; new importers must be added to
+// its allowlist with a one-line justification.
 import { extractSection, parseBullets, extractBoldField, extractAllSections, registerCacheClearCallback } from './files.js';
 import { splitFrontmatter } from '../shared/frontmatter.js';
 import { nativeParseRoadmap, nativeParsePlanFile } from './native-parser-bridge.js';