gsd-pi 2.82.0-dev.2841a1e44 → 2.82.0-dev.3a3c6509d

package/src/resources/extensions/gsd/guided-unit-context.ts

@@ -0,0 +1,30 @@
+// GSD-2 — Guided workflow Unit context.
+// Tracks the guided Unit whose queued turn should use manifest Tool Contract policy.
+
+export interface GuidedUnitContext {
+  basePath: string;
+  unitType: string;
+  startedAt: number;
+}
+
+const guidedUnitContextByBasePath = new Map<string, GuidedUnitContext>();
+
+export function setGuidedUnitContext(basePath: string, unitType: string): GuidedUnitContext {
+  const context = { basePath, unitType, startedAt: Date.now() };
+  guidedUnitContextByBasePath.set(basePath, context);
+  return context;
+}
+
+export function getGuidedUnitContext(basePath?: string): GuidedUnitContext | null {
+  if (basePath) return guidedUnitContextByBasePath.get(basePath) ?? null;
+  if (guidedUnitContextByBasePath.size === 1) return guidedUnitContextByBasePath.values().next().value!;
+  return null;
+}
+
+export function clearGuidedUnitContext(basePath?: string): void {
+  if (basePath) {
+    guidedUnitContextByBasePath.delete(basePath);
+  } else {
+    guidedUnitContextByBasePath.clear();
+  }
+}

package/src/resources/extensions/gsd/migrate/parsers.ts

@@ -95,6 +95,17 @@ function parsePhaseEntry(line: string): PlanningRoadmapEntry | null {
     };
   }
 
+  // Format 3: - ✅ v1.0 MVP — Phases 1-6
+  const fmtVersionPhases = stripped.match(/^-\s+([✅🚧])\s+v\d+(?:\.\d+)*\s+(.+?)\s*[—–]\s*Phases?\s+(\d+(?:\.\d+)?)(?:\s*-\s*\d+(?:\.\d+)?)?(?:\s+\(.*\))?\s*$/iu);
+  if (fmtVersionPhases) {
+    return {
+      number: parseFloat(fmtVersionPhases[3]),
+      title: fmtVersionPhases[2].trim(),
+      done: fmtVersionPhases[1] === '✅',
+      raw: line,
+    };
+  }
+
   return null;
 }
 

package/src/resources/extensions/gsd/migration-auto-check.ts

@@ -2,21 +2,17 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import {
-  clearEngineHierarchy,
   getAllMilestones,
   getMilestoneSlices,
   getSliceTasks,
   isDbAvailable,
-  transaction,
 } from "./gsd-db.js";
-import { migrateHierarchyToDb } from "./md-importer.js";
 import { parsePlan, parseRoadmap } from "./parsers-legacy.js";
 import {
   milestonesDir,
   resolveMilestoneFile,
   resolveSliceFile,
 } from "./paths.js";
