gsd-pi 2.62.1 → 2.63.0-dev.351157b

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

@@ -104,6 +104,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "context_management",
   "experimental",
   "codebase",
+  "slice_parallel",
 ]);
 
 /** Canonical list of all dispatch unit types. */
@@ -288,6 +289,8 @@ export interface GSDPreferences {
   experimental?: ExperimentalPreferences;
   /** Configuration for the codebase map generator (/gsd codebase). */
   codebase?: CodebaseMapPreferences;
+  /** Slice-level parallelism within a milestone. Disabled by default. */
+  slice_parallel?: { enabled?: boolean; max_workers?: number };
 }
 
 export interface LoadedGSDPreferences {

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

@@ -224,9 +224,13 @@ export function parsePreferencesMarkdown(content: string): GSDPreferences | null
     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;
 }
@@ -384,6 +388,9 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
           ].filter(Boolean),
         }
       : undefined,
+    slice_parallel: (base.slice_parallel || override.slice_parallel)
+      ? { ...(base.slice_parallel ?? {}), ...(override.slice_parallel ?? {}) }
+      : undefined,
   };
 }
 

package/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/resources/extensions/gsd/roadmap-mutations.ts

@@ -39,7 +39,7 @@ export function markSliceDoneInRoadmap(basePath: string, mid: string, sid: strin
       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)) return match;
+        if (/^[\u2713\u2705]/.test(title) || /[\u2705]\s*$/.test(title) || /\(Complete\)\s*$/i.test(title)) return match;
         return `${prefix}\u2713 ${title}`;
       },
     );

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -82,7 +82,7 @@ function parseTableSlices(section: string): RoadmapSliceEntry[] {
     const fullRow = line.toLowerCase();
     const done =
       /\[x\]/i.test(line) ||
-      /[✅☑✓]/.test(line) ||
+      /[✅☑✓✔]/.test(line) ||
       /\bdone\b/.test(fullRow) ||
       /\bcomplete(?:d)?\b/.test(fullRow);
 
@@ -222,11 +222,11 @@ function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
   // 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: RegExpExecArray | null;
 
   // 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]!;
@@ -240,9 +240,14 @@ function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
     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)) {

package/src/resources/extensions/gsd/slice-parallel-conflict.ts

@@ -0,0 +1,86 @@
+/**
+ * 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: string): Set<string> {
+  const paths = new Set<string>();
+
+  // 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: string,
+  mid: string,
+  sliceA: string,
+  sliceB: string,
+): boolean {
+  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/src/resources/extensions/gsd/slice-parallel-eligibility.ts

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface SliceInput {
+  id: string;
+  done: boolean;
+  depends: string[];
+}
+
+export interface EligibleSlice {
+  id: string;
+}
+
+// ─── 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: SliceInput[],
+  completedSliceIds: Set<string>,
+): EligibleSlice[] {
+  const eligible: EligibleSlice[] = [];
+
+  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;
+}