gsd-pi 2.63.0-dev.026d309 → 2.63.0-dev.351157b

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

@@ -402,6 +402,23 @@ export async function saveDecisionToDb(fields, basePath) {
             adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
             throw diskErr;
         }
+        // #2661: When a decision defers a slice, update the slice status in the DB
+        // so the dispatcher skips it. Without this, STATE.md and DECISIONS.md are
+        // in split-brain: the decision says "deferred" but the state still says
+        // "active", causing auto-mode to keep dispatching the deferred work.
+        try {
+            const sliceRef = extractDeferredSliceRef(fields);
+            if (sliceRef) {
+                db.updateSliceStatus(sliceRef.milestoneId, sliceRef.sliceId, 'deferred');
+            }
+        }
+        catch (deferErr) {
+            // Non-fatal — log but don't fail the decision save
+            logError('manifest', 'failed to update deferred slice status', {
+                fn: 'saveDecisionToDb',
+                error: String(deferErr.message),
+            });
+        }
         // Invalidate file-read caches so deriveState() sees the updated markdown.
         // Do NOT clear the artifacts table — we just wrote to it intentionally.
         invalidateStateCache();
@@ -414,6 +431,33 @@ export async function saveDecisionToDb(fields, basePath) {
         throw err;
     }
 }