-import { invalidateStateCache } from "./state.js";
 
 export interface HierarchyCounts {
   milestones: number;
@@ -25,11 +21,13 @@ export interface HierarchyCounts {
 }
 
 export interface MigrationAutoCheckResult {
-  action: "none" | "imported";
+  action: "none" | "recovery-required";
   reason: "no-markdown" | "in-sync" | "db-empty" | "count-mismatch";
   markdown: HierarchyCounts;
   beforeDb: HierarchyCounts;
   afterDb: HierarchyCounts;
+  recoveryCommand?: string;
+  message?: string;
 }
 
 function zeroCounts(): HierarchyCounts {
@@ -83,7 +81,7 @@ export function countDbHierarchy(): HierarchyCounts {
   return counts;
 }
 
-export async function autoImportMarkdownHierarchyIfDbMismatch(
+export async function checkMarkdownHierarchyAgainstDb(
   basePath: string,
 ): Promise<MigrationAutoCheckResult> {
   const markdown = countMarkdownHierarchy(basePath);
@@ -108,22 +106,16 @@ export async function autoImportMarkdownHierarchyIfDbMismatch(
   }
 
   const reason = sameCounts(beforeDb, zeroCounts()) ? "db-empty" : "count-mismatch";
-  const imported = transaction(() => {
-    clearEngineHierarchy();
-    return migrateHierarchyToDb(basePath);
-  });
-  invalidateStateCache();
-
-  const afterDb = {
-    milestones: imported.milestones,
-    slices: imported.slices,
-    tasks: imported.tasks,
+  return {
+    action: "recovery-required",
+    reason,
+    markdown,
+    beforeDb,
+    afterDb: beforeDb,
+    recoveryCommand: "gsd recover",
+    message:
+      `Markdown planning artifacts (${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T) ` +
+      `do not match the authoritative DB (${beforeDb.milestones}M/${beforeDb.slices}S/${beforeDb.tasks}T). ` +
+      "Runtime startup will not import markdown automatically; run explicit GSD recovery if markdown should repopulate the database.",
   };
-  if (!sameCounts(markdown, afterDb)) {
-    throw new Error(
-      `migration auto-import verification failed: markdown ${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T, db ${afterDb.milestones}M/${afterDb.slices}S/${afterDb.tasks}T`,
-    );
-  }
-
-  return { action: "imported", reason, markdown, beforeDb, afterDb };
 }

package/src/resources/extensions/gsd/milestone-actions.ts

@@ -24,6 +24,7 @@ import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } f
 import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 import { isAutoActive } from "./auto.js";
+import { isClosedStatus } from "./status-guards.js";
 
 /**
  * Writer-side assert for mutations that race with auto-mode's squash merge (#4704).
@@ -44,7 +45,7 @@ function assertNotAutoActive(action: string): void {
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
  * Parked milestones are skipped during active-milestone discovery but stay on disk.
- * Returns true if successfully parked, false if milestone not found or already parked.
+ * Returns true if successfully parked, false if milestone not found, already parked, or complete.
  */
 export function parkMilestone(basePath: string, milestoneId: string, reason: string): boolean {
   assertNotAutoActive("park milestone");
@@ -52,8 +53,13 @@ export function parkMilestone(basePath: string, milestoneId: string, reason: str
   if (!mDir || !existsSync(mDir)) return false;
 
   // Guard: do not park a completed milestone — it would corrupt depends_on satisfaction
-  const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
-  if (summaryFile) return false;
+  const dbAvailable = isDbAvailable();
+  const milestone = dbAvailable ? getMilestone(milestoneId) : null;
+  if (milestone && isClosedStatus(milestone.status)) return false;
+  if (!dbAvailable) {
+    const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
+    if (summaryFile) return false;
+  }
 
   const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
   if (existsSync(parkedPath)) return false; // already parked
@@ -72,7 +78,7 @@ export function parkMilestone(basePath: string, milestoneId: string, reason: str
 
   writeFileSync(parkedPath, content, "utf-8");
   // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
-  if (isDbAvailable()) {
+  if (dbAvailable) {
     try {
       updateMilestoneStatus(milestoneId, "parked");
     } catch (err) {

package/src/resources/extensions/gsd/native-git-bridge.ts

@@ -6,6 +6,7 @@
 // execSync calls because git2 credential handling is too complex.
 
 import { execSync, execFileSync } from "node:child_process";
+import type { ExecFileSyncOptionsWithStringEncoding } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
@@ -16,6 +17,8 @@ import { isInfrastructureError } from "./auto/infra-errors.js";
 // Issue #453: keep auto-mode bookkeeping on the stable git CLI path unless a
 // caller explicitly opts into the native helper.
 const NATIVE_GSD_GIT_ENABLED = process.env.GSD_ENABLE_NATIVE_GSD_GIT === "1";
+const TRANSIENT_GIT_RETRY_CODES = new Set(["ENOBUFS", "EAGAIN"]);
+const GIT_RETRY_DELAY_MS = 200;
 
 // ─── Native Module Types ──────────────────────────────────────────────────
 
@@ -144,9 +147,46 @@ function gitExec(basePath: string, args: string[], allowFailure = false): string
       encoding: "utf-8",
       env: GIT_NO_PROMPT_ENV,
     }).trim();
-  } catch {
+  } catch (err) {
     if (allowFailure) return "";
-    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}`);
+    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}: ${getErrorMessage(err)}`);
+  }
+}
+
+/** sleepSync uses Atomics.wait for a blocking pause without busy-waiting; it blocks the current thread and requires Atomics.wait support. */
+function sleepSync(ms: number): void {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function isRetryableGitError(err: unknown): boolean {
+  const code = isInfrastructureError(err)
+    ?? isInfrastructureError((err as { stderr?: string })?.stderr ?? "");
+  return code !== null && TRANSIENT_GIT_RETRY_CODES.has(code);
+}
+
+function execGitFileSyncWithRetry(
+  basePath: string,
+  args: string[],
+  options: Partial<ExecFileSyncOptionsWithStringEncoding>,
+): string {
+  try {
+    return execFileSync("git", args, {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+      ...options,
+    }).trim();
+  } catch (err) {
+    if (!isRetryableGitError(err)) throw err;
+    sleepSync(GIT_RETRY_DELAY_MS);
+    return execFileSync("git", args, {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+      ...options,
+    }).trim();
   }
 }
 
@@ -159,9 +199,9 @@ function gitFileExec(basePath: string, args: string[], allowFailure = false): st
       encoding: "utf-8",
       env: GIT_NO_PROMPT_ENV,
     }).trim();
-  } catch {
+  } catch (err) {
     if (allowFailure) return "";
-    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}`);
+    throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}: ${getErrorMessage(err)}`);
   }
 }
 
