gsd-pi 2.57.0 → 2.58.0-dev.778d6ac

package/dist/resources/extensions/gsd/db-writer.js

@@ -11,7 +11,7 @@ import { resolve } from 'node:path';
 import { readFileSync, existsSync, statSync } from 'node:fs';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
-import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
+import { GSDError, GSD_IO_ERROR } from './errors.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
@@ -205,6 +205,98 @@ export async function nextDecisionId() {
         return 'D001';
     }
 }
+// ─── Next Requirement ID ─────────────────────────────────────────────────
+/**
+ * Compute the next requirement ID from the current DB state.
+ * Queries MAX(CAST(SUBSTR(id, 2) AS INTEGER)) from requirements table.
+ * Returns R001 if no requirements exist. Zero-pads to 3 digits.
+ */
+export async function nextRequirementId() {
+    try {
+        const db = await import('./gsd-db.js');
+        const adapter = db._getAdapter();
+        if (!adapter)
+            return 'R001';
+        const row = adapter
+            .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM requirements')
+            .get();
+        const maxNum = row ? row['max_num'] : null;
+        if (maxNum == null || isNaN(maxNum))
+            return 'R001';
+        const next = maxNum + 1;
+        return `R${String(next).padStart(3, '0')}`;
+    }
+    catch (err) {
+        logError('manifest', 'nextRequirementId failed', { fn: 'nextRequirementId', error: String(err.message) });
+        return 'R001';
+    }
+}
+/**
+ * Save a new requirement to DB and regenerate REQUIREMENTS.md.
+ * Auto-assigns the next ID via nextRequirementId().
+ * Returns the assigned ID.
+ */
+export async function saveRequirementToDb(fields, basePath) {
+    try {
+        const db = await import('./gsd-db.js');
+        const id = await nextRequirementId();
+        const requirement = {
+            id,
+            class: fields.class,
+            status: fields.status ?? 'active',
+            description: fields.description,
+            why: fields.why,
+            source: fields.source,
+            primary_owner: fields.primary_owner ?? '',
+            supporting_slices: fields.supporting_slices ?? '',
+            validation: fields.validation ?? '',
+            notes: fields.notes ?? '',
+            full_content: '',
+            superseded_by: null,
+        };
+        db.upsertRequirement(requirement);
+        // Fetch all requirements for full file regeneration
+        const adapter = db._getAdapter();
+        let allRequirements = [];
+        if (adapter) {
+            const rows = adapter.prepare('SELECT * FROM requirements ORDER BY id').all();
+            allRequirements = rows.map(row => ({
+                id: row['id'],
+                class: row['class'],
+                status: row['status'],
+                description: row['description'],
+                why: row['why'],
+                source: row['source'],
+                primary_owner: row['primary_owner'],
+                supporting_slices: row['supporting_slices'],
+                validation: row['validation'],
+                notes: row['notes'],
+                full_content: row['full_content'],
+                superseded_by: row['superseded_by'] ?? null,
+            }));
+        }
+        const nonSuperseded = allRequirements.filter(r => r.superseded_by == null);
+        const md = generateRequirementsMd(nonSuperseded);
+        const filePath = resolveGsdRootFile(basePath, 'REQUIREMENTS');
+        try {
+            await saveFile(filePath, md);
+        }
+        catch (diskErr) {
+            logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String(diskErr.message) });
+            const rollbackAdapter = db._getAdapter();
+            rollbackAdapter?.prepare('DELETE FROM requirements WHERE id = :id').run({ ':id': id });
+            throw diskErr;
+        }
+        invalidateStateCache();
+        clearPathCache();
+        clearParseCache();
+        return { id };
+    }
+    catch (err) {
+        logError('manifest', 'saveRequirementToDb failed', { fn: 'saveRequirementToDb', error: String(err.message) });
+        throw err;
+    }
+}
 /**
  * Save a new decision to DB and regenerate DECISIONS.md.
  * Auto-assigns the next ID via nextDecisionId().
@@ -295,14 +387,28 @@ export async function updateRequirementInDb(id, updates, basePath) {
     try {
         const db = await import('./gsd-db.js');
         const existing = db.getRequirementById(id);
-        if (!existing) {
-            throw new GSDError(GSD_STALE_STATE, `Requirement ${id} not found`);
-        }
-        // Merge updates into existing
+        // If requirement doesn't exist in DB, create a skeleton and merge updates.
+        // This handles the case where requirements were written to REQUIREMENTS.md
+        // but never imported into the database (see #2919).
+        const base = existing ?? {
+            id,
+            class: '',
+            status: 'active',
+            description: '',
+            why: '',
+            source: '',
+            primary_owner: '',
+            supporting_slices: '',
+            validation: '',
+            notes: '',
+            full_content: '',
+            superseded_by: null,
+        };
+        // Merge updates into existing (or skeleton)
         const merged = {
-            ...existing,
+            ...base,
             ...updates,
-            id: existing.id, // ID cannot be changed
+            id: base.id, // ID cannot be changed
         };
         db.upsertRequirement(merged);
         // Fetch ALL requirements (including superseded) for full file regeneration
@@ -335,7 +441,9 @@ export async function updateRequirementInDb(id, updates, basePath) {
         }
         catch (diskErr) {
             logError('manifest', 'disk write failed, reverting DB row', { fn: 'updateRequirementInDb', error: String(diskErr.message) });
-            db.upsertRequirement(existing);
+            if (existing) {
+                db.upsertRequirement(existing);
+            }
             throw diskErr;
         }
         // Invalidate file-read caches so deriveState() sees the updated markdown.

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -18,9 +18,19 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
     const { milestone: targetMid, slice: targetSid } = parseUnitId(unitId);
     if (!targetMid || !targetSid)
         return null;
+    // Parallel worker isolation: when GSD_MILESTONE_LOCK is set, this worker
+    // is scoped to a single milestone. Skip the cross-milestone dependency
+    // check — other milestones are being handled by their own workers.
+    // Without this, the dispatch guard sees incomplete slices in M010/M011
+    // (cloned into the worktree DB) and blocks M012 from ever starting. #2797
+    const milestoneLock = process.env.GSD_MILESTONE_LOCK;
     // Use findMilestoneIds to respect custom queue order.
     // Only check milestones that come BEFORE the target in queue order.
-    const allIds = findMilestoneIds(base);
+    // When locked to a specific milestone, only check that milestone's
+    // intra-slice dependencies — skip all cross-milestone checks.
+    const allIds = milestoneLock && targetMid === milestoneLock
+        ? [targetMid]
+        : findMilestoneIds(base);
     const targetIdx = allIds.indexOf(targetMid);
     if (targetIdx < 0)
         return null;

package/dist/resources/extensions/gsd/doctor-git-checks.js

@@ -11,6 +11,29 @@ import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegr
 import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached } from "./native-git-bridge.js";
 import { getAllWorktreeHealth } from "./worktree-health.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+/**
+ * Returns true if the directory contains only doctor artifacts
+ * (e.g. `.gsd/doctor-history.jsonl`). These dirs are created by
+ * appendDoctorHistory() writing to worktree-scoped paths during the audit
+ * and should not be flagged as orphaned worktrees (#3105).
+ */
+function isDoctorArtifactOnly(dirPath) {
+    try {
+        const entries = readdirSync(dirPath);
+        // Empty dir — not a doctor artifact, still orphaned
+        if (entries.length === 0)
+            return false;
+        // Only a .gsd subdirectory
+        if (entries.length === 1 && entries[0] === ".gsd") {
+            const gsdEntries = readdirSync(join(dirPath, ".gsd"));
+            return gsdEntries.length <= 1 && gsdEntries.every(e => e === "doctor-history.jsonl");
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "none") {
     // Degrade gracefully if not a git repo
     if (!nativeIsRepo(basePath)) {
@@ -307,6 +330,11 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                 }
                 const normalizedFullPath = normalizePath(fullPath);
                 if (!registeredPaths.has(normalizedFullPath)) {
+                    // Skip directories that only contain doctor artifacts (.gsd/doctor-history.jsonl).
+                    // appendDoctorHistory() can recreate these dirs during the audit itself,
+                    // causing a circular false positive (#3105 Bug 1).
+                    if (isDoctorArtifactOnly(fullPath))
+                        continue;
                     issues.push({
                         severity: "warning",
                         code: "worktree_directory_orphaned",

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -144,7 +144,8 @@ function resolveKey(providerId) {
  */
 const PROVIDER_ROUTES = {
     anthropic: ["github-copilot"],
-    openai: ["github-copilot"],
+    openai: ["github-copilot", "openai-codex"],
+    google: ["google-gemini-cli"],
 };
 function checkLlmProviders() {
     const required = collectConfiguredModelProviders();

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -108,11 +108,12 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
             const orphaned = [];
             for (const key of keys) {
                 // Key format: "unitType/unitId" e.g. "execute-task/M001/S01/T01"
-                const slashIdx = key.indexOf("/");
-                if (slashIdx === -1)
+                // Hook units have compound types: "hook/<hookName>/unitId"
+                const { splitCompletedKey } = await import("./forensics.js");
+                const parsed = splitCompletedKey(key);
+                if (!parsed)
                     continue;
-                const unitType = key.slice(0, slashIdx);
-                const unitId = key.slice(slashIdx + 1);
+                const { unitType, unitId } = parsed;
                 // Only validate artifact-producing unit types
                 const { verifyExpectedArtifact } = await import("./auto-recovery.js");
                 if (!verifyExpectedArtifact(unitType, unitId, basePath)) {

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

@@ -689,8 +689,10 @@ export async function runGSDDoctor(basePath, options) {
                 allTasksDone = allTasksDone && task.done;
             }
             // Blocker-without-replan detection
+            // Skip when all tasks are done — the blocker was implicitly resolved
+            // within the task and the slice is not stuck (#3105 Bug 2).
             const replanPath = resolveSliceFile(basePath, milestoneId, slice.id, "REPLAN");
-            if (!replanPath) {
+            if (!replanPath && !allTasksDone) {
                 for (const task of plan.tasks) {
                     if (!task.done)
                         continue;

package/dist/resources/extensions/gsd/error-classifier.js

@@ -24,7 +24,7 @@ const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fet
 const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i;
 // ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
 const CONNECTION_RE = /terminated|connection.?refused|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
-const STREAM_RE = /Unexpected end of JSON|Unexpected token.*JSON|Expected double-quoted property name|SyntaxError.*JSON/i;
+const STREAM_RE = /Unexpected end of JSON|Unexpected token.*JSON|Expected.*in JSON|Unterminated.*in JSON|SyntaxError.*JSON/i;
 const RESET_DELAY_RE = /reset in (\d+)s/i;
 /**
  * Classify an error message into one of the ErrorClass kinds.
@@ -33,9 +33,9 @@ const RESET_DELAY_RE = /reset in (\d+)s/i;
  *  1. Permanent (auth/billing/quota) — unless also rate-limited
  *  2. Rate limit (429, rate.?limit, too many requests)
  *  3. Network (ECONNRESET, ETIMEDOUT, socket hang up, fetch failed, dns)
- *  4. Server (500/502/503, overloaded, server_error)
- *  5. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
- *  6. Stream truncation (malformed JSON from mid-stream cut)
+ *  4. Stream truncation (malformed JSON from mid-stream cut)
+ *  5. Server (500/502/503, overloaded, server_error)
+ *  6. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
  *  7. Unknown
  */
 export function classifyError(errorMsg, retryAfterMs) {
@@ -61,18 +61,21 @@ export function classifyError(errorMsg, retryAfterMs) {
         // "billing" appearing alongside "network").
         return { kind: "network", retryAfterMs: retryAfterMs ?? 3_000 };
     }
-    // 4. Server errors — try fallback model
+    // 4. Stream truncation — downstream symptom of connection drop
+    //    Checked before server/connection because JSON parse errors can contain
+    //    substrings like "position 500" (matches SERVER_RE) or "Unterminated"
+    //    (matches CONNECTION_RE's "terminated" pattern).
+    if (STREAM_RE.test(errorMsg)) {
+        return { kind: "stream", retryAfterMs: retryAfterMs ?? 15_000 };
+    }
+    // 5. Server errors — try fallback model
     if (SERVER_RE.test(errorMsg)) {
         return { kind: "server", retryAfterMs: retryAfterMs ?? 30_000 };
     }
-    // 5. Connection errors — try fallback model
+    // 6. Connection errors — try fallback model
     if (CONNECTION_RE.test(errorMsg)) {
         return { kind: "connection", retryAfterMs: retryAfterMs ?? 15_000 };
     }
-    // 6. Stream truncation — downstream symptom of connection drop
-    if (STREAM_RE.test(errorMsg)) {
-        return { kind: "stream", retryAfterMs: retryAfterMs ?? 15_000 };
-    }
     // 7. Unknown
     return { kind: "unknown" };
 }

package/dist/resources/extensions/gsd/extension-manifest.json

@@ -12,7 +12,22 @@
       "gsd_requirement_update", "gsd_milestone_generate_id"
     ],
     "commands": ["gsd", "kill", "worktree", "exit"],
-    "hooks": ["session_start", "session_switch"],
+    "hooks": [
+      "session_start",
+      "session_switch",
+      "bash_transform",
+      "session_fork",
+      "before_agent_start",
+      "agent_end",
+      "session_before_compact",
+      "session_shutdown",
+      "tool_call",
+      "tool_result",
+      "tool_execution_start",
+      "tool_execution_end",
+      "model_select",
+      "before_provider_request"
+    ],
     "shortcuts": ["Ctrl+Alt+G"]
   }
 }

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

@@ -22,6 +22,8 @@ import { deriveState } from "./state.js";
 import { isAutoActive } from "./auto.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
+import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 import { formatDuration } from "../shared/format-utils.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
@@ -29,13 +31,15 @@ import { showNextAction } from "../shared/tui.js";
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
 // ─── Duplicate Detection ──────────────────────────────────────────────────────
 const DEDUP_PROMPT_SECTION = `
-## Duplicate Detection (REQUIRED before issue creation)
+## Pre-Investigation: Duplicate Check (REQUIRED)
 
-Before offering to create a GitHub issue, you MUST search for existing issues and PRs that may already address this bug. This step uses the user's AI tokens for analysis.
+Before reading GSD source code or performing deep analysis, you MUST search for existing issues and PRs that may already address this bug. This avoids wasting tokens on already-fixed bugs.
 
 ### Search Steps
 
-1. **Search closed issues** for similar keywords from your diagnosis:
+Use keywords from the user's problem description and the anomaly summaries in the forensic report above.
+
+1. **Search closed issues** for similar keywords:
    \`\`\`
    gh issue list --repo gsd-build/gsd-2 --state closed --search "<keywords from root cause>" --limit 20
    \`\`\`
@@ -52,20 +56,16 @@ Before offering to create a GitHub issue, you MUST search for existing issues an
 
 ### Analysis
 
-For each result, compare it against your root-cause diagnosis:
+For each result, compare it against the user's reported symptoms and the forensic anomalies:
 - Does the issue describe the same code path or file?
-- Does the PR modify the same file:line you identified?
+- Does the PR modify the area related to the reported symptoms?
 - Is the symptom description semantically similar even if keywords differ?
 
-### Present Findings
-
-If you find potential matches, present them to the user:
-
-1. **"Already fixed by PR #X — skip issue creation"** — when a merged PR or closed issue clearly addresses the same root cause. Explain why you believe it matches.
-2. **"Add my findings to existing issue #Y"** — when an open issue exists for the same bug. Use \`gh issue comment #Y --repo gsd-build/gsd-2\` to add forensic evidence.
-3. **"Create new issue anyway"** — when existing results do not cover this specific failure.
+### Decision Gate
 
-Only proceed to issue creation if no matches were found OR the user explicitly chooses "Create new issue anyway".
+- **Merged PR clearly fixes the described symptom** → Report "Already fixed by PR #X" with brief explanation. Skip full investigation.
+- **Open issue matches** → Report "Existing issue #Y covers this." Offer to add forensic evidence. Skip full investigation unless user asks for deeper analysis.
+- **No matches** → Proceed to full investigation below.
 `;
 async function writeForensicsDedupPref(ctx, enabled) {
     const prefsPath = getGlobalGSDPreferencesPath();
@@ -148,6 +148,8 @@ export async function handleForensics(args, ctx, pi) {
     });
     ctx.ui.notify(`Forensic report saved: ${relative(basePath, savedPath)}`, "info");
     pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });
+    // Persist forensics context so follow-up turns can re-inject it (#2941)
+    writeForensicsMarker(basePath, savedPath, content);
 }
 // ─── Report Builder ───────────────────────────────────────────────────────────
 export async function buildForensicReport(basePath) {
@@ -167,8 +169,9 @@ export async function buildForensicReport(basePath) {
     const unitTraces = scanActivityLogs(basePath, activeMilestone);
     // 3. Load metrics
     const metrics = loadLedgerFromDisk(basePath);
-    // 4. Load completed keys
+    // 4. Load completed keys (legacy) and DB completion counts
     const completedKeys = loadCompletedKeys(basePath);
+    const dbCompletionCounts = getDbCompletionCounts();
     // 5. Check crash lock
     const crashLock = readCrashLock(basePath);
     // 6. Run doctor
@@ -222,6 +225,7 @@ export async function buildForensicReport(basePath) {
         unitTraces,
         metrics,
         completedKeys,
+        dbCompletionCounts,
         crashLock,
         doctorIssues,
         anomalies,
@@ -458,6 +462,41 @@ function loadCompletedKeys(basePath) {
     catch { /* non-fatal */ }
     return [];
 }
+// ─── DB Completion Counts ────────────────────────────────────────────────────
+function getDbCompletionCounts() {
+    if (!isDbAvailable())
+        return null;
+    const milestones = getAllMilestones();
+    let completedMilestones = 0;
+    let totalSlices = 0;
+    let completedSlices = 0;
+    let totalTasks = 0;
+    let completedTasks = 0;
+    for (const m of milestones) {
+        if (isClosedStatus(m.status))
+            completedMilestones++;
+        const slices = getMilestoneSlices(m.id);
+        for (const s of slices) {
+            totalSlices++;
+            if (isClosedStatus(s.status))
+                completedSlices++;
+            const tasks = getSliceTasks(m.id, s.id);
+            for (const t of tasks) {
+                totalTasks++;
+                if (isClosedStatus(t.status))
+                    completedTasks++;
+            }
+        }
+    }
+    return {
+        milestones: completedMilestones,
+        milestonesTotal: milestones.length,
+        slices: completedSlices,
+        slicesTotal: totalSlices,
+        tasks: completedTasks,
+        tasksTotal: totalTasks,
+    };
+}
 // ─── Anomaly Detectors ───────────────────────────────────────────────────────
 function detectStuckLoops(units, anomalies) {
     const counts = new Map();
@@ -515,15 +554,42 @@ function detectTimeouts(traces, anomalies) {
         }
     }
 }
+/**
+ * Parse a completed-unit key into its unitType and unitId.
+ *
+ * Hook units use a compound slash-delimited type ("hook/<hookName>"), so a
+ * naive `key.indexOf("/")` would split "hook/telegram-progress/M007/S01" into
+ * unitType="hook" (wrong) instead of "hook/telegram-progress".
+ *
+ * Returns `null` for malformed keys that cannot be split.
+ */
+export function splitCompletedKey(key) {
+    if (key.startsWith("hook/")) {
+        // Hook unit types are two segments: "hook/<hookName>/<unitId...>"
+        const secondSlash = key.indexOf("/", 5); // skip past "hook/"
+        if (secondSlash === -1)
+            return null; // malformed — no unitId after hook name
+        return {
+            unitType: key.slice(0, secondSlash),
+            unitId: key.slice(secondSlash + 1),
+        };
+    }
+    const slashIdx = key.indexOf("/");
+    if (slashIdx === -1)
+        return null;
+    return {
+        unitType: key.slice(0, slashIdx),
+        unitId: key.slice(slashIdx + 1),
+    };
+}
 function detectMissingArtifacts(completedKeys, basePath, activeMilestone, anomalies) {
     // Also check the worktree path for artifacts — they may exist there but not at root
     const wtBasePath = activeMilestone ? getAutoWorktreePath(basePath, activeMilestone) : null;
     for (const key of completedKeys) {
-        const slashIdx = key.indexOf("/");
-        if (slashIdx === -1)
+        const parsed = splitCompletedKey(key);
+        if (!parsed)
             continue;
-        const unitType = key.slice(0, slashIdx);
-        const unitId = key.slice(slashIdx + 1);
+        const { unitType, unitId } = parsed;
         const rootHasArtifact = verifyExpectedArtifact(unitType, unitId, basePath);
         const wtHasArtifact = wtBasePath ? verifyExpectedArtifact(unitType, unitId, wtBasePath) : false;
         if (!rootHasArtifact && !wtHasArtifact) {
@@ -749,6 +815,34 @@ function saveForensicReport(basePath, report, problemDescription) {
     writeFileSync(filePath, sections.join("\n"), "utf-8");
     return filePath;
 }
+/**
+ * Write a marker file so that buildBeforeAgentStartResult() can re-inject
+ * the forensics prompt on follow-up turns.  (#2941)
+ */
+export function writeForensicsMarker(basePath, reportPath, promptContent) {
+    const dir = join(gsdRoot(basePath), "runtime");
+    mkdirSync(dir, { recursive: true });
+    const marker = {
+        reportPath,
+        promptContent,
+        createdAt: new Date().toISOString(),
+    };
+    writeFileSync(join(dir, "active-forensics.json"), JSON.stringify(marker), "utf-8");
+}
+/**
+ * Read the active forensics marker, or null if none exists.
+ */
+export function readForensicsMarker(basePath) {
+    const markerPath = join(gsdRoot(basePath), "runtime", "active-forensics.json");
+    if (!existsSync(markerPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(markerPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Prompt Formatter ─────────────────────────────────────────────────────────
 function formatReportForPrompt(report) {
     const MAX_BYTES = 30 * 1024;
@@ -856,8 +950,17 @@ function formatReportForPrompt(report) {
         }
         sections.push("");
     }
-    // Completed keys count
-    sections.push(`### Completed Keys: ${report.completedKeys.length}`);
+    // Completion status — prefer DB counts, fall back to legacy completed-units.json
+    if (report.dbCompletionCounts) {
+        const c = report.dbCompletionCounts;
+        sections.push(`### Completion Status (from DB)`);
+        sections.push(`- ${c.milestones}/${c.milestonesTotal} milestones complete`);
+        sections.push(`- ${c.slices}/${c.slicesTotal} slices complete`);
+        sections.push(`- ${c.tasks}/${c.tasksTotal} tasks complete`);
+    }
+    else {
+        sections.push(`### Completed Keys: ${report.completedKeys.length}`);
+    }
     sections.push(`### GSD Version: ${report.gsdVersion}`);
     sections.push(`### Active Milestone: ${report.activeMilestone ?? "none"}`);
     sections.push(`### Active Slice: ${report.activeSlice ?? "none"}`);

package/dist/resources/extensions/gsd/git-service.js

@@ -8,7 +8,7 @@
  * paths, commit type inference, and the runGit shell helper.
  */
 import { execFileSync, execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
@@ -348,6 +348,28 @@ export class GitServiceImpl {
         // If .gsd/ IS in .gitignore (the default for external state projects),
         // git add -A already skips it and the exclusions are harmless no-ops.
         const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
+        // ── Parallel worker milestone scope (#1991) ──
+        // When GSD_MILESTONE_LOCK is set, this process is a parallel worker that
+        // must only commit files belonging to its own milestone. Exclude all other
+        // milestone directories from staging to prevent cross-milestone pollution
+        // (e.g., an M033 worker fabricating M032 artifacts in the same commit).
+        const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+        if (milestoneLock) {
+            const msDir = join(gsdRoot(this.basePath), "milestones");
+            if (existsSync(msDir)) {
+                try {
+                    const entries = readdirSync(msDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory() && entry.name !== milestoneLock) {
+                            allExclusions.push(`.gsd/milestones/${entry.name}/`);
+                        }
+                    }
+                }
+                catch {
+                    // Best-effort — if we can't read the milestones dir, proceed without scoping
+                }
+            }
+        }
         nativeAddAllWithExclusions(this.basePath, allExclusions);
     }
     /** Tracks whether runtime file cleanup has run this session. */

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

@@ -38,6 +38,7 @@ const GSD_RUNTIME_PATTERNS = [
 const BASELINE_PATTERNS = [
     // ── GSD state directory (symlink to external storage) ──
     ".gsd",
+    ".gsd-id",
     // ── OS junk ──
     ".DS_Store",
     "Thumbs.db",
@@ -72,6 +73,38 @@ const BASELINE_PATTERNS = [
     ".cache/",
     "tmp/",
 ];
+/**
+ * Check whether `.gsd` is covered by the project's `.gitignore`.
+ *
+ * Uses `git check-ignore` for accurate evaluation — this respects nested
+ * .gitignore files, global gitignore, and negation patterns. Returns true
+ * only when git would actually ignore `.gsd/`.
+ *
+ * Returns false (not ignored) if:
+ *   - No `.gitignore` exists
+ *   - `.gsd` is not listed in any active ignore rule
+ *   - Not a git repo or git is unavailable
+ */
+export function isGsdGitignored(basePath) {
+    // Check both `.gsd` and `.gsd/` because `.gsd/` in .gitignore (trailing
+    // slash = directory-only pattern) only matches the directory form. Using
+    // both paths covers all gitignore pattern variants.
+    for (const path of [".gsd", ".gsd/"]) {
+        try {
+            // git check-ignore exits 0 when the path IS ignored, 1 when it is NOT.
+            execFileSync("git", ["check-ignore", "-q", path], {
+                cwd: basePath,
+                stdio: "pipe",
+                env: GIT_NO_PROMPT_ENV,
+            });
+            return true; // exit 0 → .gsd is ignored
+        }
+        catch {
+            // exit 1 → this form is NOT ignored, try the other
+        }
+    }
+    return false; // neither form is ignored (or git unavailable)
+}
 /**
  * Check whether `.gsd/` contains files tracked by git.
  * If so, the project intentionally keeps `.gsd/` in version control