gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

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_IO_ERROR } from './errors.js';
+import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
@@ -205,98 +205,6 @@ 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().
@@ -387,28 +295,14 @@ export async function updateRequirementInDb(id, updates, basePath) {
     try {
         const db = await import('./gsd-db.js');
         const existing = db.getRequirementById(id);
-        // 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)
+        if (!existing) {
+            throw new GSDError(GSD_STALE_STATE, `Requirement ${id} not found`);
+        }
+        // Merge updates into existing
         const merged = {
-            ...base,
+            ...existing,
             ...updates,
-            id: base.id, // ID cannot be changed
+            id: existing.id, // ID cannot be changed
         };
         db.upsertRequirement(merged);
         // Fetch ALL requirements (including superseded) for full file regeneration
@@ -441,9 +335,7 @@ export async function updateRequirementInDb(id, updates, basePath) {
         }
         catch (diskErr) {
             logError('manifest', 'disk write failed, reverting DB row', { fn: 'updateRequirementInDb', error: String(diskErr.message) });
-            if (existing) {
-                db.upsertRequirement(existing);
-            }
+            db.upsertRequirement(existing);
             throw diskErr;
         }
         // Invalidate file-read caches so deriveState() sees the updated markdown.

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

@@ -11,29 +11,6 @@ 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)) {
@@ -330,11 +307,6 @@ 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,8 +144,7 @@ function resolveKey(providerId) {
  */
 const PROVIDER_ROUTES = {
     anthropic: ["github-copilot"],
-    openai: ["github-copilot", "openai-codex"],
-    google: ["google-gemini-cli"],
+    openai: ["github-copilot"],
 };
 function checkLlmProviders() {
     const required = collectConfiguredModelProviders();

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

@@ -108,12 +108,11 @@ 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"
-                // Hook units have compound types: "hook/<hookName>/unitId"
-                const { splitCompletedKey } = await import("./forensics.js");
-                const parsed = splitCompletedKey(key);
-                if (!parsed)
+                const slashIdx = key.indexOf("/");
+                if (slashIdx === -1)
                     continue;
-                const { unitType, unitId } = parsed;
+                const unitType = key.slice(0, slashIdx);
+                const unitId = key.slice(slashIdx + 1);
                 // 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,10 +689,8 @@ 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 && !allTasksDone) {
+            if (!replanPath) {
                 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.*in JSON|Unterminated.*in JSON|SyntaxError.*JSON/i;
+const STREAM_RE = /Unexpected end of JSON|Unexpected token.*JSON|Expected double-quoted property name|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. Stream truncation (malformed JSON from mid-stream cut)
- *  5. Server (500/502/503, overloaded, server_error)
- *  6. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
+ *  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)
  *  7. Unknown
  */
 export function classifyError(errorMsg, retryAfterMs) {
@@ -61,21 +61,18 @@ export function classifyError(errorMsg, retryAfterMs) {
         // "billing" appearing alongside "network").
         return { kind: "network", retryAfterMs: retryAfterMs ?? 3_000 };
     }
-    // 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
+    // 4. Server errors — try fallback model
     if (SERVER_RE.test(errorMsg)) {
         return { kind: "server", retryAfterMs: retryAfterMs ?? 30_000 };
     }
-    // 6. Connection errors — try fallback model
+    // 5. 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,22 +12,7 @@
       "gsd_requirement_update", "gsd_milestone_generate_id"
     ],
     "commands": ["gsd", "kill", "worktree", "exit"],
-    "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"
-    ],
+    "hooks": ["session_start", "session_switch"],
     "shortcuts": ["Ctrl+Alt+G"]
   }
 }

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

@@ -22,8 +22,6 @@ 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";
@@ -31,15 +29,13 @@ import { showNextAction } from "../shared/tui.js";
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
 // ─── Duplicate Detection ──────────────────────────────────────────────────────
 const DEDUP_PROMPT_SECTION = `
-## Pre-Investigation: Duplicate Check (REQUIRED)
+## Duplicate Detection (REQUIRED before issue creation)
 
-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.
+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.
 
 ### Search Steps
 
-Use keywords from the user's problem description and the anomaly summaries in the forensic report above.
-
-1. **Search closed issues** for similar keywords:
+1. **Search closed issues** for similar keywords from your diagnosis:
    \`\`\`
    gh issue list --repo gsd-build/gsd-2 --state closed --search "<keywords from root cause>" --limit 20
    \`\`\`
@@ -56,16 +52,20 @@ Use keywords from the user's problem description and the anomaly summaries in th
 
 ### Analysis
 
-For each result, compare it against the user's reported symptoms and the forensic anomalies:
+For each result, compare it against your root-cause diagnosis:
 - Does the issue describe the same code path or file?
-- Does the PR modify the area related to the reported symptoms?
+- Does the PR modify the same file:line you identified?
 - Is the symptom description semantically similar even if keywords differ?
 
-### Decision Gate
+### 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.
 
-- **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.
+Only proceed to issue creation if no matches were found OR the user explicitly chooses "Create new issue anyway".
 `;
 async function writeForensicsDedupPref(ctx, enabled) {
     const prefsPath = getGlobalGSDPreferencesPath();
@@ -148,8 +148,6 @@ 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) {
@@ -169,9 +167,8 @@ export async function buildForensicReport(basePath) {
     const unitTraces = scanActivityLogs(basePath, activeMilestone);
     // 3. Load metrics
     const metrics = loadLedgerFromDisk(basePath);
-    // 4. Load completed keys (legacy) and DB completion counts
+    // 4. Load completed keys
     const completedKeys = loadCompletedKeys(basePath);
-    const dbCompletionCounts = getDbCompletionCounts();
     // 5. Check crash lock
     const crashLock = readCrashLock(basePath);
     // 6. Run doctor
@@ -225,7 +222,6 @@ export async function buildForensicReport(basePath) {
         unitTraces,
         metrics,
         completedKeys,
-        dbCompletionCounts,
         crashLock,
         doctorIssues,
         anomalies,
@@ -462,41 +458,6 @@ 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();
@@ -554,42 +515,15 @@ 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 parsed = splitCompletedKey(key);
-        if (!parsed)
+        const slashIdx = key.indexOf("/");
+        if (slashIdx === -1)
             continue;
-        const { unitType, unitId } = parsed;
+        const unitType = key.slice(0, slashIdx);
+        const unitId = key.slice(slashIdx + 1);
         const rootHasArtifact = verifyExpectedArtifact(unitType, unitId, basePath);
         const wtHasArtifact = wtBasePath ? verifyExpectedArtifact(unitType, unitId, wtBasePath) : false;
         if (!rootHasArtifact && !wtHasArtifact) {
@@ -815,34 +749,6 @@ 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;
@@ -950,17 +856,8 @@ function formatReportForPrompt(report) {
         }
         sections.push("");
     }
-    // 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}`);
-    }
+    // Completed keys count
+    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, readdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
@@ -348,28 +348,6 @@ 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,7 +38,6 @@ const GSD_RUNTIME_PATTERNS = [
 const BASELINE_PATTERNS = [
     // ── GSD state directory (symlink to external storage) ──
     ".gsd",
-    ".gsd-id",
     // ── OS junk ──
     ".DS_Store",
     "Thumbs.db",
@@ -73,38 +72,6 @@ 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