gsd-pi 2.72.0 → 2.73.0-dev.27730dc

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -1712,7 +1712,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     });
 }
 // ─── Reactive Execute Prompt ──────────────────────────────────────────────
-export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base) {
+export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, readyTaskIds, base, subagentModel) {
     const { loadSliceTaskIO, deriveTaskGraph, graphMetrics } = await import("./reactive-graph.js");
     // Build graph for context
     const taskIO = await loadSliceTaskIO(base, mid, sid);
@@ -1744,10 +1744,11 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
         const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
         // Build a full execute-task prompt with dependency-based carry-forward
         const taskPrompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, { carryForwardPaths: depPaths });
+        const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
             `### ${tid}: ${tTitle}`,
             "",
-            "Use this as the prompt for a `subagent` call:",
+            `Use this as the prompt for a \`subagent\` call${modelSuffix}:`,
             "",
             "```",
             taskPrompt,
@@ -1806,15 +1807,16 @@ function renderGatesToCloseBlock(gates, opts) {
     }
     return lines.join("\n").trimEnd();
 }
-export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, basePath) {
+export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, basePath, subagentModel) {
     // Build individual research-slice prompts for each slice
     const subagentSections = [];
+    const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
     for (const slice of slices) {
         const slicePrompt = await buildResearchSlicePrompt(mid, midTitle, slice.id, slice.title, basePath);
         subagentSections.push([
             `### ${slice.id}: ${slice.title}`,
             "",
-            "Use this as the prompt for a `subagent` call (agent: `gsd-executor` or the default agent):",
+            `Use this as the prompt for a \`subagent\` call${modelSuffix} (agent: \`gsd-executor\` or the default agent):`,
             "",
             "```",
             slicePrompt,
@@ -1829,7 +1831,7 @@ export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, b
         subagentPrompts: subagentSections.join("\n\n---\n\n"),
     });
 }
-export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base) {
+export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base, subagentModel) {
     // Pull only the gates this turn actually owns (Q3/Q4). Filter via the
     // registry so that scope:"slice" gates owned by other turns (Q8) can't
     // leak into this prompt and can't block dispatch via silent skip.
@@ -1873,10 +1875,11 @@ export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base)
             "- `rationale`: one-sentence justification",
             "- `findings`: detailed markdown findings (or empty if omitted)",
         ].join("\n");
+        const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
             `### ${def.id}: ${def.question}`,
             "",
-            "Use this as the prompt for a `subagent` call:",
+            `Use this as the prompt for a \`subagent\` call${modelSuffix}:`,
             "",
             "```",
             subPrompt,

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -224,6 +224,17 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         if (!isValidationTerminal(validationContent))
             return false;
     }
