gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

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

@@ -210,16 +210,62 @@ export async function nextDecisionId() {
         return 'D001';
     }
 }
-/** Synchronous variant for use inside db.transaction(). */
-function nextDecisionIdSync(adapter) {
+/**
+ * ADR-013 Stage 3: compute the next `D###` identifier across both the legacy
+ * `decisions` table AND the `memories.structured_fields.sourceDecisionId`
+ * surface. Returns the max numeric suffix from either side + 1, three-digit
+ * padded.
+ *
+ * Used by `saveDecisionToDb` once writes to the `decisions` table stop —
+ * new decisions live only in memories, but historical IDs sit in both
+ * places during the cutover bake. The cross-surface max keeps IDs
+ * monotonic and avoids collisions on the next save.
+ */
+function nextDecisionIdAcrossSurfaces(adapter) {
     if (!adapter)
         return 'D001';
-    const row = adapter
-        .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM decisions')
-        .get();
-    const maxNum = row ? row['max_num'] : null;
-    if (maxNum == null || isNaN(maxNum))
-        return 'D001';
+    let maxNum = 0;
+    // Legacy table — best-effort.
+    try {
+        const row = adapter
+            .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM decisions')
+            .get();
+        const candidate = row ? row['max_num'] : null;
+        if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+            maxNum = Math.max(maxNum, candidate);
+        }
+    }
+    catch {
+        // fall through to memory-only
+    }
+    // Memory surface: scan structuredFields.sourceDecisionId for D### values.
+    // SQLite LIKE on the JSON-stringified field is sufficient — rows tagged
+    // with sourceDecisionId are bounded by the decisions count.
+    try {
+        const rows = adapter
+            .prepare("SELECT structured_fields FROM memories WHERE structured_fields LIKE '%\"sourceDecisionId\":\"D%'")
+            .all();
+        for (const row of rows) {
+            if (!row.structured_fields)
+                continue;
+            let sf;
+            try {
+                sf = JSON.parse(row.structured_fields);
+            }
+            catch {
+                continue;
+            }
+            const sourceId = sf['sourceDecisionId'];
+            if (typeof sourceId !== 'string' || !sourceId.startsWith('D'))
+                continue;
+            const num = parseInt(sourceId.slice(1), 10);
+            if (Number.isFinite(num) && num > maxNum)
+                maxNum = num;
+        }
+    }
+    catch {
+        // best-effort
+    }
     const next = maxNum + 1;
     return `D${String(next).padStart(3, '0')}`;
 }