+/**
+ * Extract a milestone/slice reference from a deferral decision.
+ *
+ * Detects deferrals by checking:
+ *   - scope contains "defer" (e.g., "deferral", "defer")
+ *   - choice or decision contains "defer" + an M###/S## pattern
+ *
+ * Returns { milestoneId, sliceId } if found, null otherwise.
+ */
+export function extractDeferredSliceRef(fields) {
+    const isDeferral = /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.scope) ||
+        /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.choice) ||
+        /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.decision);
+    if (!isDeferral)
+        return null;
+    // Look for M###/S## pattern in choice first, then decision
+    const slicePattern = /\b(M\d{3,4})\/(S\d{2,3})\b/;
+    const choiceMatch = fields.choice.match(slicePattern);
+    if (choiceMatch) {
+        return { milestoneId: choiceMatch[1], sliceId: choiceMatch[2] };
+    }
+    const decisionMatch = fields.decision.match(slicePattern);
+    if (decisionMatch) {
+        return { milestoneId: decisionMatch[1], sliceId: decisionMatch[2] };
+    }
+    return null;
+}
 // ─── Update Requirement in DB + Regenerate Markdown ───────────────────────
 /**
  * Update a requirement in DB and regenerate REQUIREMENTS.md.
@@ -422,10 +466,34 @@ export async function saveDecisionToDb(fields, basePath) {
 export async function updateRequirementInDb(id, updates, basePath) {
     try {
         const db = await import('./gsd-db.js');
-        const existing = db.getRequirementById(id);
-        // If requirement doesn't exist in DB, create a skeleton and merge updates.
-        // This handles the case where requirements were written to REQUIREMENTS.md
-        // but never imported into the database (see #2919).
+        let existing = db.getRequirementById(id);
+        // If requirement doesn't exist in DB, seed the entire requirements table
+        // from REQUIREMENTS.md first (#3346). This handles the standard workflow
+        // where requirements are authored in markdown during discussion but never
+        // imported into the database — making gsd_requirement_update always fail
+        // with "not_found" at milestone completion.
+        if (!existing) {
+            const reqFilePath = resolveGsdRootFile(basePath, 'REQUIREMENTS');
+            try {
+                const content = readFileSync(reqFilePath, 'utf-8');
+                const { parseRequirementsSections } = await import('./md-importer.js');
+                const parsed = parseRequirementsSections(content);
+                if (parsed.length > 0) {
+                    logWarning('manifest', `Seeding ${parsed.length} requirements from REQUIREMENTS.md into DB (first update triggers import)`, { fn: 'updateRequirementInDb' });
+                    for (const req of parsed) {
+                        // Only seed if not already in DB (avoid overwriting concurrent inserts)
+                        if (!db.getRequirementById(req.id)) {
+                            db.upsertRequirement(req);
+                        }
+                    }
+                    // Re-check after seeding
+                    existing = db.getRequirementById(id);
+                }
+            }
+            catch {
+                // REQUIREMENTS.md missing or unparseable — fall through to skeleton
+            }
+        }
         const base = existing ?? {
             id,
             class: '',

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

@@ -498,13 +498,29 @@ function getDbCompletionCounts() {
     };
 }
 // ─── Anomaly Detectors ───────────────────────────────────────────────────────
-function detectStuckLoops(units, anomalies) {
-    const counts = new Map();
+/**
+ * Detect units that were dispatched multiple times (stuck in a loop).
+ *
+ * Counts distinct dispatches by grouping on (type, id, startedAt) first to
+ * collapse idle-watchdog duplicate snapshots (#1943), then counts unique
+ * startedAt values per type/id to determine actual dispatch count.
+ *
+ * Exported for testability.
+ */
+export function detectStuckLoops(units, anomalies) {
+    // First, collect unique startedAt values per type/id key
+    const dispatchMap = new Map();
     for (const u of units) {
         const key = `${u.type}/${u.id}`;
-        counts.set(key, (counts.get(key) ?? 0) + 1);
+        let starts = dispatchMap.get(key);
+        if (!starts) {
+            starts = new Set();
+            dispatchMap.set(key, starts);
+        }
+        starts.add(u.startedAt);
     }
-    for (const [key, count] of counts) {
+    for (const [key, starts] of dispatchMap) {
+        const count = starts.size;
         if (count > 1) {
             const [unitType, ...idParts] = key.split("/");
             anomalies.push({

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

@@ -1023,11 +1023,12 @@ export function insertMilestone(m) {
         ":boundary_map_markdown": m.planning?.boundaryMapMarkdown ?? "",
     });
 }
-export function upsertMilestonePlanning(milestoneId, planning, title) {
+export function upsertMilestonePlanning(milestoneId, planning) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE milestones SET
-      title = COALESCE(:title, title),
+      title = COALESCE(NULLIF(:title, ''), title),
+      status = COALESCE(NULLIF(:status, ''), status),
       vision = COALESCE(:vision, vision),
       success_criteria = COALESCE(:success_criteria, success_criteria),
       key_risks = COALESCE(:key_risks, key_risks),
@@ -1041,7 +1042,8 @@ export function upsertMilestonePlanning(milestoneId, planning, title) {
       boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
      WHERE id = :id`).run({
         ":id": milestoneId,
-        ":title": title ?? null,
+        ":title": planning.title ?? "",
+        ":status": planning.status ?? "",
         ":vision": planning.vision ?? null,
         ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
         ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
@@ -1058,13 +1060,25 @@ export function upsertMilestonePlanning(milestoneId, planning, title) {
 export function insertSlice(s) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb.prepare(`INSERT OR IGNORE INTO slices (
+    currentDb.prepare(`INSERT INTO slices (
       milestone_id, id, title, status, risk, depends, demo, created_at,
       goal, success_criteria, proof_level, integration_closure, observability_impact, sequence
     ) VALUES (
       :milestone_id, :id, :title, :status, :risk, :depends, :demo, :created_at,
       :goal, :success_criteria, :proof_level, :integration_closure, :observability_impact, :sequence
-    )`).run({
+    )
+    ON CONFLICT (milestone_id, id) DO UPDATE SET
+      title = CASE WHEN :raw_title IS NOT NULL THEN excluded.title ELSE slices.title END,
+      status = CASE WHEN slices.status IN ('complete', 'done') THEN slices.status ELSE excluded.status END,
+      risk = CASE WHEN :raw_risk IS NOT NULL THEN excluded.risk ELSE slices.risk END,
+      depends = excluded.depends,
+      demo = CASE WHEN :raw_demo IS NOT NULL THEN excluded.demo ELSE slices.demo END,
+      goal = CASE WHEN :raw_goal IS NOT NULL THEN excluded.goal ELSE slices.goal END,
+      success_criteria = CASE WHEN :raw_success_criteria IS NOT NULL THEN excluded.success_criteria ELSE slices.success_criteria END,
+      proof_level = CASE WHEN :raw_proof_level IS NOT NULL THEN excluded.proof_level ELSE slices.proof_level END,
+      integration_closure = CASE WHEN :raw_integration_closure IS NOT NULL THEN excluded.integration_closure ELSE slices.integration_closure END,
+      observability_impact = CASE WHEN :raw_observability_impact IS NOT NULL THEN excluded.observability_impact ELSE slices.observability_impact END,
+      sequence = CASE WHEN :raw_sequence IS NOT NULL THEN excluded.sequence ELSE slices.sequence END`).run({
         ":milestone_id": s.milestoneId,
         ":id": s.id,
         ":title": s.title ?? "",
@@ -1079,6 +1093,16 @@ export function insertSlice(s) {
         ":integration_closure": s.planning?.integrationClosure ?? "",
         ":observability_impact": s.planning?.observabilityImpact ?? "",
         ":sequence": s.sequence ?? 0,
+        // Raw sentinel params: NULL when caller omitted the field, used in ON CONFLICT guards
+        ":raw_title": s.title ?? null,
+        ":raw_risk": s.risk ?? null,
+        ":raw_demo": s.demo ?? null,
+        ":raw_goal": s.planning?.goal ?? null,
+        ":raw_success_criteria": s.planning?.successCriteria ?? null,
+        ":raw_proof_level": s.planning?.proofLevel ?? null,
+        ":raw_integration_closure": s.planning?.integrationClosure ?? null,
+        ":raw_observability_impact": s.planning?.observabilityImpact ?? null,
+        ":raw_sequence": s.sequence ?? null,
     });
 }
 export function upsertSlicePlanning(milestoneId, sliceId, planning) {
@@ -1574,19 +1598,31 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
                  definition_of_done, requirement_coverage, boundary_map_markdown
           FROM wt.milestones
         `).run());
-                // Merge slices — preserve worktree progress (status, summaries, planning)
+                // Merge slices — preserve worktree progress but never downgrade completed status (#2558).
+                // Uses INSERT OR REPLACE with a subquery that picks the best status — if the main DB
+                // already has a completed slice, keep that status even if the worktree copy is stale.
                 merged.slices = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO slices (
             milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
             full_summary_md, full_uat_md, goal, success_criteria, proof_level,
             integration_closure, observability_impact, sequence, replan_triggered_at
           )
-          SELECT milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
-                 full_summary_md, full_uat_md, goal, success_criteria, proof_level,
-                 integration_closure, observability_impact, sequence, replan_triggered_at
-          FROM wt.slices
+          SELECT w.milestone_id, w.id, w.title,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.status ELSE w.status
+                 END,
+                 w.risk, w.depends, w.demo, w.created_at,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.completed_at ELSE w.completed_at
+                 END,
+                 w.full_summary_md, w.full_uat_md, w.goal, w.success_criteria, w.proof_level,
+                 w.integration_closure, w.observability_impact, w.sequence, w.replan_triggered_at
+          FROM wt.slices w
+          LEFT JOIN slices m ON m.milestone_id = w.milestone_id AND m.id = w.id
         `).run());
-                // Merge tasks — preserve execution results, status, summaries
+                // Merge tasks — preserve execution results, never downgrade completed status (#2558)
                 merged.tasks = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO tasks (
             milestone_id, slice_id, id, title, status, one_liner, narrative,
@@ -1595,12 +1631,23 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             description, estimate, files, verify, inputs, expected_output,
             observability_impact, full_plan_md, sequence
           )
-          SELECT milestone_id, slice_id, id, title, status, one_liner, narrative,
-                 verification_result, duration, completed_at, blocker_discovered,
-                 deviations, known_issues, key_files, key_decisions, full_summary_md,
-                 description, estimate, files, verify, inputs, expected_output,
-                 observability_impact, full_plan_md, sequence
-          FROM wt.tasks
+          SELECT w.milestone_id, w.slice_id, w.id, w.title,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.status ELSE w.status
+                 END,
+                 w.one_liner, w.narrative,
+                 w.verification_result, w.duration,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.completed_at ELSE w.completed_at
+                 END,
+                 w.blocker_discovered,
+                 w.deviations, w.known_issues, w.key_files, w.key_decisions, w.full_summary_md,
+                 w.description, w.estimate, w.files, w.verify, w.inputs, w.expected_output,
+                 w.observability_impact, w.full_plan_md, w.sequence
+          FROM wt.tasks w
+          LEFT JOIN tasks m ON m.milestone_id = w.milestone_id AND m.slice_id = w.slice_id AND m.id = w.id
         `).run());
                 // Merge memories — keep worktree-learned insights
                 merged.memories = countChanges(adapter.prepare(`

package/dist/resources/extensions/gsd/guided-flow.js

@@ -33,6 +33,7 @@ import { debugLog } from "./debug-logger.js";
 import { findMilestoneIds, nextMilestoneId, reserveMilestoneId, getReservedMilestoneIds, clearReservedMilestoneIds } from "./milestone-ids.js";
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
+import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, reserveMilestoneId, claimReservedId, getReservedMilestoneIds, clearReservedMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
@@ -242,6 +243,24 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
             });
         }
     }
+    // Scope tools for discuss flows (#2949).
+    // Providers with grammar-based constrained decoding (xAI/Grok) return
+    // "Grammar is too complex" when the combined tool schema is too large.
+    // Discuss flows only need a small subset of GSD tools — strip the heavy
+    // planning/execution/completion tools to keep the grammar within limits.
+    if (unitType?.startsWith("discuss-")) {
+        const currentTools = pi.getActiveTools();
+        // Keep all non-GSD tools (builtins, other extensions) and only the
+        // GSD tools on the discuss allowlist.
+        const scopedTools = currentTools.filter((t) => !t.startsWith("gsd_") || DISCUSS_TOOLS_ALLOWLIST.includes(t));
+        pi.setActiveTools(scopedTools);
+        debugLog("discuss-tool-scoping", {
+            unitType,
+            before: currentTools.length,
+            after: scopedTools.length,
+            removed: currentTools.length - scopedTools.length,
+        });
+    }
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({

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

@@ -412,7 +412,33 @@ export function loadLedgerFromDisk(base) {
     return loadJsonFileOrNull(metricsPath(base), isMetricsLedger);
 }
 function loadLedger(base) {
-    return loadJsonFile(metricsPath(base), isMetricsLedger, defaultLedger);
+    const raw = loadJsonFile(metricsPath(base), isMetricsLedger, defaultLedger);
+    const before = raw.units.length;
+    raw.units = deduplicateUnits(raw.units);
+    if (raw.units.length < before) {
+        // Persist the cleaned ledger so duplicates don't re-accumulate
+        saveLedger(base, raw);
+    }
+    return raw;
+}
+/**
+ * Collapse duplicate entries with the same (type, id, startedAt) triple.
+ * Keeps the entry with the highest finishedAt (the most complete snapshot).
+ *
+ * This is a defensive measure against idle-watchdog race conditions that can
+ * produce duplicate entries on disk despite the in-memory idempotency guard
+ * in snapshotUnitMetrics(). See #1943.
+ */
+function deduplicateUnits(units) {
+    const map = new Map();
+    for (const u of units) {
+        const key = `${u.type}\0${u.id}\0${u.startedAt}`;
+        const existing = map.get(key);
+        if (!existing || u.finishedAt > existing.finishedAt) {
+            map.set(key, u);
+        }
+    }
+    return Array.from(map.values());
 }
 function saveLedger(base, data) {
     saveJsonFile(metricsPath(base), data);

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -569,10 +569,12 @@ export function nativeAddAllWithExclusions(basePath, exclusions) {
             return;
         }
         // When .gsd is a symlink, git rejects `:!.gsd/...` pathspecs with
-        // "beyond a symbolic link". Fall back to plain `git add -A` which
-        // respects .gitignore (where .gsd/ is listed by default).
+        // "beyond a symbolic link". Fall back to `git add -u` which only
+        // stages changes to already-tracked files — O(tracked) not O(filesystem).
+        // Using `git add -A` here would traverse the entire working tree,
+        // hanging indefinitely on repos with large untracked data dirs. (#1977)
         if (stderr.includes("beyond a symbolic link")) {
-            nativeAddAll(basePath);
+            gitFileExec(basePath, ["add", "-u"]);
             return;
         }
         throw new GSDError(GSD_GIT_ERROR, `git add -A with exclusions failed in ${basePath}: ${getErrorMessage(err)}`);

package/dist/resources/extensions/gsd/preferences-types.js

@@ -74,6 +74,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "context_management",
     "experimental",
     "codebase",
+    "slice_parallel",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

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

@@ -148,9 +148,11 @@ export function parsePreferencesMarkdown(content) {
     if (/^##\s+\w/m.test(content)) {
         return parseHeadingListFormat(content);
     }
-    if (!_warnedUnrecognizedFormat) {
+    // Warn when a non-empty file exists but lacks frontmatter delimiters (#2036).
+    if (content.trim().length > 0 && !_warnedUnrecognizedFormat) {
         _warnedUnrecognizedFormat = true;
-        console.warn("[parsePreferencesMarkdown] preferences.md exists but uses an unrecognized format — skipping.");
+        console.warn("[GSD] Warning: preferences file has unrecognized format — content does not use YAML frontmatter delimiters (---). " +
+            "Wrap your preferences in --- fences. See https://github.com/gsd-build/gsd-2/issues/2036");
     }
     return null;
 }
@@ -301,6 +303,9 @@ function mergePreferences(base, override) {
                 ].filter(Boolean),
             }
             : undefined,
+        slice_parallel: (base.slice_parallel || override.slice_parallel)
+            ? { ...(base.slice_parallel ?? {}), ...(override.slice_parallel ?? {}) }
+            : undefined,
     };
 }
 function mergeStringLists(base, override) {

package/dist/resources/extensions/gsd/prompts/complete-milestone.md

@@ -24,6 +24,8 @@ Then:
 7. Fill the **Decision Re-evaluation** table in the milestone summary. For each key decision from `.gsd/DECISIONS.md` made during this milestone, evaluate whether it is still valid given what was actually built. Flag decisions that should be revisited next milestone.
 8. Validate **requirement status transitions**. For each requirement that changed status during this milestone, confirm the transition is supported by evidence. Requirements can move between Active, Validated, Deferred, Blocked, or Out of Scope — but only with proof.
 
+**DB access safety:** Do NOT query `.gsd/gsd.db` directly via `sqlite3` or `node -e require('better-sqlite3')` — the engine owns the WAL connection. Use `gsd_milestone_status` to read milestone and slice state. All data you need is already inlined in the context above or accessible via the `gsd_*` tools — never via direct SQL.
+
 ### Verification Gate — STOP if verification failed
 
 **If ANY verification failure was recorded in steps 3, 4, or 5, you MUST follow the failure path below. Do NOT proceed to step 9.**

package/dist/resources/extensions/gsd/prompts/complete-slice.md

@@ -35,6 +35,8 @@ Then:
 
 **Autonomous execution:** Do not call `ask_user_questions` or `secure_env_collect`. You are running in auto-mode — there is no human available to answer questions. Make reasonable assumptions and document them in the slice summary. If a decision genuinely requires human input, note it in the summary and proceed with the best available option.
 
+**File system safety:** Task summaries are preloaded in the inlined context above. If you need to re-read any of them, use `find .gsd/milestones/{{milestoneId}}/slices/{{sliceId}}/tasks -name "*-SUMMARY.md"` to list file paths first — never pass `{{slicePath}}` or any other directory path directly to the `read` tool. The `read` tool only accepts file paths, not directories.
+
 **You MUST call `gsd_complete_slice` with the slice summary and UAT content before finishing. The tool persists to both DB and disk and renders `{{sliceSummaryPath}}` and `{{sliceUatPath}}` automatically.**
 
 When done, say: "Slice {{sliceId}} complete."

package/dist/resources/extensions/gsd/prompts/doctor-heal.md

@@ -9,6 +9,7 @@ Rules:
 4. For missing summaries or UAT files, generate the real artifact from existing slice/task context when possible — do not leave placeholders if you can reconstruct the real content.
 5. After each repair cluster, verify the relevant invariant directly from disk.
 6. When done, rerun `/gsd doctor {{doctorCommandSuffix}}` mentally by ensuring the remaining issue set for this scope is reduced or cleared.
+7. Do NOT query `.gsd/gsd.db` directly via `sqlite3` or `node -e require('better-sqlite3')` — use `gsd_milestone_status` to inspect DB state. Direct access bypasses the WAL connection owned by the engine and can corrupt in-flight writes.
 
 ## Doctor Summary
 

package/dist/resources/extensions/gsd/prompts/forensics.md

@@ -116,6 +116,8 @@ A unit dispatched more than once (`type/id` appears multiple times) indicates a
 
 5. **Read the actual GSD source code** at `{{gsdSourceDir}}` to confirm or deny each hypothesis. Do not guess what code does — read it.
 
+   **DB inspection:** If you need to check DB state as part of investigation, use `gsd_milestone_status` — never run `sqlite3 .gsd/gsd.db` or `node -e require('better-sqlite3')` directly. The engine holds a WAL write lock; direct access will either fail or return stale data.
+
 6. **Trace the code path** from the entry point (usually `auto-loop.ts` dispatch or `auto-dispatch.ts`) through to the failure point. Follow function calls across files.
 
 7. **Identify the specific file and line** where the bug lives. Determine what kind of defect it is:

package/dist/resources/extensions/gsd/prompts/reassess-roadmap.md

@@ -63,4 +63,6 @@ If `.gsd/REQUIREMENTS.md` exists and requirement ownership or status changed, up
 
 {{commitInstruction}}
 
+**DB access safety:** Do NOT query `.gsd/gsd.db` directly via `sqlite3` or `node -e require('better-sqlite3')`. Use `gsd_milestone_status` to read current milestone and slice state. All roadmap mutations go through `gsd_reassess_roadmap` — the tool writes to the DB and re-renders ROADMAP.md atomically.
+
 When done, say: "Roadmap reassessed."

package/dist/resources/extensions/gsd/prompts/system.md

@@ -175,6 +175,7 @@ Templates showing the expected format for each artifact type are in:
 - Never guess at library APIs from training data — use `get_library_docs`.
 - Never ask the user to run a command, set a variable, or check something you can check yourself.
 - Never await stale async jobs after editing source — `cancel_job` them first, then re-run.
+- Never query `.gsd/gsd.db` directly via `sqlite3`, `better-sqlite3`, or `node -e require('better-sqlite3')` — the database uses a single-writer WAL connection managed by the engine. Direct access causes reader/writer conflicts and bypasses validation logic. Use `gsd_milestone_status`, `gsd_journal_query`, or other `gsd_*` tools exclusively for all DB reads and writes.
 
 ### Ask vs infer
 

package/dist/resources/extensions/gsd/prompts/validate-milestone.md

@@ -38,6 +38,8 @@ All relevant context has been preloaded below — the roadmap, all slice summari
 
 **Persist validation results through `gsd_validate_milestone`.** Call it with: `milestoneId`, `verdict`, `remediationRound`, `successCriteriaChecklist`, `sliceDeliveryAudit`, `crossSliceIntegration`, `requirementCoverage`, `verificationClasses` (when non-empty), `verdictRationale`, and `remediationPlan` (if verdict is `needs-remediation`). The tool writes the validation to the DB and renders VALIDATION.md to disk.
 
+**DB access safety:** Do NOT query `.gsd/gsd.db` directly via `sqlite3` or `node -e require('better-sqlite3')` — the engine owns the WAL connection. Use `gsd_milestone_status` to read milestone and slice state. All data you need is already inlined in the context above or accessible via the `gsd_*` tools. Direct DB access corrupts the WAL and bypasses tool-level validation.
+
 If verdict is `needs-remediation`:
 - After calling `gsd_validate_milestone`, use `gsd_reassess_roadmap` to add remediation slices. Pass `milestoneId`, a synthetic `completedSliceId` (e.g. "VALIDATION"), `verdict: "roadmap-adjusted"`, `assessment` text, and `sliceChanges` with the new slices in the `added` array. The tool persists the changes to the DB and re-renders ROADMAP.md.
 - These remediation slices will be planned and executed before validation re-runs.

package/dist/resources/extensions/gsd/roadmap-mutations.js

@@ -31,7 +31,7 @@ export function markSliceDoneInRoadmap(basePath, mid, sid) {
     if (updated === content) {
         updated = content.replace(new RegExp(`^(#{1,4}\\s+(?:\\*{0,2})(?:Slice\\s+)?${sid}\\*{0,2}[:\\s.\\u2014\\u2013-]+\\s*)(.+)`, "m"), (match, prefix, title) => {
             // Already marked done — no-op
-            if (/^\u2713/.test(title) || /\(Complete\)\s*$/i.test(title))
+            if (/^[\u2713\u2705]/.test(title) || /[\u2705]\s*$/.test(title) || /\(Complete\)\s*$/i.test(title))
                 return match;
             return `${prefix}\u2713 ${title}`;
         });

package/dist/resources/extensions/gsd/roadmap-slices.js

@@ -74,7 +74,7 @@ function parseTableSlices(section) {
         // Determine completion status from any cell containing [x], "Done", or "Complete"
         const fullRow = line.toLowerCase();
         const done = /\[x\]/i.test(line) ||
-            /[✅☑✓]/.test(line) ||
+            /[✅☑✓✔]/.test(line) ||
             /\bdone\b/.test(fullRow) ||
             /\bcomplete(?:d)?\b/.test(fullRow);
         // Extract risk from any cell containing risk keywords
@@ -214,10 +214,10 @@ function parseProseSliceHeaders(content) {
     // numeric prefixes (e.g., "1.", "(1)"), bracketed IDs (e.g., "[S01]"),
     // optional checkmark completion marker, and optional leading indentation.
     // Separator after the ID is flexible: colon, dash, em/en dash, dot, or just whitespace.
-    const headerPattern = /^\s*#{1,4}\s+\*{0,2}(?:\u2713\s+)?(?:\d+[.)]\s+)?(?:\(\d+\)\s+)?(?:Slice\s+)?\[?(S\d+)\]?\*{0,2}[:\s.\u2014\u2013-]*\s*(.+)/gm;
+    const headerPattern = /^\s*#{1,4}\s+\*{0,2}(?:[\u2713\u2705]\s+)?(?:\d+[.)]\s+)?(?:\(\d+\)\s+)?(?:Slice\s+)?\[?(S\d+)\]?\*{0,2}[:\s.\u2014\u2013-]*\s*(.+)/gm;
     let match;
     // Check for checkmark before the slice ID (e.g., "## checkmark S01: Title")
-    const prefixCheckPattern = /^\s*#{1,4}\s+\*{0,2}\u2713\s+/;
+    const prefixCheckPattern = /^\s*#{1,4}\s+\*{0,2}[\u2713\u2705]\s+/;
     while ((match = headerPattern.exec(content)) !== null) {
         const id = match[1];
         let title = match[2].trim().replace(/\*{1,2}$/g, "").trim(); // strip trailing bold markers
@@ -229,9 +229,13 @@ function parseProseSliceHeaders(content) {
         // 3. (Complete) suffix: "## S01: Title (Complete)"
         const line = match[0];
         let done = prefixCheckPattern.test(line);
-        if (!done && title.startsWith("\u2713")) {
+        if (!done && /^[\u2713\u2705]/.test(title)) {
             done = true;
-            title = title.replace(/^\u2713\s*/, "");
+            title = title.replace(/^[\u2713\u2705]\s*/, "");
+        }
+        if (!done && /[\u2705]\s*$/.test(title)) {
+            done = true;
+            title = title.replace(/\s*[\u2705]\s*$/, "");
         }
         if (!done && /\(Complete\)\s*$/i.test(title)) {
             done = true;

package/dist/resources/extensions/gsd/slice-parallel-conflict.js

@@ -0,0 +1,67 @@
+/**
+ * GSD Slice Parallel Conflict Detection — File overlap analysis between slices.
+ *
+ * Reads PLAN.md for each slice and extracts file paths mentioned in task
+ * descriptions. If two slices share more than 5 file paths, they are considered
+ * conflicting and should not run in parallel.
+ *
+ * Conservative by default: missing PLAN = block parallel execution.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+// ─── File Path Extraction ─────────────────────────────────────────────────────
+/**
+ * Extract file paths from a PLAN.md content string.
+ * Matches common patterns like `src/...`, `lib/...`, paths with extensions.
+ */
+function extractFilePaths(content) {
+    const paths = new Set();
+    // Match file-like patterns: word/word paths with extensions, or src/lib/etc prefixed paths
+    const patterns = [
+        // Paths like src/foo/bar.ts, lib/utils.js, etc.
+        /(?:src|lib|test|tests|app|pkg|cmd|internal|components|pages|api|utils|config|scripts|dist|build)\/[\w./-]+\.\w+/g,
+        // Generic path with at least one slash and extension
+        /(?<!\w)[\w-]+\/[\w./-]+\.\w{1,5}(?!\w)/g,
+    ];
+    for (const pattern of patterns) {
+        const matches = content.matchAll(pattern);
+        for (const match of matches) {
+            paths.add(match[0]);
+        }
+    }
+    return paths;
+}
+// ─── Conflict Detection ──────────────────────────────────────────────────────
+/**
+ * Check if two slices have file conflicts that would block parallel execution.
+ *
+ * @param basePath  Project root path.
+ * @param mid       Milestone ID.
+ * @param sliceA    First slice ID.
+ * @param sliceB    Second slice ID.
+ * @returns         true if parallel is unsafe (>5 shared files or missing plan).
+ */
+export function hasFileConflict(basePath, mid, sliceA, sliceB) {
+    const planPathA = join(basePath, ".gsd", "milestones", mid, sliceA, "PLAN.md");
+    const planPathB = join(basePath, ".gsd", "milestones", mid, sliceB, "PLAN.md");
+    // Conservative: missing PLAN = block
+    if (!existsSync(planPathA) || !existsSync(planPathB)) {
+        return true;
+    }
+    const contentA = readFileSync(planPathA, "utf-8");
+    const contentB = readFileSync(planPathB, "utf-8");
+    const filesA = extractFilePaths(contentA);
+    const filesB = extractFilePaths(contentB);
+    // If either has no files extracted, no conflict detectable → allow
+    if (filesA.size === 0 || filesB.size === 0) {
+        return false;
+    }
+    // Count shared files
+    let sharedCount = 0;
+    for (const file of filesA) {
+        if (filesB.has(file)) {
+            sharedCount++;
+        }
+    }
+    return sharedCount > 5;
+}

package/dist/resources/extensions/gsd/slice-parallel-eligibility.js

@@ -0,0 +1,51 @@
+/**
+ * GSD Slice Parallel Eligibility — Pure function to determine which slices
+ * within a milestone can run in parallel based on dependency satisfaction.
+ *
+ * This is the slice-level equivalent of parallel-eligibility.ts (which operates
+ * at milestone scope). The key difference is the positional fallback: slices
+ * without explicit dependencies use sequential ordering as an implicit constraint.
+ */
+// ─── Core Logic ───────────────────────────────────────────────────────────────
+/**
+ * Determine which slices are eligible for parallel execution.
+ *
+ * Rules:
+ * 1. Done slices are never eligible (nothing to do).
+ * 2. A slice with explicit `depends` entries is eligible when ALL deps
+ *    appear in `completedSliceIds`.
+ * 3. A slice with NO `depends` entries uses positional fallback: it is
+ *    eligible only when every positionally-earlier slice is done.
+ *    This preserves backward compatibility with roadmaps that don't
+ *    declare inter-slice dependencies.
+ *
+ * @param slices      All slices in the milestone (ordered by position).
+ * @param completedSliceIds  Set of slice IDs that are already complete.
+ * @returns           Array of eligible slice descriptors.
+ */
+export function getEligibleSlices(slices, completedSliceIds) {
+    const eligible = [];
+    for (let i = 0; i < slices.length; i++) {
+        const slice = slices[i];
+        // Rule 1: skip done slices
+        if (slice.done)
+            continue;
+        const hasExplicitDeps = slice.depends.length > 0;
+        if (hasExplicitDeps) {
+            // Rule 2: explicit dependencies — all must be satisfied
+            const allDepsSatisfied = slice.depends.every(dep => completedSliceIds.has(dep));
+            if (allDepsSatisfied) {
+                eligible.push({ id: slice.id });
+            }
+        }
+        else {
+            // Rule 3: no deps declared — positional fallback
+            // Eligible only if all positionally-earlier slices are done
+            const allEarlierDone = slices.slice(0, i).every(earlier => earlier.done || completedSliceIds.has(earlier.id));
+            if (allEarlierDone) {
+                eligible.push({ id: slice.id });
+            }
+        }
+    }
+    return eligible;
+}