+    if (unitType === "plan-milestone") {
+        try {
+            const roadmap = parseLegacyRoadmap(readFileSync(absPath, "utf-8"));
+            if (roadmap.slices.length === 0)
+                return false;
+        }
+        catch (err) {
+            logWarning("recovery", `plan-milestone roadmap verification failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    }
     // plan-slice must produce a plan with actual task entries, not just a scaffold.
     // The plan file may exist from a prior discussion/context step with only headings
     // but no tasks. Without this check the artifact is considered "complete" and the

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

@@ -19,7 +19,7 @@ import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveDir, milest
 import { invalidateAllCaches } from "./cache.js";
 import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, readActiveMilestoneId, } from "./session-forensics.js";
-import { writeLock, clearLock, readCrashLock, isLockProcessAlive, formatCrashInfo, } from "./crash-recovery.js";
+import { writeLock, clearLock, readCrashLock, isLockProcessAlive, formatCrashInfo, emitCrashRecoveredUnitEnd, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
@@ -425,9 +425,13 @@ function cleanupAfterLoopExit(ctx) {
         /* best-effort — mirror stopAuto cleanup */
         logWarning("session", `lock cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
-    ctx.ui.setStatus("gsd-auto", undefined);
-    ctx.ui.setWidget("gsd-progress", undefined);
-    ctx.ui.setFooter(undefined);
+    // A transient provider-error pause intentionally leaves the paused badge
+    // visible so the user still has a resumable auto-mode signal on screen.
+    if (!s.paused) {
+        ctx.ui.setStatus("gsd-auto", undefined);
+        ctx.ui.setWidget("gsd-progress", undefined);
+        ctx.ui.setFooter(undefined);
+    }
     // Restore CWD out of worktree back to original project root
     if (s.originalBasePath) {
         s.basePath = s.originalBasePath;
@@ -529,7 +533,22 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-worktree", { error: e instanceof Error ? e.message : String(e) });
         }
-        // ── Step 5: DB cleanup ──
+        // ── Step 5: Rebuild state while DB is still open (#3599) ──
+        // rebuildState() calls deriveState() which needs the DB for authoritative
+        // state. Previously this ran after closeDatabase(), forcing a filesystem
+        // fallback that could disagree with the DB-backed dispatch decisions —
+        // a split-brain where dispatch says "blocked" but STATE.md shows work.
+        if (s.basePath) {
+            try {
+                await rebuildState(s.basePath);
+            }
+            catch (e) {
+                debugLog("stop-rebuild-state-failed", {
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        // ── Step 6: DB cleanup ──
         if (isDbAvailable()) {
             try {
                 const { closeDatabase } = await import("./gsd-db.js");
@@ -541,7 +560,7 @@ export async function stopAuto(ctx, pi, reason) {
                 });
             }
         }
-        // ── Step 6: Restore basePath and chdir ──
+        // ── Step 7: Restore basePath and chdir ──
         try {
             if (s.originalBasePath) {
                 s.basePath = s.originalBasePath;
@@ -557,7 +576,7 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-basepath", { error: e instanceof Error ? e.message : String(e) });
         }
-        // ── Step 7: Ledger notification ──
+        // ── Step 8: Ledger notification ──
         try {
             const ledger = getLedger();
             if (ledger && ledger.units.length > 0) {
@@ -571,17 +590,6 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-ledger", { error: e instanceof Error ? e.message : String(e) });
         }
-        // ── Step 8: Rebuild state ──
-        if (s.basePath) {
-            try {
-                await rebuildState(s.basePath);
-            }
-            catch (e) {
-                debugLog("stop-rebuild-state-failed", {
-                    error: e instanceof Error ? e.message : String(e),
-                });
-            }
-        }
         // ── Step 9: Cmux sidebar / event log ──
         try {
             clearCmuxSidebar(loadedPreferences);
@@ -1006,6 +1014,10 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
     }
     if (freshStartAssessment.lock) {
+        // Emit a synthetic unit-end for any unit-start that has no closing event.
+        // This closes the journal gap reported in #3348 where the worker wrote side
+        // effects (SUMMARY.md, DB updates) but died before emitting unit-end.
+        emitCrashRecoveredUnitEnd(base, freshStartAssessment.lock);
         clearLock(base);
     }
     if (!s.paused) {
@@ -1294,8 +1306,6 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
     pi.sendMessage({ customType: "gsd-auto", content: hookPrompt, display: true }, { triggerTurn: true });
     return true;
 }
-// Direct phase dispatch → auto-direct-dispatch.ts
-export { dispatchDirectPhase } from "./auto-direct-dispatch.js";
 // Re-export recovery functions for external consumers
 export { buildLoopRemediationSteps, } from "./auto-recovery.js";
 export { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";

package/dist/resources/extensions/gsd/bootstrap/crash-log.js

@@ -0,0 +1,31 @@
+/**
+ * crash-log.ts — Write crash diagnostics to ~/.gsd/crash/<timestamp>.log
+ *
+ * Zero cross-dependencies: only uses Node.js built-ins so it can be imported
+ * safely from uncaughtException / unhandledRejection handlers and from tests
+ * without pulling in the full extension dependency tree.
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Write a crash log to ~/.gsd/crash/<timestamp>.log (or $GSD_HOME/crash/).
+ * Never throws — must be safe to call from any error handler.
+ */
+export function writeCrashLog(err, source) {
+    try {
+        const crashDir = join(process.env.GSD_HOME ?? join(homedir(), ".gsd"), "crash");
+        mkdirSync(crashDir, { recursive: true });
+        const ts = new Date().toISOString().replace(/[:.]/g, "-");
+        const logPath = join(crashDir, `${ts}.log`);
+        const lines = [
+            `[gsd] ${source}: ${err.message}`,
+            `timestamp: ${new Date().toISOString()}`,
+            `pid: ${process.pid}`,
+            err.stack ?? "(no stack trace available)",
+            "",
+        ];
+        appendFileSync(logPath, lines.join("\n"));
+    }
+    catch { /* never throw from crash handler */ }
+}

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -8,6 +8,8 @@ import { registerJournalTools } from "./journal-tools.js";
 import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
+import { writeCrashLog } from "./crash-log.js";
+export { writeCrashLog } from "./crash-log.js";
 export function handleRecoverableExtensionProcessError(err) {
     if (err.code === "EPIPE") {
         process.exit(0);
@@ -28,17 +30,26 @@ export function handleRecoverableExtensionProcessError(err) {
 function installEpipeGuard() {
     if (!process.listeners("uncaughtException").some((listener) => listener.name === "_gsdEpipeGuard")) {
         const _gsdEpipeGuard = (err) => {
-            if (handleRecoverableExtensionProcessError(err)) {
+            if (handleRecoverableExtensionProcessError(err))
                 return;
-            }
-            // Log unhandled errors instead of re-throwing — throwing inside an
-            // uncaughtException handler is a fatal double-fault in Node.js (#3163).
-            process.stderr.write(`[gsd] uncaught extension error (non-fatal): ${err.message}\n`);
-            if (err.stack)
-                process.stderr.write(`${err.stack}\n`);
+            // Write crash log and exit cleanly for unrecoverable errors.
+            // Logging and continuing was the original double-fault fix (#3163), but
+            // continuing in an indeterminate state is worse than a clean exit (#3348).
+            writeCrashLog(err, "uncaughtException");
+            process.exit(1);
         };
         process.on("uncaughtException", _gsdEpipeGuard);
     }
+    if (!process.listeners("unhandledRejection").some((listener) => listener.name === "_gsdRejectionGuard")) {
+        const _gsdRejectionGuard = (reason, _promise) => {
+            const err = reason instanceof Error ? reason : new Error(String(reason));
+            if (handleRecoverableExtensionProcessError(err))
+                return;
+            writeCrashLog(err, "unhandledRejection");
+            process.exit(1);
+        };
+        process.on("unhandledRejection", _gsdRejectionGuard);
+    }
 }
 export function registerGsdExtension(pi) {
     registerGSDCommand(pi);

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -172,14 +172,10 @@ export function registerHooks(pi) {
         // Only gate-shaped ask_user_questions calls should block execution.
         // The gate stays pending until the user selects the approval option.
         if (event.toolName === "ask_user_questions") {
-            const milestoneId = getDiscussionMilestoneId(discussionBasePath);
-            const inDiscussion = milestoneId !== null || isQueuePhaseActive();
-            if (inDiscussion) {
-                const questions = event.input?.questions ?? [];
-                const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
-                if (typeof questionId === "string") {
-                    setPendingGate(questionId);
-                }
+            const questions = event.input?.questions ?? [];
+            const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
+            if (typeof questionId === "string") {
+                setPendingGate(questionId);
             }
         }
         // ── Discussion gate enforcement: block tool calls while gate is pending ──
@@ -261,8 +257,6 @@ export function registerHooks(pi) {
             return;
         const milestoneId = getDiscussionMilestoneId(process.cwd());
         const queueActive = isQueuePhaseActive();
-        if (!milestoneId && !queueActive)
-            return;
         const details = event.details;
         // ── Discussion gate enforcement: handle gate question responses ──
         // If the result is cancelled or has no response, the pending gate stays active
@@ -293,12 +287,16 @@ export function registerHooks(pi) {
                 // Only unlock the gate if the user selected the first option (confirmation).
                 // Cross-references against the question's defined options to reject free-form "Other" text.
                 const answer = details.response?.answers?.[question.id];
+                const inferredMilestoneId = extractDepthVerificationMilestoneId(question.id) ?? milestoneId;
                 if (isDepthConfirmationAnswer(answer?.selected, question.options)) {
-                    markDepthVerified(extractDepthVerificationMilestoneId(question.id) ?? milestoneId);
+                    markDepthVerified(inferredMilestoneId);
+                    clearPendingGate();
                 }
                 break;
             }
         }
+        if (!milestoneId && !queueActive)
+            return;
         if (!milestoneId)
             return;
         const basePath = process.cwd();

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -6,6 +6,7 @@ import { debugTime } from "../debug-logger.js";
 import { loadPrompt, getTemplatesDir } from "../prompt-loader.js";
 import { readForensicsMarker } from "../forensics.js";
 import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffectiveGSDPreferences } from "../preferences.js";
+import { resolveModelWithFallbacksForUnit } from "../preferences-models.js";
 import { resolveSkillReference } from "../preferences-skills.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
 import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
@@ -147,7 +148,11 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     // Re-inject forensics context on follow-up turns (#2941)
     const forensicsInjection = !injection ? buildForensicsContextInjection(process.cwd(), event.prompt) : null;
     const worktreeBlock = buildWorktreeContextBlock();
-    const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}`;
+    const subagentModelConfig = resolveModelWithFallbacksForUnit("subagent");
+    const subagentModelBlock = subagentModelConfig
+        ? `\n\n## Subagent Model\n\nWhen spawning subagents via the \`subagent\` tool, always pass \`model: "${subagentModelConfig.primary}"\` in the tool call parameters. Never omit this — always specify it explicitly.`
+        : "";
+    const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}${subagentModelBlock}`;
     stopContextTimer({
         systemPromptSize: fullSystem.length,
         injectionSize: injection?.length ?? forensicsInjection?.length ?? 0,

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -61,6 +61,9 @@ export function parseDoctorArgs(args) {
     const requestedScope = mode === "doctor" ? parts[0] : parts[1];
     return { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope };
 }
+export function isDoctorHealActionable(issue) {
+    return issue.fixable && issue.severity !== "info";
+}
 export async function handleDoctor(args, ctx, pi) {
     const { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope } = parseDoctorArgs(args);
     const scope = await selectDoctorScope(projectRoot(), requestedScope);
@@ -88,7 +91,7 @@ export async function handleDoctor(args, ctx, pi) {
             scope: effectiveScope,
             includeWarnings: true,
         });
-        const actionable = unresolved.filter(issue => issue.severity === "error");
+        const actionable = unresolved.filter(isDoctorHealActionable);
         if (actionable.length === 0) {
             ctx.ui.notify("Doctor heal found nothing actionable to hand off to the LLM.", "info");
             return;

package/dist/resources/extensions/gsd/context-injector.js

@@ -14,7 +14,7 @@
  */
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, sep } from "node:path";
-import { readFrozenDefinition } from "./custom-workflow-engine.js";
+import { readFrozenDefinition } from "./definition-io.js";
 /** Maximum characters per artifact to prevent context window blowout. */
 const MAX_CONTEXT_CHARS = 10_000;
 /**

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -14,6 +14,7 @@ import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { effectiveLockFile } from "./session-lock.js";
+import { emitJournalEvent, queryJournal } from "./journal.js";
 function lockPath(basePath) {
     return join(gsdRoot(basePath), effectiveLockFile());
 }
@@ -110,3 +111,53 @@ export function formatCrashInfo(lock) {
     }
     return lines.join("\n");
 }
+/**
+ * Emit a synthetic unit-end event for a unit that crashed without emitting its own.
+ *
+ * Queries the journal to find the most recent unit-start for the crashed unit.
+ * If a matching unit-end already exists (e.g. the hard timeout fired), this is a
+ * no-op. Called during crash recovery, before clearing the stale lock.
+ *
+ * Addresses the gap reported in #3348 where `unit-start` was emitted but no
+ * `unit-end` followed — side effects landed but the worker died before closeout.
+ */
+export function emitCrashRecoveredUnitEnd(basePath, lock) {
+    // Skip bootstrap / starting pseudo-units — they have no meaningful unit-start event.
+    if (!lock.unitType || !lock.unitId || lock.unitType === "starting")
+        return;
+    try {
+        const all = queryJournal(basePath);
+        // Find the most recent unit-start for this unitId
+        const starts = all.filter((e) => e.eventType === "unit-start" && e.data?.unitId === lock.unitId);
+        if (starts.length === 0)
+            return;
+        const lastStart = starts[starts.length - 1];
+        // Check if a unit-end was already emitted (e.g. hard timeout fired after the crash)
+        const alreadyClosed = all.some((e) => e.eventType === "unit-end" &&
+            e.data?.unitId === lock.unitId &&
+            e.causedBy?.flowId === lastStart.flowId &&
+            e.causedBy?.seq === lastStart.seq);
+        if (alreadyClosed)
+            return;
+        // Find the highest seq in this flow for monotonic ordering
+        const maxSeq = all
+            .filter((e) => e.flowId === lastStart.flowId)
+            .reduce((max, e) => Math.max(max, e.seq), lastStart.seq);
+        emitJournalEvent(basePath, {
+            ts: new Date().toISOString(),
+            flowId: lastStart.flowId,
+            seq: maxSeq + 1,
+            eventType: "unit-end",
+            data: {
+                unitType: lock.unitType,
+                unitId: lock.unitId,
+                status: "crash-recovered",
+                artifactVerified: false,
+            },
+            causedBy: { flowId: lastStart.flowId, seq: lastStart.seq },
+        });
+    }
+    catch {
+        // Never throw from crash recovery path — journal failure must not block recovery
+    }
+}

package/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -13,17 +13,13 @@
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { parse } from "yaml";
 import { readGraph, writeGraph, getNextPendingStep, markStepComplete, expandIteration, } from "./graph.js";
 import { injectContext } from "./context-injector.js";
+import { readFrozenDefinition } from "./definition-io.js";
 import { parseUnitId } from "./unit-id.js";
 import { withFileLock } from "./file-lock.js";
-/** Read and parse the frozen DEFINITION.yaml from a run directory. */
-export function readFrozenDefinition(runDir) {
-    const defPath = join(runDir, "DEFINITION.yaml");
-    const raw = readFileSync(defPath, "utf-8");
-    return parse(raw, { schema: "core" });
-}
+// Re-export for downstream consumers
+export { readFrozenDefinition } from "./definition-io.js";
 export class CustomWorkflowEngine {
     engineId = "custom";
     runDir;

package/dist/resources/extensions/gsd/definition-io.js

@@ -0,0 +1,15 @@
+/**
+ * definition-io.ts — Read frozen DEFINITION.yaml from a run directory.
+ *
+ * Extracted from custom-workflow-engine.ts to break the circular dependency
+ * between context-injector.ts and custom-workflow-engine.ts.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "yaml";
+/** Read and parse the frozen DEFINITION.yaml from a run directory. */
+export function readFrozenDefinition(runDir) {
+    const defPath = join(runDir, "DEFINITION.yaml");
+    const raw = readFileSync(defPath, "utf-8");
+    return parse(raw, { schema: "core" });
+}

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

@@ -102,6 +102,10 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
             }
         }
         else {
+            const milestoneUsesExplicitDeps = slices.some((slice) => slice.depends.length > 0);
+            if (milestoneUsesExplicitDeps) {
+                return null;
+            }
             // Positional fallback is only a heuristic for legacy slices with no
             // declared dependencies. Skip any earlier slice that depends on the
             // target, directly or transitively, or we can deadlock a valid zero-dep

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

@@ -277,13 +277,16 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
         if (existsSync(gitignorePath) && nativeIsRepo(basePath)) {
             const content = readFileSync(gitignorePath, "utf-8");
             const existingLines = new Set(content.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#")));
-            // Check for critical runtime patterns that must be present
+            // Check for critical runtime patterns that must be present.
+            // NOTE: GSD_RUNTIME_PATTERNS in gitignore.ts is the canonical source of truth.
+            // This is a minimal subset for the doctor check.
             const criticalPatterns = [
                 ".gsd/activity/",
                 ".gsd/runtime/",
                 ".gsd/auto.lock",
-                ".gsd/gsd.db",
-                ".gsd/completed-units.json",
+                ".gsd/gsd.db*",
+                ".gsd/completed-units*.json",
+                ".gsd/event-log.jsonl",
             ];
             // If blanket .gsd/ or .gsd is present, all patterns are covered
             const hasBlanketIgnore = existingLines.has(".gsd/") || existingLines.has(".gsd");

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

@@ -78,22 +78,25 @@ export class MergeConflictError extends GSDError {
 /**
  * GSD runtime paths that should be excluded from smart staging.
  * These are transient/generated artifacts that should never be committed.
- * Matches the union of SKIP_PATHS + SKIP_EXACT in worktree-manager.ts
- * and the first 7 entries in gitignore.ts BASELINE_PATTERNS.
+ *
+ * NOTE: GSD_RUNTIME_PATTERNS in gitignore.ts is the canonical source of truth.
+ * This array must stay synchronized with it.
  */
 export const RUNTIME_EXCLUSION_PATHS = [
     ".gsd/activity/",
+    ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",
+    ".gsd/parallel/",
     ".gsd/auto.lock",
     ".gsd/metrics.json",
-    ".gsd/completed-units.json",
+    ".gsd/completed-units*.json", // covers completed-units.json and archived completed-units-{MID}.json
+    ".gsd/state-manifest.json",
     ".gsd/STATE.md",
-    ".gsd/gsd.db",
-    ".gsd/gsd.db-shm", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/gsd.db-wal", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/journal/", // daily-rotated JSONL event journal (#2296)
-    ".gsd/doctor-history.jsonl", // doctor run history (#2296)
+    ".gsd/gsd.db*",
+    ".gsd/journal/",
+    ".gsd/doctor-history.jsonl",
+    ".gsd/event-log.jsonl",
     ".gsd/DISCUSSION-MANIFEST.json",
 ];
 // ─── Integration Branch Metadata ───────────────────────────────────────────

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

@@ -13,6 +13,12 @@ import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 /**
  * GSD runtime patterns for git index cleanup.
+ *
+ * CANONICAL SOURCE OF TRUTH: This array is the authoritative list of runtime
+ * ignore patterns. Other modules (RUNTIME_EXCLUSION_PATHS in git-service.ts,
+ * SKIP_* arrays in worktree-manager.ts, criticalPatterns in doctor-runtime-checks.ts)
+ * must stay synchronized with this list.
+ *
  * With external state (symlink), these are a no-op in most cases,
  * but retained for backwards compatibility during migration.
  */
@@ -24,13 +30,13 @@ const GSD_RUNTIME_PATTERNS = [
     ".gsd/parallel/",
     ".gsd/auto.lock",
     ".gsd/metrics.json",
-    ".gsd/completed-units.json",
+    ".gsd/completed-units*.json", // covers completed-units.json and archived completed-units-{MID}.json
+    ".gsd/state-manifest.json",
     ".gsd/STATE.md",
-    ".gsd/gsd.db",
-    ".gsd/gsd.db-shm", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/gsd.db-wal", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/journal/", // daily-rotated JSONL event journal (#2296)
-    ".gsd/doctor-history.jsonl", // doctor run history (#2296)
+    ".gsd/gsd.db*",
+    ".gsd/journal/",
+    ".gsd/doctor-history.jsonl",
+    ".gsd/event-log.jsonl",
     ".gsd/DISCUSSION-MANIFEST.json",
     ".gsd/milestones/**/*-CONTINUE.md",
     ".gsd/milestones/**/continue.md",