@@ -376,38 +422,55 @@ export async function saveDecisionToDb(fields, basePath) {
     try {
         const db = await import('./gsd-db.js');
         const adapter = db._getAdapter();
-        const id = db.transaction(() => {
-            const nextId = nextDecisionIdSync(adapter);
-            db.upsertDecision({
-                id: nextId,
-                when_context: fields.when_context ?? '',
-                scope: fields.scope,
-                decision: fields.decision,
-                choice: fields.choice,
-                rationale: fields.rationale,
-                revisable: fields.revisable ?? 'Yes',
-                made_by: fields.made_by ?? 'agent',
-                source: fields.source ?? 'discussion',
-                superseded_by: null,
+        const normalized = {
+            ...fields,
+            when_context: fields.when_context ?? '',
+            revisable: fields.revisable ?? 'Yes',
+            made_by: fields.made_by ?? 'agent',
+            source: fields.source ?? 'discussion',
+        };
+        // ADR-013 Stage 3 (destructive): writes to the `decisions` table stop
+        // here. New decisions live only in the `memories` table; the projection
+        // regen below sources from memories (Stage 2a). The decisions table
+        // remains for backwards-compat reads (queryDecisions, md-importer,
+        // commands-inspect, workflow-manifest) until #5756 drops it.
+        //
+        // Reversal: a code revert of this change restores the upsertDecision
+        // call. Memory rows written between merge and revert stay durable; the
+        // legacy table simply doesn't grow during the cutover window.
+        const id = nextDecisionIdAcrossSurfaces(adapter);
+        // The mirror-to-memories write is what persists the new decision. Must
+        // run before the projection regen — the regen sources from memories
+        // (Stage 2a) and would otherwise miss the just-saved decision. Pass
+        // the normalized field set so defaults (revisable, made_by, source)
+        // are recorded on the memory row.
+        await mirrorDecisionToMemory(id, normalized);
+        // Fetch all decisions (including superseded for the full register).
+        // ADR-013 Stage 2a: source from the `memories` table. The Phase 5
+        // dual-write keeps memories in sync with each decision save; the backfill
+        // (memory-backfill.ts) absorbs the historical chain and drift-heals
+        // superseded_by on every session start.
+        const { getAllDecisionsFromMemories } = await import('./context-store.js');
+        let allDecisions = getAllDecisionsFromMemories();
+        if (!allDecisions.some(d => d.id === id)) {
+            logWarning('projection', 'just-saved decision missing from memories after mirror; injecting fallback for projection', {
+                fn: 'saveDecisionToDb',
+                decisionId: id,
             });
-            return nextId;
-        });
-        // Fetch all decisions (including superseded for the full register)
-        let allDecisions = [];
-        if (adapter) {
-            const rows = adapter.prepare('SELECT * FROM decisions ORDER BY seq').all();
-            allDecisions = rows.map(row => ({
-                seq: row['seq'],
-                id: row['id'],
-                when_context: row['when_context'],
-                scope: row['scope'],
-                decision: row['decision'],
-                choice: row['choice'],
-                rationale: row['rationale'],
-                revisable: row['revisable'],
-                made_by: row['made_by'] ?? 'agent',
-                superseded_by: row['superseded_by'] ?? null,
-            }));
+            const nextSeq = allDecisions.reduce((max, d) => Math.max(max, d.seq ?? 0), 0) + 1;
+            const fallback = {
+                seq: nextSeq,
+                id,
+                when_context: normalized.when_context,
+                scope: normalized.scope,
+                decision: normalized.decision,
+                choice: normalized.choice,
+                rationale: normalized.rationale,
+                revisable: normalized.revisable,
+                made_by: normalized.made_by,
+                superseded_by: null,
+            };
+            allDecisions = [...allDecisions, fallback];
         }
         const filePath = resolveGsdRootFile(basePath, 'DECISIONS');
         // Check if existing DECISIONS.md has freeform (non-table) content.
@@ -460,51 +523,6 @@ export async function saveDecisionToDb(fields, basePath) {
         invalidateStateCache();
         clearPathCache();
         clearParseCache();
-        // ADR-013 dual-write: keep the memory store in sync with every decision
-        // persisted via the legacy gsd_save_decision path. Without this, prompts
-        // that still call gsd_save_decision (discuss.md, plan-milestone.md,
-        // plan-slice.md, et al.) would create decisions rows invisible to
-        // memory_query and loadMemoryBlock.
-        // Best-effort — never throw, never roll back the decision on failure.
-        try {
-            const { createMemory } = await import('./memory-store.js');
-            const decisionText = (fields.decision ?? '').trim();
-            const choiceText = (fields.choice ?? '').trim();
-            const rationaleText = (fields.rationale ?? '').trim();
-            const contentParts = [];
-            if (decisionText)
-                contentParts.push(decisionText);
-            if (choiceText)
-                contentParts.push(`Chose: ${choiceText}.`);
-            if (rationaleText)
-                contentParts.push(`Rationale: ${rationaleText}.`);
-            const content = contentParts.join(' ').slice(0, 600);
-            if (content) {
-                createMemory({
-                    category: 'architecture',
-                    content,
-                    scope: fields.scope || 'project',
-                    confidence: 0.85,
-                    structuredFields: {
-                        sourceDecisionId: id,
-                        when_context: fields.when_context ?? '',
-                        scope: fields.scope,
-                        decision: fields.decision,
-                        choice: fields.choice,
-                        rationale: fields.rationale,
-                        made_by: fields.made_by ?? 'agent',
-                        revisable: fields.revisable ?? '',
-                    },
-                });
-            }
-        }
-        catch (mirrorErr) {
-            logError('manifest', 'memory-store mirror write failed (non-fatal)', {
-                fn: 'saveDecisionToDb',
-                decisionId: id,
-                error: String(mirrorErr.message),
-            });
-        }
         return { id };
     }
     catch (err) {
@@ -515,6 +533,54 @@ export async function saveDecisionToDb(fields, basePath) {
         release();
     }
 }
+/**
+ * ADR-013 dual-write — mirror a freshly-saved decision into the `memories`
+ * table so the memory store remains the single source of truth for the
+ * DECISIONS.md projection (Stage 2a) and for prompt-inline reads (Stage 1).
+ *
+ * Best-effort mirror: logs failures without throwing to avoid blocking saves.
+ * Caller invokes this AFTER the decisions-table write completes and
+ * BEFORE the projection regen — the regen sources from memories and would
+ * otherwise miss the just-saved decision.
+ */
+async function mirrorDecisionToMemory(id, normalizedFields) {
+    try {
+        const { createMemory } = await import('./memory-store.js');
+        const { synthesizeDecisionMemoryContent } = await import('./memory-backfill.js');
+        const content = synthesizeDecisionMemoryContent(normalizedFields);
+        if (!content)
+            return false;
+        createMemory({
+            category: 'architecture',
+            content,
+            scope: normalizedFields.scope || 'project',
+            confidence: 0.85,
+            structuredFields: {
+                sourceDecisionId: id,
+                when_context: normalizedFields.when_context,
+                scope: normalizedFields.scope,
+                decision: normalizedFields.decision,
+                choice: normalizedFields.choice,
+                rationale: normalizedFields.rationale,
+                made_by: normalizedFields.made_by,
+                revisable: normalizedFields.revisable,
+                // New decisions are always written as active; md-importer can later
+                // set superseded_by on the source decision row, and the backfill's
+                // drift auto-heal pass propagates that update to this memory.
+                superseded_by: null,
+            },
+        });
+        return true;
+    }
+    catch (mirrorErr) {
+        logError('manifest', 'memory-store mirror write failed', {
+            fn: 'saveDecisionToDb',
+            decisionId: id,
+            error: String(mirrorErr.message),
+        });
+        return false;
+    }
+}
 /**
  * Extract a milestone/slice reference from a deferral decision.
  *

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

@@ -4,7 +4,7 @@ import { findMilestoneIds } from "./guided-flow.js";
 import { parseUnitId } from "./unit-id.js";
 import { isDbAvailable, getMilestoneSlices, getMilestone } from "./gsd-db.js";
 import { parseRoadmap } from "./parsers-legacy.js";
-import { isClosedStatus } from "./status-guards.js";
+import { isClosedStatus, isSkippedForDispatch } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { readFileSync } from "node:fs";
 const SLICE_DISPATCH_TYPES = new Set([
@@ -14,6 +14,50 @@ const SLICE_DISPATCH_TYPES = new Set([
     "execute-task",
     "complete-slice",
 ]);
+const CONSECUTIVE_SAME_UNIT_CAP_TYPES = new Set([
+    "complete-milestone",
+    "validate-milestone",
+    "research-slice",
+]);
+const CONSECUTIVE_SAME_UNIT_CAP = 2;
+/**
+ * Prevent repeated dispatches of the same unit within the same phase.
+ *
+ * Applies only to unit types in `CONSECUTIVE_SAME_UNIT_CAP_TYPES`. The first
+ * dispatch for a unit/phase pair starts a counter, unit or phase changes reset
+ * tracking, and dispatch is blocked once the counter reaches
+ * `CONSECUTIVE_SAME_UNIT_CAP`.
+ *
+ * Side effects: mutates `state.consecutiveDispatchCount`,
+ * `state.lastDispatchedKey`, and `state.lastDispatchPhase`.
+ *
+ * Returns `null` when dispatch is allowed, or a blocker message (including
+ * guidance to run `/gsd resume`) when the cap is reached.
+ */
+export function getConsecutiveDispatchBlocker(state, phase, unitType, unitId) {
+    if (!CONSECUTIVE_SAME_UNIT_CAP_TYPES.has(unitType))
+        return null;
+    if (!state.consecutiveDispatchCount)
+        state.consecutiveDispatchCount = new Map();
+    const key = `${unitType}:${unitId}`;
+    const phaseChanged = state.lastDispatchPhase !== phase;
+    const switchedUnit = state.lastDispatchedKey !== key;
+    if (phaseChanged || switchedUnit) {
+        state.consecutiveDispatchCount.clear();
+        state.consecutiveDispatchCount.set(key, 1);
+        state.lastDispatchedKey = key;
+        state.lastDispatchPhase = phase;
+        return null;
+    }
+    const count = state.consecutiveDispatchCount.get(key) ?? 0;
+    if (count >= CONSECUTIVE_SAME_UNIT_CAP) {
+        return `Cannot dispatch ${unitType} ${unitId}: dispatched ${count} consecutive times; same-unit repeat cap reached. Resolve via /gsd resume.`;
+    }
+    state.consecutiveDispatchCount.set(key, count + 1);
+    state.lastDispatchedKey = key;
+    state.lastDispatchPhase = phase;
+    return null;
+}
 export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unitId) {
     if (!SLICE_DISPATCH_TYPES.has(unitType))
         return null;
@@ -49,7 +93,7 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
         //      DB-backed projects must not treat SUMMARY.md as authoritative.
         if (isDbAvailable()) {
             const milestoneRow = getMilestone(mid);
-            if (milestoneRow && isClosedStatus(milestoneRow.status))
+            if (milestoneRow && isSkippedForDispatch(milestoneRow.status))
                 continue;
         }
         else {

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -100,7 +100,7 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `skill_rules`: situational rules with a human-readable `when` trigger and one or more of `use`, `prefer`, or `avoid`.
 
-- `custom_instructions`: extra durable instructions related to skill use. For operational project knowledge (recurring rules, gotchas, patterns), use `.gsd/KNOWLEDGE.md` instead — it's injected into every agent prompt automatically and agents can append to it during execution.
+- `custom_instructions`: extra durable instructions related to skill use. For operational project knowledge, use `.gsd/KNOWLEDGE.md` instead. Rules are file-canonical; patterns and lessons are persisted to the `memories` table and projected back into `KNOWLEDGE.md` on the next session start.
 
 - `language`: preferred response language for all GSD interactions. Accepts any language name or code — `"Chinese"`, `"zh"`, `"German"`, `"de"`, `"日本語"`, etc. When set, GSD injects "Always respond in \<language\>" into every agent's system prompt, including after `/clear`. Quickest way to set it: `/gsd language <name>`. To clear: `/gsd language off`.
 
@@ -147,6 +147,14 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `unique_milestone_ids`: boolean — when `true`, generates milestone IDs in `M{seq}-{rand6}` format (e.g. `M001-eh88as`) instead of plain sequential `M001`. Prevents ID collisions in team workflows where multiple contributors create milestones concurrently. Both formats coexist — existing `M001`-style milestones remain valid. Default: `false`.
 
+- `workspace`: optional parent-workspace repository registry. Keys:
+  - `mode`: `"project"` or `"parent"` — registry mode for repository lookup. Default: `"project"`.
+  - `repositories`: object keyed by repository id. A default `"project"` repository pointing at the project root is always available, even when not listed here (and can be overridden by explicitly defining `"project"`). Each repository supports:
+    - `path`: string — repository root path relative to project root.
+    - `role`: string — optional human label for prompts/reporting.
+    - `verification`: string[] — optional default verification commands.
+    - `commit_policy`: `"auto"` or `"skip"` — optional turn-commit policy for auto-mode commit actions. Defaults to `"auto"` when omitted. `"skip"` suppresses commit execution for that target repo.
+
 - `budget_ceiling`: number — maximum dollar amount to spend on auto-mode. When reached, behavior is controlled by `budget_enforcement`. Default: no limit.
 
 - `budget_enforcement`: `"warn"`, `"pause"`, or `"halt"` — action taken when `budget_ceiling` is reached.
@@ -246,6 +254,8 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `verification_max_retries`: number — maximum number of fix-and-retry cycles for verification failures. Default: `0` (no retries).
 
+- `per_unit_cost_cap_usd`: number — per-unit retry cost ceiling in USD for verification retries. Must be a positive finite number when set; invalid values are rejected during preference validation. Default: `5.0`. During auto-verification and artifact-retry flows, auto-mode pauses when the current unit reaches this cap or when current unit cost spikes to at least `3.0x` the rolling average.
+
 - `uat_dispatch`: boolean — when `true`, enables UAT (User Acceptance Testing) dispatch mode. Default: `false`.
 
 - `post_unit_hooks`: array — hooks that fire after a unit completes. Each entry has:

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

@@ -1,3 +1,5 @@
+// GSD-2 doctor git health checks
+import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
 import { join, sep } from "node:path";
 import { loadFile } from "./files.js";
@@ -5,12 +7,13 @@ import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
-import { listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
+import { createWorktree, listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
 import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegrationBranch } from "./git-service.js";
 import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
 import { getAllWorktreeHealth } from "./worktree-health.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { listUnmergedGitPaths } from "./git-conflict-state.js";
 /**
  * Returns true if the directory contains only doctor artifacts
  * (e.g. `.gsd/doctor-history.jsonl`). These dirs are created by
@@ -48,6 +51,38 @@ function isSameOrNestedPath(candidate, container) {
     return normalizedCandidate === normalizedContainer ||
         normalizedCandidate.startsWith(`${normalizedContainer}/`);
 }
+function hasProjectContentOnDisk(dirPath) {
+    try {
+        for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+            if (entry.name === ".git" || entry.name === ".gsd")
+                continue;
+            if (entry.name === ".DS_Store")
+                continue;
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+function getSnapshotDiffCheckFailure(basePath) {
+    const failures = [];
+    for (const args of [["--cached"], []]) {
+        const result = spawnSync("git", ["diff", "--check", ...args], {
+            cwd: basePath,
+            encoding: "utf-8",
+        });
+        if (result.status === 0)
+            continue;
+        const output = [result.stdout, result.stderr, result.error?.message]
+            .filter(Boolean)
+            .join("\n")
+            .trim();
+        failures.push(output || `git diff --check ${args.join(" ")} failed`);
+    }
+    return failures.length > 0 ? failures.join("\n") : null;
+}
 async function isCompletedMilestoneTerminal(basePath, milestoneId) {
     const summaryPath = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
     if (!summaryPath)
@@ -69,6 +104,18 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
         return; // Not a git repo — skip all git health checks
     }
     const gitDir = resolveGitDir(basePath);
+    const unmergedPaths = listUnmergedGitPaths(basePath);
+    if (unmergedPaths === null) {
+        issues.push({
+            severity: "error",
+            code: "corrupt_merge_state",
+            scope: "project",
+            unitId: "project",
+            message: "Failed to evaluate unresolved Git conflicts. Resolve Git/worktree state manually before resuming auto-mode.",
+            fixable: false,
+        });
+        return;
+    }
     // ── Orphaned auto-worktrees & Stale milestone branches ────────────────
     // These checks only apply in worktree/branch modes — skip in none mode
     // where no milestone worktrees or branches are created.
@@ -85,6 +132,36 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                 const isComplete = milestoneEntry
                     ? await isCompletedMilestoneTerminal(basePath, milestoneId)
                     : false;
+                if (!isComplete && !hasProjectContentOnDisk(wt.path) && hasProjectContentOnDisk(basePath)) {
+                    issues.push({
+                        severity: "error",
+                        code: "worktree_empty_with_project_content",
+                        scope: "milestone",
+                        unitId: milestoneId,
+                        message: `Worktree ${wt.path} has no project content, but project root ${basePath} does. Run doctor --fix to recreate the worktree.`,
+                        fixable: true,
+                    });
+                    if (shouldFix("worktree_empty_with_project_content")) {
+                        try {
+                            nativeWorktreeRemove(basePath, wt.path, true);
+                            const recreated = createWorktree(basePath, milestoneId, {
+                                branch: wt.branch,
+                                reuseExistingBranch: true,
+                            });
+                            const reset = spawnSync("git", ["reset", "--hard"], {
+                                cwd: recreated.path,
+                                encoding: "utf-8",
+                            });
+                            if (reset.status !== 0) {
+                                throw new Error(reset.stderr || reset.error?.message || "git reset --hard failed");
+                            }
+                            fixesApplied.push(`recreated empty worktree ${wt.path}`);
+                        }
+                        catch {
+                            fixesApplied.push(`failed to recreate empty worktree ${wt.path}`);
+                        }
+                    }
+                }
                 if (isComplete) {
                     issues.push({
                         severity: "warning",
@@ -184,6 +261,16 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
             if (existsSync(join(gitDir, d)))
                 found.push(d);
         }
+        if (unmergedPaths.length > 0) {
+            issues.push({
+                severity: "error",
+                code: "unresolved_git_conflicts",
+                scope: "project",
+                unitId: "project",
+                message: `Unresolved Git conflicts detected: ${unmergedPaths.join(", ")}. Resolve these files manually before auto-mode can proceed.`,
+                fixable: false,
+            });
+        }
         if (found.length > 0) {
             issues.push({
                 severity: "error",
@@ -191,12 +278,15 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                 scope: "project",
                 unitId: "project",
                 message: `Corrupt merge/rebase state detected: ${found.join(", ")}`,
-                fixable: true,
+                fixable: unmergedPaths.length === 0,
             });
-            if (shouldFix("corrupt_merge_state")) {
+            if (shouldFix("corrupt_merge_state") && unmergedPaths.length === 0) {
                 const result = abortAndReset(basePath);
                 fixesApplied.push(`cleaned merge state: ${result.cleaned.join(", ")}`);
             }
+            else if (shouldFix("corrupt_merge_state")) {
+                fixesApplied.push("skipped merge-state reset because unresolved conflicts require manual resolution");
+            }
         }
     }
     catch {
@@ -401,16 +491,32 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                         message: `Uncommitted changes detected with no commit in ${mins} minute${mins === 1 ? "" : "s"} (threshold: ${thresholdMinutes}m). Snapshotting tracked files.`,
                         fixable: true,
                     });
+                    const diffCheckFailure = getSnapshotDiffCheckFailure(basePath);
+                    if (diffCheckFailure) {
+                        issues.push({
+                            severity: "error",
+                            code: "conflict_markers_in_tracked_files",
+                            scope: "project",
+                            unitId: "project",
+                            message: `Cannot create gsd snapshot: tracked changes contain conflict markers or whitespace errors. Resolve conflicts manually before auto-mode can proceed.\n${diffCheckFailure}`,
+                            fixable: false,
+                        });
+                    }
                     if (shouldFix("stale_uncommitted_changes")) {
                         try {
-                            nativeAddTracked(basePath);
-                            const commitMsg = `gsd snapshot: uncommitted changes after ${mins}m inactivity`;
-                            const result = nativeCommit(basePath, commitMsg);
-                            if (result) {
-                                fixesApplied.push(`created gsd snapshot after ${mins}m of uncommitted changes`);
+                            if (diffCheckFailure) {
+                                fixesApplied.push("gsd snapshot skipped - conflict markers detected in tracked files");
                             }
                             else {
-                                fixesApplied.push("gsd snapshot skipped — nothing to commit after staging tracked files");
+                                nativeAddTracked(basePath);
+                                const commitMsg = `gsd snapshot: uncommitted changes after ${mins}m inactivity`;
+                                const result = nativeCommit(basePath, commitMsg);
+                                if (result) {
+                                    fixesApplied.push(`created gsd snapshot after ${mins}m of uncommitted changes`);
+                                }
+                                else {
+                                    fixesApplied.push("gsd snapshot skipped — nothing to commit after staging tracked files");
+                                }
                             }
                         }
                         catch {

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

@@ -25,6 +25,7 @@ import { nativeIsRepo, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrent
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
+import { listUnmergedGitPaths } from "./git-conflict-state.js";
 /** In-memory health history for the current auto-mode session. */
 let healthHistory = [];
 /** Count of consecutive units with unresolved errors. */
@@ -156,6 +157,14 @@ export function resetHealthTracking() {
 export async function preDispatchHealthGate(basePath) {
     const issues = [];
     const fixesApplied = [];
+    const unmergedPaths = nativeIsRepo(basePath) ? listUnmergedGitPaths(basePath) : [];
+    if (unmergedPaths === null) {
+        issues.push("Failed to evaluate unresolved Git conflicts. Resolve Git/worktree state manually before resuming auto-mode.");
+        return { proceed: false, reason: issues[0], issues, fixesApplied };
+    }
+    if (unmergedPaths.length > 0) {
+        issues.push(`Unresolved Git conflicts: ${unmergedPaths.join(", ")}. Resolve these files manually before resuming auto-mode.`);
+    }
     // ── Stale crash lock blocks dispatch ──
     // If a stale lock exists, the crash recovery path should handle it,
     // not a new dispatch. This prevents double-dispatch after crashes.
@@ -179,7 +188,10 @@ export async function preDispatchHealthGate(basePath) {
         const gitDir = join(basePath, ".git");
         if (existsSync(gitDir)) {
             const blockers = ["MERGE_HEAD", "rebase-apply", "rebase-merge"].filter(f => existsSync(join(gitDir, f)));
-            if (blockers.length > 0) {
+            if (blockers.length > 0 && unmergedPaths.length > 0) {
+                issues.push(`Corrupt git state: ${blockers.join(", ")} with unresolved conflicts. Resolve conflicts manually before running /gsd doctor fix.`);
+            }
+            else if (blockers.length > 0) {
                 // Try to auto-heal
                 try {
                     const result = abortAndReset(basePath);
@@ -246,7 +258,7 @@ export async function preDispatchHealthGate(basePath) {
             // snapshot commits — honour it before touching the threshold path (#4420).
             const snapshotsEnabled = prefs.git?.snapshots !== false;
             const thresholdMinutes = prefs.stale_commit_threshold_minutes ?? 30;
-            if (snapshotsEnabled && thresholdMinutes > 0 && nativeHasChanges(basePath)) {
+            if (snapshotsEnabled && thresholdMinutes > 0 && unmergedPaths.length === 0 && nativeHasChanges(basePath)) {
                 const branch = nativeGetCurrentBranch(basePath);
                 const lastEpoch = nativeLastCommitEpoch(basePath, branch || "HEAD");
                 const nowEpoch = Math.floor(Date.now() / 1000);

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

@@ -5,7 +5,7 @@ import { milestonesDir, gsdRoot, resolveGsdRootFile } from "./paths.js";
 import { deriveState, isGhostMilestone, isReusableGhostMilestone } from "./state.js";
 import { saveFile } from "./files.js";
 import { nativeIsRepo, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
-import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.js";
+import { readCrashLock, isLockProcessAlive, clearStaleWorkerLock } from "./crash-recovery.js";
 import { getActiveAutoWorkers } from "./db/auto-workers.js";
 import { normalizeRealPath } from "./paths.js";
 import { ensureGitignore, isGsdGitignored } from "./gitignore.js";
@@ -46,7 +46,7 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                     fixable: true,
                 });
                 if (shouldFix("stale_crash_lock")) {
-                    clearLock(basePath);
+                    clearStaleWorkerLock(basePath);
                     fixesApplied.push("cleared stale auto-mode worker state");
                 }
             }
@@ -70,15 +70,32 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                 // heartbeat for this project?" — readCrashLock returns null for
                 // healthy live workers (it surfaces stale ones only), so we must
                 // consult getActiveAutoWorkers directly.
-                const projectRoot = normalizeRealPath(basePath);
-                const activeWorkers = getActiveAutoWorkers().filter((w) => w.project_root_realpath === projectRoot && isLockProcessAlive({
-                    pid: w.pid,
-                    startedAt: w.started_at,
-                    unitType: "starting",
-                    unitId: "bootstrap",
-                    unitStartedAt: w.started_at,
-                }));
-                const lockHolderAlive = activeWorkers.length > 0;
+                let lockHolderAlive = false;
+                try {
+                    const projectRoot = normalizeRealPath(basePath);
+                    for (const worker of getActiveAutoWorkers()) {
+                        if (worker.project_root_realpath !== projectRoot)
+                            continue;
+                        try {
+                            if (isLockProcessAlive({
+                                pid: worker.pid,
+                                startedAt: worker.started_at,
+                                unitType: "starting",
+                                unitId: "bootstrap",
+                                unitStartedAt: worker.started_at,
+                            })) {
+                                lockHolderAlive = true;
+                                break;
+                            }
+                        }
+                        catch {
+                            // Ignore malformed worker rows or transient PID probe failures.
+                        }
+                    }
+                }
+                catch {
+                    // If worker lookup fails, continue with the stranded lock diagnosis.
+                }
                 if (!lockHolderAlive) {
                     issues.push({
                         severity: "error",