gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.8b8d129d7

package/src/resources/extensions/gsd/commands-verdict.ts

@@ -0,0 +1,202 @@
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+import { loadFile } from "./files.js";
+import { resolveMilestoneFile } from "./paths.js";
+import { deriveState } from "./state.js";
+import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
+import {
+  VALIDATION_VERDICTS,
+  extractVerdict,
+  isValidMilestoneVerdict,
+  type ValidationVerdict,
+} from "./verdict-parser.js";
+
+const USAGE =
+  'Usage: /gsd verdict <pass|needs-attention|needs-remediation> [--milestone Mxxx] [--rationale "..."]';
+
+interface ParsedArgs {
+  verdict?: ValidationVerdict;
+  milestoneId?: string;
+  rationale?: string;
+}
+
+interface ParsedValidation {
+  verdict: string | undefined;
+  remediationRound: number;
+  successCriteriaChecklist: string;
+  sliceDeliveryAudit: string;
+  crossSliceIntegration: string;
+  requirementCoverage: string;
+  verificationClasses?: string;
+  verdictRationale: string;
+  remediationPlan?: string;
+}
+
+function tokenize(raw: string): string[] {
+  const tokens: string[] = [];
+  const re = /"([^"]*)"|(\S+)/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(raw)) !== null) {
+    tokens.push(match[1] ?? match[2]);
+  }
+  return tokens;
+}
+
+function parseArgs(raw: string): ParsedArgs | { error: string } {
+  const tokens = tokenize(raw);
+  const out: ParsedArgs = {};
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === "--milestone") {
+      const next = tokens[++i];
+      if (!next) return { error: "--milestone requires a milestone ID" };
+      out.milestoneId = next;
+    } else if (t === "--rationale") {
+      const next = tokens[++i];
+      if (next == null) return { error: "--rationale requires a value" };
+      out.rationale = next;
+    } else if (!out.verdict) {
+      if (!isValidMilestoneVerdict(t)) {
+        return {
+          error: `Invalid verdict "${t}". Must be one of: ${VALIDATION_VERDICTS.join(", ")}`,
+        };
+      }
+      out.verdict = t;
+    } else {
+      return { error: `Unexpected argument: ${t}` };
+    }
+  }
+  return out;
+}
+
+function extractRemediationRound(content: string): number {
+  const fm = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fm) return 0;
+  const m = fm[1].match(/^remediation_round:\s*(\d+)/im);
+  return m ? Number.parseInt(m[1], 10) : 0;
+}
+
+function extractSection(content: string, heading: string): string | undefined {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  // Match section bodies bounded by the next "## " heading or end-of-string.
+  // Leading "\n" prefix lets a single pattern handle first-line headings too.
+  // No /m flag — we want `$` to mean end-of-string, not end-of-line.
+  const re = new RegExp(`\\n## ${escaped}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+  const m = ("\n" + content).match(re);
+  if (!m) return undefined;
+  return m[1].replace(/\s+$/, "");
+}
+
+export function parseValidationFile(content: string): ParsedValidation {
+  return {
+    verdict: extractVerdict(content),
+    remediationRound: extractRemediationRound(content),
+    successCriteriaChecklist: extractSection(content, "Success Criteria Checklist") ?? "",
+    sliceDeliveryAudit: extractSection(content, "Slice Delivery Audit") ?? "",
+    crossSliceIntegration: extractSection(content, "Cross-Slice Integration") ?? "",
+    requirementCoverage: extractSection(content, "Requirement Coverage") ?? "",
+    verificationClasses: extractSection(content, "Verification Class Compliance"),
+    verdictRationale: extractSection(content, "Verdict Rationale") ?? "",
+    remediationPlan: extractSection(content, "Remediation Plan"),
+  };
+}
+
+export async function handleVerdict(
+  rawArgs: string,
+  ctx: ExtensionCommandContext,
+  basePath: string,
+): Promise<void> {
+  if (!rawArgs.trim()) {
+    ctx.ui.notify(USAGE, "warning");
+    return;
+  }
+
+  const parsed = parseArgs(rawArgs);
+  if ("error" in parsed) {
+    ctx.ui.notify(`${parsed.error}\n${USAGE}`, "warning");
+    return;
+  }
+  if (!parsed.verdict) {
+    ctx.ui.notify(USAGE, "warning");
+    return;
+  }
+
+  let milestoneId = parsed.milestoneId;
+  if (!milestoneId) {
+    const state = await deriveState(basePath);
+    if (!state.activeMilestone) {
+      ctx.ui.notify(
+        "No active milestone — pass --milestone Mxxx to target a specific milestone.",
+        "warning",
+      );
+      return;
+    }
+    milestoneId = state.activeMilestone.id;
+  }
+
+  const validationPath = resolveMilestoneFile(basePath, milestoneId, "VALIDATION");
+  if (!validationPath) {
+    ctx.ui.notify(
+      `No VALIDATION file found for ${milestoneId}. Run gsd_validate_milestone first to produce one.`,
+      "warning",
+    );
+    return;
+  }
+  const existing = await loadFile(validationPath);
+  if (!existing) {
+    ctx.ui.notify(
+      `Could not read VALIDATION file for ${milestoneId} (${validationPath}).`,
+      "warning",
+    );
+    return;
+  }
+
+  const current = parseValidationFile(existing);
+
+  if (parsed.verdict !== "pass" && !parsed.rationale) {
+    ctx.ui.notify(
+      `--rationale is required when overriding to ${parsed.verdict}.`,
+      "warning",
+    );
+    return;
+  }
+
+  const verdictRationale =
+    parsed.rationale ?? "Manually overridden via /gsd verdict";
+
+  const result = await executeValidateMilestone(
+    {
+      milestoneId,
+      verdict: parsed.verdict,
+      remediationRound: current.remediationRound,
+      successCriteriaChecklist: current.successCriteriaChecklist,
+      sliceDeliveryAudit: current.sliceDeliveryAudit,
+      crossSliceIntegration: current.crossSliceIntegration,
+      requirementCoverage: current.requirementCoverage,
+      verificationClasses: current.verificationClasses,
+      verdictRationale,
+      remediationPlan: current.remediationPlan,
+    },
+    basePath,
+  );
+
+  if (result.isError) {
+    const msg =
+      result.content[0]?.type === "text" ? result.content[0].text : "Unknown error";
+    ctx.ui.notify(msg, "error");
+    return;
+  }
+
+  const prevVerdict = current.verdict ?? "unknown";
+  ctx.ui.notify(
+    `Milestone ${milestoneId} verdict: ${prevVerdict} -> ${parsed.verdict}`,
+    "success",
+  );
+
+  if (parsed.verdict === "needs-remediation") {
+    ctx.ui.notify(
+      "Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.",
+      "info",
+    );
+  }
+}

package/src/resources/extensions/gsd/crash-recovery.ts

@@ -30,9 +30,12 @@ import { join } from "node:path";
 import {
   findStaleWorkerForProject,
   getAllAutoWorkers,
+  markWorkerCrashed,
+  markWorkerStopping,
   type AutoWorkerRow,
 } from "./db/auto-workers.js";
-import { getLatestForUnit, type DispatchStatus } from "./db/unit-dispatches.js";
+import { forceReleaseLeasesForWorker } from "./db/milestone-leases.js";
+import { markLatestActiveForWorkerCanceled, type DispatchStatus } from "./db/unit-dispatches.js";
 import { getRuntimeKv, setRuntimeKv, deleteRuntimeKv } from "./db/runtime-kv.js";
 import { _getAdapter, isDbAvailable } from "./gsd-db.js";
 import { gsdRoot, normalizeRealPath } from "./paths.js";
@@ -56,6 +59,15 @@ function lockPath(basePath: string): string {
   return join(gsdRoot(basePath), effectiveLockFile());
 }
 
+function clearLegacyLockFile(basePath: string): void {
+  try {
+    const p = lockPath(basePath);
+    if (existsSync(p)) unlinkSync(p);
+  } catch {
+    // Best-effort.
+  }
+}
+
 function readLegacyLock(basePath: string): LockData | null {
   try {
     const p = lockPath(basePath);
@@ -204,18 +216,46 @@ export function writeLock(
  * stale session-file pointer.
  */
 export function clearLock(basePath: string): void {
+  clearLegacyLockFile(basePath);
+
+  if (!isDbAvailable()) return;
   try {
-    const p = lockPath(basePath);
-    if (existsSync(p)) unlinkSync(p);
+    const projectRoot = normalizeRealPath(basePath);
+    const staleWorker = findStaleWorkerForProject(projectRoot);
+    if (staleWorker) {
+      markWorkerCrashed(staleWorker.worker_id);
+      forceReleaseLeasesForWorker(staleWorker.worker_id);
+      deleteRuntimeKv("worker", staleWorker.worker_id, SESSION_FILE_KV_KEY);
+      return;
+    }
+    const worker = findActiveWorkerForCurrentProcess(projectRoot);
+    if (worker) deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+
+    const stale = findStaleWorkerForProject(projectRoot);
+    if (stale) {
+      markWorkerStopping(stale.worker_id);
+      deleteRuntimeKv("worker", stale.worker_id, SESSION_FILE_KV_KEY);
+    }
   } catch {
     // Best-effort.
   }
+}
+
+/**
+ * Clear a stale DB-backed worker lock after readCrashLock/findStaleWorkerForProject
+ * has identified a dead worker. Unlike clearLock(), this targets the stale
+ * worker row instead of the current process's active worker.
+ */
+export function clearStaleWorkerLock(basePath: string): void {
+  clearLegacyLockFile(basePath);
 
   if (!isDbAvailable()) return;
   try {
     const projectRoot = normalizeRealPath(basePath);
-    const worker = findActiveWorkerForCurrentProcess(projectRoot);
+    const worker = findStaleWorkerForProject(projectRoot);
     if (!worker) return;
+    markLatestActiveForWorkerCanceled(worker.worker_id, "crash-recovered");
+    markWorkerCrashed(worker.worker_id);
     deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
   } catch {
     // Best-effort.

package/src/resources/extensions/gsd/db/milestone-leases.ts

@@ -255,6 +255,32 @@ export function releaseMilestoneLease(
   });
 }
 
+/**
+ * Force-release all held leases for a worker.
+ *
+ * Used by crash recovery once PID liveness has confirmed the worker is dead.
+ * No fencing token is required because this path is cleanup-only for a
+ * non-running process.
+ */
+export function forceReleaseLeasesForWorker(workerId: string): number {
+  if (!isDbAvailable()) return 0;
+  const db = _getAdapter()!;
+  let changes = 0;
+  transaction(() => {
+    const result = db.prepare(
+      `UPDATE milestone_leases
+       SET status = 'released'
+       WHERE worker_id = :worker_id
+         AND status = 'held'`,
+    ).run({ ":worker_id": workerId });
+    changes =
+      typeof (result as { changes?: unknown }).changes === "number"
+        ? (result as { changes: number }).changes
+        : 0;
+  });
+  return changes;
+}
+
 /**
  * Read current lease row for diagnostics. Returns null if no row exists.
  */

package/src/resources/extensions/gsd/db/unit-dispatches.ts

@@ -524,17 +524,18 @@ export function getRecentUnitKeysForProjectRoot(
   if (!isDbAvailable()) return [];
   const db = _getAdapter()!;
   const rows = db.prepare(
-    `SELECT ud.unit_id
+    `SELECT ud.unit_type, ud.unit_id
      FROM unit_dispatches ud
      INNER JOIN workers w ON w.worker_id = ud.worker_id
      WHERE w.project_root_realpath = :project_root_realpath
+       AND w.status != 'crashed'
      ORDER BY ud.started_at DESC, ud.id DESC
      LIMIT :limit`,
   ).all({
     ":project_root_realpath": projectRootRealpath,
     ":limit": limit,
-  }) as Array<{ unit_id: string }>;
-  return rows.reverse().map((r) => ({ key: r.unit_id }));
+  }) as Array<{ unit_type: string; unit_id: string }>;
+  return rows.reverse().map((r) => ({ key: `${r.unit_type}/${r.unit_id}` }));
 }
 
 /**

package/src/resources/extensions/gsd/db-base-schema.ts

@@ -168,6 +168,7 @@ export function createBaseSchemaObjects(db: DbAdapter, hooks: BaseSchemaHooks):
       proof_level TEXT NOT NULL DEFAULT '',
       integration_closure TEXT NOT NULL DEFAULT '',
       observability_impact TEXT NOT NULL DEFAULT '',
+      target_repositories TEXT NOT NULL DEFAULT '[]',
       sequence INTEGER DEFAULT 0,
       replan_triggered_at TEXT DEFAULT NULL,
       is_sketch INTEGER NOT NULL DEFAULT 0,
@@ -208,6 +209,7 @@ export function createBaseSchemaObjects(db: DbAdapter, hooks: BaseSchemaHooks):
       expected_output TEXT NOT NULL DEFAULT '[]',
       observability_impact TEXT NOT NULL DEFAULT '',
       full_plan_md TEXT NOT NULL DEFAULT '',
+      target_repositories TEXT NOT NULL DEFAULT '[]',
       sequence INTEGER DEFAULT 0,
       PRIMARY KEY (milestone_id, slice_id, id),
       FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)

package/src/resources/extensions/gsd/db-migration-steps.ts

@@ -424,6 +424,11 @@ export function applyMigrationV28MemoryLastHitAt(db: DbAdapter): void {
   ensureColumn(db, "memories", "last_hit_at", "ALTER TABLE memories ADD COLUMN last_hit_at TEXT DEFAULT NULL");
 }
 
+export function applyMigrationV29RepositoryTargets(db: DbAdapter): void {
+  ensureColumn(db, "slices", "target_repositories", "ALTER TABLE slices ADD COLUMN target_repositories TEXT NOT NULL DEFAULT '[]'");
+  ensureColumn(db, "tasks", "target_repositories", "ALTER TABLE tasks ADD COLUMN target_repositories TEXT NOT NULL DEFAULT '[]'");
+}
+
 export interface MigrationV22Hooks {
   copyQualityGateRowsToRepairedTable(db: DbAdapter): void;
 }

package/src/resources/extensions/gsd/db-task-slice-rows.ts

@@ -22,6 +22,7 @@ export interface SliceRow {
   replan_triggered_at: string | null;
   is_sketch: number;
   sketch_scope: string;
+  target_repositories?: string[];
 }
 
 export interface TaskRow {
@@ -55,6 +56,7 @@ export interface TaskRow {
   escalation_awaiting_review: number;
   escalation_artifact_path: string | null;
   escalation_override_applied_at: string | null;
+  target_repositories?: string[];
 }
 
 type DbRow = Record<string, unknown>;
@@ -107,6 +109,7 @@ export function rowToSlice(row: DbRow): SliceRow {
     replan_triggered_at: (row["replan_triggered_at"] as string) ?? null,
     is_sketch: (row["is_sketch"] as number) ?? 0,
     sketch_scope: (row["sketch_scope"] as string) ?? "",
+    target_repositories: parseTaskArrayColumn(row["target_repositories"]),
   };
 }
 
@@ -142,5 +145,6 @@ export function rowToTask(row: DbRow): TaskRow {
     escalation_awaiting_review: (row["escalation_awaiting_review"] as number) ?? 0,
     escalation_artifact_path: (row["escalation_artifact_path"] as string) ?? null,
     escalation_override_applied_at: (row["escalation_override_applied_at"] as string) ?? null,
+    target_repositories: parseTaskArrayColumn(row["target_repositories"]),
   };
 }

package/src/resources/extensions/gsd/dispatch-guard.ts

@@ -5,9 +5,10 @@ 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";
+import type { LoopState } from "./auto/types.js";
 
 const SLICE_DISPATCH_TYPES = new Set([
   "research-slice",
@@ -17,6 +18,63 @@ const SLICE_DISPATCH_TYPES = new Set([
   "complete-slice",
 ]);
 
+const CONSECUTIVE_SAME_UNIT_CAP_TYPES = new Set([
+  "complete-milestone",
+  "validate-milestone",
+  "research-slice",
+]);
+const CONSECUTIVE_SAME_UNIT_CAP = 2;
+
+type ConsecutiveDispatchState = Pick<
+  LoopState,
+  "consecutiveDispatchCount" | "lastDispatchedKey" | "lastDispatchPhase"
+>;
+
+/**
+ * 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: ConsecutiveDispatchState,
+  phase: string,
+  unitType: string,
+  unitId: string,
+): string | null {
+  if (!CONSECUTIVE_SAME_UNIT_CAP_TYPES.has(unitType)) return null;
+  if (!state.consecutiveDispatchCount) state.consecutiveDispatchCount = new Map<string, number>();
+
+  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: string,
   _mainBranch: string,
@@ -58,7 +116,7 @@ export function getPriorSliceCompletionBlocker(
     //      DB-backed projects must not treat SUMMARY.md as authoritative.
     if (isDbAvailable()) {
       const milestoneRow = getMilestone(mid);
-      if (milestoneRow && isClosedStatus(milestoneRow.status)) continue;
+      if (milestoneRow && isSkippedForDispatch(milestoneRow.status)) continue;
     } else {
       const summaryPath = resolveMilestoneFile(base, mid, "SUMMARY");
       let summaryContent: string | null = null;

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

@@ -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.

package/src/resources/extensions/gsd/doctor-git-checks.ts

@@ -9,7 +9,7 @@ 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";
@@ -54,6 +54,19 @@ function isSameOrNestedPath(candidate: string, container: string): boolean {
     normalizedCandidate.startsWith(`${normalizedContainer}/`);
 }
 
+function hasProjectContentOnDisk(dirPath: string): boolean {
+  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: string): string | null {
   const failures: string[] = [];
 
@@ -123,6 +136,37 @@ export async function checkGitHealth(
         ? 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",

package/src/resources/extensions/gsd/doctor-runtime-checks.ts

@@ -7,7 +7,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";
@@ -56,7 +56,7 @@ export async function checkRuntimeHealth(
         });
 
         if (shouldFix("stale_crash_lock")) {
-          clearLock(basePath);
+          clearStaleWorkerLock(basePath);
           fixesApplied.push("cleared stale auto-mode worker state");
         }
       }
@@ -80,17 +80,29 @@ export async function checkRuntimeHealth(
         // 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",

package/src/resources/extensions/gsd/doctor-types.ts

@@ -51,6 +51,7 @@ export type DoctorIssueCode =
   // Git / worktree integrity checks
   | "integration_branch_missing"
   | "worktree_directory_orphaned"
+  | "worktree_empty_with_project_content"
   // GSD state structural checks
   | "circular_slice_dependency"
   | "orphaned_slice_directory"

package/src/resources/extensions/gsd/doctor.ts

@@ -16,6 +16,7 @@ import type { RoadmapSliceEntry } from "./types.js";
 import { checkGitHealth, checkRuntimeHealth, checkGlobalHealth, checkEngineHealth } from "./doctor-checks.js";
 import { checkEnvironmentHealth } from "./doctor-environment.js";
 import { runProviderChecks } from "./doctor-providers.js";
+import { validateTitle } from "./validation.js";
 
 // ── Re-exports ─────────────────────────────────────────────────────────────
 // All public types and functions from extracted modules are re-exported here
@@ -25,33 +26,7 @@ export { summarizeDoctorIssues, filterDoctorIssues, formatDoctorReport, formatDo
 export { runEnvironmentChecks, runFullEnvironmentChecks, formatEnvironmentReport, type EnvironmentCheckResult } from "./doctor-environment.js";
 export { computeProgressScore, computeProgressScoreWithContext, formatProgressLine, formatProgressReport, type ProgressScore, type ProgressLevel } from "./progress-score.js";
 
-/**
- * Characters that are used as delimiters in GSD state management documents
- * and should not appear in milestone or slice titles.
- *
- * - "\u2014" (em dash, U+2014): used as a display separator in STATE.md and other docs.
- *   A title containing "\u2014" makes the separator ambiguous, corrupting state display
- *   and confusing the LLM agent that reads and writes these files.
- * - "\u2013" (en dash, U+2013): visually similar to em dash; same ambiguity risk.
- * - "/" (forward slash, U+002F): used as the path separator in unit IDs (M001/S01)
- *   and git branch names (gsd/M001/S01). A slash in a title can break path resolution.
- */
-const TITLE_DELIMITER_RE = /[\u2014\u2013\/]/; // em dash, en dash, forward slash
-
-/**
- * Check whether a milestone or slice title contains characters that conflict
- * with GSD's state document delimiter conventions.
- * Returns a human-readable description of the problem, or null if the title is safe.
- */
-export function validateTitle(title: string): string | null {
-  if (TITLE_DELIMITER_RE.test(title)) {
-    const found: string[] = [];
-    if (/[\u2014\u2013]/.test(title)) found.push("em/en dash (\u2014 or \u2013)");
-    if (/\//.test(title)) found.push("forward slash (/)");
-    return `title contains ${found.join(" and ")}, which conflict with GSD state document delimiters`;
-  }
-  return null;
-}
+export { validateTitle } from "./validation.js";
 
 function validatePreferenceShape(preferences: GSDPreferences): string[] {
   const issues: string[] = [];