@@ -428,16 +468,21 @@ export function nativeDiffNameStatus(
 
 /**
  * Get numstat diff between two refs.
+ * useMergeBase: if true, uses three-dot semantics.
  * Native: libgit2 patch line stats.
  * Fallback: `git diff --numstat`.
  */
-export function nativeDiffNumstat(basePath: string, fromRef: string, toRef: string): GitNumstat[] {
+export function nativeDiffNumstat(basePath: string, fromRef: string, toRef: string, useMergeBase?: boolean): GitNumstat[] {
   const native = loadNative();
-  if (native) {
+  if (native && !useMergeBase) {
     return native.gitDiffNumstat(basePath, fromRef, toRef);
   }
 
-  const result = gitExec(basePath, ["diff", "--numstat", fromRef, toRef], true);
+  const refspec = useMergeBase ? `${fromRef}...${toRef}` : undefined;
+  const args = refspec
+    ? ["diff", "--numstat", refspec]
+    : ["diff", "--numstat", fromRef, toRef];
+  const result = gitExec(basePath, args, true);
   if (!result) return [];
 
   return result.split("\n").filter(Boolean).map(line => {
@@ -935,13 +980,10 @@ export function nativeCommit(
   try {
     const args = ["commit", "-F", "-"];
     if (options?.allowEmpty) args.push("--allow-empty");
-    const result = execFileSync("git", args, {
-      cwd: basePath,
+    const result = execGitFileSyncWithRetry(basePath, args, {
       stdio: ["pipe", "pipe", "pipe"],
-      encoding: "utf-8",
-      env: GIT_NO_PROMPT_ENV,
       input: message,
-    }).trim();
+    });
     return result;
   } catch (err: unknown) {
     const errObj = err as { stdout?: string; stderr?: string; message?: string };

package/src/resources/extensions/gsd/pending-auto-start.ts

@@ -0,0 +1,79 @@
+// GSD-2 — Pending auto-start handoff state.
+// Stores discuss-to-auto handoff entries keyed by project root.
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { createWorkspace, scopeMilestone, type MilestoneScope } from "./workspace.js";
+
+export interface PendingAutoStartEntry {
+  ctx: ExtensionCommandContext;
+  pi: ExtensionAPI;
+  basePath: string;
+  milestoneId: string;
+  step?: boolean;
+  createdAt: number;
+  readyRejectCount?: number;
+  scope: MilestoneScope;
+  planBlockedRecoveryCount: number;
+}
+
+export interface PendingAutoStartInput {
+  basePath: string;
+  milestoneId: string;
+  ctx: ExtensionCommandContext;
+  pi: ExtensionAPI;
+  step?: boolean;
+  createdAt?: number;
+}
+
+const pendingAutoStartMap = new Map<string, PendingAutoStartEntry>();
+
+export function getPendingAutoStart(basePath?: string): PendingAutoStartEntry | null {
+  if (basePath) return pendingAutoStartMap.get(basePath) ?? null;
+  if (pendingAutoStartMap.size === 1) return pendingAutoStartMap.values().next().value!;
+  return null;
+}
+
+export const _getPendingAutoStart = getPendingAutoStart;
+
+export function hasPendingAutoStart(basePath?: string): boolean {
+  if (basePath) return pendingAutoStartMap.has(basePath);
+  return pendingAutoStartMap.size > 0;
+}
+
+export function setPendingAutoStart(basePath: string, entry: PendingAutoStartInput): void {
+  if (!entry.ctx || !entry.pi) {
+    throw new Error("setPendingAutoStart requires ctx and pi");
+  }
+  const ws = createWorkspace(entry.basePath);
+  const scope = scopeMilestone(ws, entry.milestoneId);
+  pendingAutoStartMap.set(basePath, {
+    createdAt: Date.now(),
+    planBlockedRecoveryCount: 0,
+    ...entry,
+    scope,
+    ctx: entry.ctx,
+    pi: entry.pi,
+  });
+}
+
+export function deletePendingAutoStart(basePath: string): void {
+  pendingAutoStartMap.delete(basePath);
+}
+
+export function clearPendingAutoStart(basePath?: string): void {
+  if (basePath) {
+    pendingAutoStartMap.delete(basePath);
+  } else {
+    pendingAutoStartMap.clear();
+  }
+}
+
+export function getDiscussionMilestoneId(basePath?: string): string | null {
+  if (basePath) {
+    return pendingAutoStartMap.get(basePath)?.milestoneId ?? null;
+  }
+  if (pendingAutoStartMap.size === 1) {
+    return pendingAutoStartMap.values().next().value!.milestoneId;
+  }
+  return null;
+}

package/src/resources/extensions/gsd/post-execution-checks.ts

@@ -46,6 +46,46 @@ export interface PostExecutionResult {
 
 // ─── Import Resolution Check ─────────────────────────────────────────────────
 
+/**
+ * Replace the contents of single- and double-quoted string literals on a single
+ * source line with spaces so import patterns do not match text inside strings.
+ * Template-literal spans are handled separately via the inTemplateLiteral flag.
+ */
+function stripStringLiterals(line: string): string {
+  let result = "";
+  let i = 0;
+
+  while (i < line.length) {
+    const ch = line[i];
+
+    if (ch === '"' || ch === "'") {
+      result += ch;
+      i++;
+
+      while (i < line.length) {
+        const c = line[i];
+
+        if (c === "\\" && i + 1 < line.length) {
+          result += "  ";
+          i += 2;
+        } else if (c === ch) {
+          result += ch;
+          i++;
+          break;
+        } else {
+          result += " ";
+          i++;
+        }
+      }
+    } else {
+      result += ch;
+      i++;
+    }
+  }
+
+  return result;
+}
+
 /**
  * Extract relative import paths from TypeScript/JavaScript source code.
  * Returns array of { importPath, lineNum } for relative imports.
@@ -62,14 +102,23 @@ export function extractRelativeImports(
   //   import './path'
   //   require('./path')
   //   require("../path")
-  const importPattern = /(?:import\s+(?:.*?\s+from\s+)?|require\s*\(\s*)(['"])(\.\.?\/[^'"]+)\1/g;
+  const importPattern = /(?:^|[;{}]\s*)import\s+(?:.*?\s+from\s+)?(['"])(\.\.?\/[^'"]+)\1/g;
+  const requirePattern = /require\s*\(\s*(['"])(\.\.?\/[^'"]+)\1/g;
 
   // Track if we're inside a block comment
   let inBlockComment = false;
+  let inTemplateLiteral = false;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
 
+    if (inTemplateLiteral) {
+      if ((line.match(/(?<!\\)`/g) ?? []).length % 2 === 1) {
+        inTemplateLiteral = false;
+      }
+      continue;
+    }
+
     // Handle block comment boundaries
     if (inBlockComment) {
       if (line.includes("*/")) {
@@ -101,10 +150,22 @@ export function extractRelativeImports(
 
     // Reset lastIndex for each line
     importPattern.lastIndex = 0;
+    requirePattern.lastIndex = 0;
+
+    const strippedLine = stripStringLiterals(line);
 
     while ((match = importPattern.exec(line)) !== null) {
+      const importOffset = match[0].indexOf("import");
+      const importStart = match.index + importOffset;
+      if (
+        strippedLine.slice(importStart, importStart + "import".length) !==
+        "import"
+      ) {
+        continue;
+      }
+
       // Check if this match is after a // comment marker on the same line
-      const beforeMatch = line.substring(0, match.index);
+      const beforeMatch = strippedLine.substring(0, match.index);
       if (beforeMatch.includes("//")) {
         continue;
       }
@@ -114,6 +175,30 @@ export function extractRelativeImports(
         lineNum: i + 1,
       });
     }
+
+    while ((match = requirePattern.exec(line)) !== null) {
+      if (
+        strippedLine.slice(match.index, match.index + "require".length) !==
+        "require"
+      ) {
+        continue;
+      }
+
+      // Check if this match is after a // comment marker on the same line
+      const beforeMatch = strippedLine.substring(0, match.index);
+      if (beforeMatch.includes("//")) {
+        continue;
+      }
+
+      imports.push({
+        importPath: match[2],
+        lineNum: i + 1,
+      });
+    }
+
+    if ((strippedLine.match(/(?<!\\)`/g) ?? []).length % 2 === 1) {
+      inTemplateLiteral = true;
+    }
   }
 
   return imports;

package/src/resources/extensions/gsd/pre-execution-checks.ts

@@ -23,6 +23,7 @@ import { homedir } from "node:os";
 import { resolve } from "node:path";
 import type { TaskRow } from "./db-task-slice-rows.js";
 import type { PreExecutionCheckJSON } from "./verification-evidence.ts";
+import { validateVerificationCommand } from "./verification-gate.js";
 
 const NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";
 
@@ -37,6 +38,35 @@ export interface PreExecutionResult {
   durationMs: number;
 }
 
+export function checkVerificationCommands(tasks: TaskRow[]): PreExecutionCheckJSON[] {
+  const results: PreExecutionCheckJSON[] = [];
+
+  for (const task of tasks) {
+    const verify = task.verify.trim();
+    if (!verify) continue;
+
+    const commands = verify
+      .split("&&")
+      .map((command) => command.trim())
+      .filter(Boolean);
+
+    for (const command of commands) {
+      const validation = validateVerificationCommand(command);
+      if (!validation.ok) {
+        results.push({
+          category: "tool",
+          target: `${task.id} Verify`,
+          passed: false,
+          message: `Unsafe or non-runnable Verify command: ${command} (${validation.reason})`,
+          blocking: true,
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
 // ─── Package Existence Check ─────────────────────────────────────────────────
 
 /**
@@ -757,8 +787,9 @@ export async function runPreExecutionChecks(
   const fileChecks = checkFilePathConsistency(tasks, basePath);
   const orderingChecks = checkTaskOrdering(tasks, basePath);
   const contractChecks = checkInterfaceContracts(tasks, basePath);
+  const verificationChecks = checkVerificationCommands(tasks);
 
-  allChecks.push(...fileChecks, ...orderingChecks, ...contractChecks);
+  allChecks.push(...fileChecks, ...orderingChecks, ...contractChecks, ...verificationChecks);
 
   // Run async package checks
   const packageChecks = await checkPackageExistence(tasks, basePath);

package/src/resources/extensions/gsd/prompt-loader.ts

@@ -200,7 +200,7 @@ export function loadPrompt(name: string, vars: Record<string, string> = {}): str
     if (missing.length > 0) {
       throw new GSDError(
         GSD_PARSE_ERROR,
-        `loadPrompt("${name}"): template declares {{${missing.join("}}, {{")}}}} but no value was provided. ` +
+        `loadPrompt("${name}"): template declares {{${missing.join("}}, {{")}}} but no value was provided. ` +
         `This usually means the extension code in memory is older than the template on disk. ` +
         `Restart pi to reload the extension.`,
       );

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

@@ -57,7 +57,7 @@ Subagents report only; they do not write user source. Fold any findings into Dec
 **Success path** (all verifications passed):
 
 10. For each requirement whose status changed in step 9, call `gsd_requirement_update` with the requirement ID and updated `status` and `validation` fields — the tool regenerates `.gsd/REQUIREMENTS.md` automatically. Do this BEFORE completing the milestone so requirement updates are persisted.
-11. Update `.gsd/PROJECT.md`: use the `write` tool with `path: ".gsd/PROJECT.md"` and `content` containing the full updated document reflecting milestone completion and current project state. Do NOT use the `edit` tool for this — PROJECT.md is a full-document refresh.
+11. Refresh the project state through `gsd_summary_save` with `artifact_type: "PROJECT"` and the full updated project markdown as `content`; omit `milestone_id`. The tool persists the DB-backed PROJECT artifact and renders `.gsd/PROJECT.md`. Do not write or edit `.gsd/PROJECT.md` directly.
 12. Extract structured learnings from this milestone and persist them to the GSD memory store. Follow the procedure block immediately below — it writes `{{milestoneId}}-LEARNINGS.md` as the audit trail and persists Patterns, Lessons, and Decisions via `capture_thought` (categories: pattern, gotcha/convention, architecture). The memory store is the single source of truth for cross-session durable knowledge (ADR-013).
 
 {{extractLearningsSteps}}

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

@@ -34,7 +34,7 @@ Use `subagent` only for fresh-context review when useful: reviewer for cross-cut
 12. Review the inlined task-summary excerpts for DECISIONS.md and KNOWLEDGE.md-worthy decisions, patterns, and gotchas. Read full `*-SUMMARY.md` files only when an excerpt is absent, truncated, or lacks the specific evidence needed for the slice narrative. Capture significant items with `capture_thought`; do not append knowledge files directly.
 13. When verification passes, call `gsd_slice_complete`. The DB-backed tool is the canonical write path. Do **not** manually write `{{sliceSummaryPath}}`. Do **not** manually write `{{sliceUatPath}}`. Do not edit roadmap checkboxes; the tool renders files and updates projections.
 14. Do not run git commands.
-15. Update `.gsd/PROJECT.md` with a full `write` only if the current project state needs refresh.
+15. If the current project state needs refresh, call `gsd_summary_save` with `artifact_type: "PROJECT"` and the full updated project markdown as `content`; omit `milestone_id`. Do not write or edit `.gsd/PROJECT.md` directly.
 
 **Autonomous execution:** no human is available. Do not call `ask_user_questions` or `secure_env_collect`; make reasonable assumptions and document them.
 

package/src/resources/extensions/gsd/prompts/discuss-headless.md

@@ -106,8 +106,8 @@ Directories use bare IDs. Files use ID-SUFFIX format. Titles live inside content
 
 In a single pass:
 1. `mkdir -p .gsd/milestones/{{milestoneId}}/slices`
-2. Write or update `.gsd/PROJECT.md` — use the **Project** output template below. Describe what the project is, its current state, and list the milestone sequence.
-3. Write or update `.gsd/REQUIREMENTS.md` — use the **Requirements** output template below. Confirm states, ownership, and traceability before roadmap creation.
+2. Call `gsd_summary_save` with `artifact_type: "PROJECT"` and full Project template content. The tool persists the DB-backed PROJECT artifact and renders `.gsd/PROJECT.md`. Describe what the project is, its current state, and list the milestone sequence.
+3. Persist requirements with `gsd_requirement_save` or `gsd_requirement_update`, then call `gsd_summary_save` with `artifact_type: "REQUIREMENTS"` so the tool renders `.gsd/REQUIREMENTS.md` from DB rows. Confirm states, ownership, and traceability before roadmap creation.
 
 **Depth-Preservation Guidance for context.md:** Preserve the specification's exact terminology, emphasis, and framing. Do not flatten domain-specific language into generics. CONTEXT.md is downstream agents' only window into this spec.
 
@@ -120,8 +120,8 @@ In a single pass:
 
 Before emitting the ready phrase, verify in the CURRENT turn that you have:
 
-- [ ] Written `.gsd/PROJECT.md` (step 2)
-- [ ] Written `.gsd/REQUIREMENTS.md` (step 3)
+- [ ] Called `gsd_summary_save` for the PROJECT artifact (step 2)
+- [ ] Persisted requirements and called `gsd_summary_save` for the REQUIREMENTS artifact (step 3)
 - [ ] Written `{{contextPath}}` (step 4)
 - [ ] Called `gsd_plan_milestone` (step 5)
 
@@ -145,8 +145,8 @@ Next steps:
 #### Phase 1: Shared artifacts
 
 1. For each milestone, call `gsd_milestone_generate_id`; never invent IDs. Then `mkdir -p .gsd/milestones/<ID>/slices`.
-2. Write `.gsd/PROJECT.md` — use the **Project** output template below.
-3. Write `.gsd/REQUIREMENTS.md` — use the **Requirements** output template below. Capture Active, Deferred, Out of Scope, and any already Validated requirements. Later milestones may have provisional ownership where slice plans do not exist yet.
+2. Call `gsd_summary_save` with `artifact_type: "PROJECT"` and full Project template content so the tool persists the DB-backed PROJECT artifact and renders `.gsd/PROJECT.md`.
+3. Persist requirements with `gsd_requirement_save` or `gsd_requirement_update`, then call `gsd_summary_save` with `artifact_type: "REQUIREMENTS"` so the tool renders `.gsd/REQUIREMENTS.md` from DB rows. Capture Active, Deferred, Out of Scope, and any already Validated requirements. Later milestones may have provisional ownership where slice plans do not exist yet.
 4. For any architectural or pattern decisions, call `gsd_decision_save` — the tool auto-assigns IDs and regenerates `.gsd/DECISIONS.md` automatically.
 
 #### Phase 2: Primary milestone
@@ -214,8 +214,8 @@ For single-milestone projects, do NOT write this file.
 
 Before emitting the ready phrase, verify in the CURRENT turn that you have:
 
-- [ ] Written `.gsd/PROJECT.md`
-- [ ] Written `.gsd/REQUIREMENTS.md`
+- [ ] Called `gsd_summary_save` for the PROJECT artifact
+- [ ] Persisted requirements and called `gsd_summary_save` for the REQUIREMENTS artifact
 - [ ] Written the primary milestone `CONTEXT.md`
 - [ ] Called `gsd_plan_milestone` for the primary milestone
 - [ ] Written `.gsd/DISCUSSION-MANIFEST.json` with `gates_completed === total`