gsd-pi 2.78.1-dev.b0759e59b → 2.78.1-dev.e9d88a536

package/src/resources/extensions/gsd/tests/worktree-sync-tasks.test.ts

@@ -1,8 +1,9 @@
 /**
- * worktree-sync-tasks.test.ts — Regression test for #1678.
+ * worktree-sync-tasks.test.ts
  *
- * Verifies that syncWorktreeStateBack() correctly syncs task summaries
- * from the tasks/ subdirectory within each slice, not just slice-level files.
+ * DB-authoritative worktree contract: task and milestone markdown under a
+ * worktree .gsd directory are legacy projections. syncWorktreeStateBack must
+ * not copy them into the canonical project .gsd tree.
  */
 
 import test from "node:test";
@@ -11,7 +12,6 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
-  readFileSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
@@ -20,19 +20,13 @@ import { tmpdir } from "node:os";
 
 import { syncWorktreeStateBack } from "../auto-worktree.ts";
 
-// ─── Helpers ─────────────────────────────────────────────────────────
-
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), `gsd-sync-test-${prefix}-`));
 }
 
 function cleanup(...dirs: string[]): void {
   for (const dir of dirs) {
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
+    rmSync(dir, { recursive: true, force: true });
   }
 }
 
@@ -42,168 +36,49 @@ function writeFile(dir: string, relativePath: string, content: string): void {
   writeFileSync(fullPath, content, "utf-8");
 }
 
-// ─── Tests ───────────────────────────────────────────────────────────
-
-test("syncWorktreeStateBack copies task summaries from tasks/ subdirectory (#1678)", () => {
+test("syncWorktreeStateBack does not copy task markdown projections from worktree", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const currentMid = "M000"; // milestone being merged (skipped by sync)
-  const mid = "M001";        // other milestone that should be synced
 
   try {
-    // Set up worktree with milestone, slice, and task files
-    writeFile(wtBase, `.gsd/milestones/${mid}/${mid}-ROADMAP.md`, "# Roadmap\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/${mid}-SUMMARY.md`, "# Summary\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-PLAN.md`, "# Plan\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-SUMMARY.md`, "# Slice Summary\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-UAT.md`, "# UAT\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-PLAN.md`, "# Task 1 Plan\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`, "# Task 1 Summary\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T02-PLAN.md`, "# Task 2 Plan\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T02-SUMMARY.md`, "# Task 2 Summary\n");
-
-    // Set up main with empty .gsd
+    writeFile(wtBase, ".gsd/milestones/M001/M001-ROADMAP.md", "# Roadmap\n");
+    writeFile(wtBase, ".gsd/milestones/M001/slices/S01/S01-PLAN.md", "# Plan\n");
+    writeFile(wtBase, ".gsd/milestones/M001/slices/S01/tasks/T01-SUMMARY.md", "# Task Summary\n");
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    // Run sync — currentMid is skipped, mid (M001) should be synced
-    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
-
-    // Verify milestone-level files synced
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/${mid}-ROADMAP.md`)),
-      "ROADMAP should be synced",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/${mid}-SUMMARY.md`)),
-      "SUMMARY should be synced",
-    );
-
-    // Verify slice-level files synced
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/S01-PLAN.md`)),
-      "S01-PLAN should be synced",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/S01-SUMMARY.md`)),
-      "S01-SUMMARY should be synced",
-    );
+    const result = syncWorktreeStateBack(mainBase, wtBase, "M000");
 
-    // Verify task-level files synced (THE BUG FIX)
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-PLAN.md`)),
-      "T01-PLAN should be synced (was dropped before fix)",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`)),
-      "T01-SUMMARY should be synced (was dropped before fix)",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T02-PLAN.md`)),
-      "T02-PLAN should be synced (was dropped before fix)",
-    );
-    assert.ok(
-      existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T02-SUMMARY.md`)),
-      "T02-SUMMARY should be synced (was dropped before fix)",
-    );
-
-    // Verify task files appear in synced list
-    const taskSynced = result.synced.filter(p => p.includes("/tasks/"));
-    assert.ok(
-      taskSynced.length >= 4,
-      `Expected at least 4 task files in synced list, got ${taskSynced.length}: ${taskSynced.join(", ")}`,
-    );
-
-    // Verify content integrity
-    const t1Summary = readFileSync(
-      join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`),
-      "utf-8",
+    assert.equal(result.synced.some((p) => p.includes("milestones/")), false);
+    assert.equal(
+      existsSync(join(mainBase, ".gsd/milestones/M001/M001-ROADMAP.md")),
+      false,
+      "milestone markdown projection must not be copied",
     );
-    assert.equal(t1Summary, "# Task 1 Summary\n");
-  } finally {
-    cleanup(mainBase, wtBase);
-  }
-});
-
-test("syncWorktreeStateBack handles multiple slices with tasks (#1678)", () => {
-  const mainBase = makeTempDir("main");
-  const wtBase = makeTempDir("wt");
-  const currentMid = "M000"; // milestone being merged (skipped)
-  const mid = "M002";        // other milestone that should be synced
-
-  try {
-    // Set up two slices with tasks
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-SUMMARY.md`, "# S01\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`, "# S01-T01\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S02/S02-SUMMARY.md`, "# S02\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S02/tasks/T01-SUMMARY.md`, "# S02-T01\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S02/tasks/T02-SUMMARY.md`, "# S02-T02\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S02/tasks/T03-SUMMARY.md`, "# S02-T03\n");
-
-    mkdirSync(join(mainBase, ".gsd"), { recursive: true });
-
-    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
-
-    // All task summaries from both slices should be synced
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`)));
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S02/tasks/T01-SUMMARY.md`)));
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S02/tasks/T02-SUMMARY.md`)));
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S02/tasks/T03-SUMMARY.md`)));
-
-    // Verify content integrity across slices
     assert.equal(
-      readFileSync(join(mainBase, `.gsd/milestones/${mid}/slices/S02/tasks/T03-SUMMARY.md`), "utf-8"),
-      "# S02-T03\n",
+      existsSync(join(mainBase, ".gsd/milestones/M001/slices/S01/tasks/T01-SUMMARY.md")),
+      false,
+      "task summary projection must not be copied",
     );
   } finally {
     cleanup(mainBase, wtBase);
   }
 });
 
-test("syncWorktreeStateBack handles slices without tasks/ directory", () => {
-  const mainBase = makeTempDir("main");
-  const wtBase = makeTempDir("wt");
-  const currentMid = "M000"; // milestone being merged (skipped)
-  const mid = "M003";        // other milestone that should be synced
-
-  try {
-    // Slice with no tasks/ subdirectory (legitimate case: pre-planning)
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-RESEARCH.md`, "# Research\n");
-
-    mkdirSync(join(mainBase, ".gsd"), { recursive: true });
-
-    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
-
-    // Should sync the slice file without errors
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/S01-RESEARCH.md`)));
-    // Should not have any task entries
-    const taskSynced = result.synced.filter(p => p.includes("/tasks/"));
-    assert.equal(taskSynced.length, 0);
-  } finally {
-    cleanup(mainBase, wtBase);
-  }
-});
-
-test("syncWorktreeStateBack ignores non-md files in tasks/", () => {
+test("syncWorktreeStateBack still copies diagnostic root files", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const currentMid = "M000"; // milestone being merged (skipped)
-  const mid = "M004";        // other milestone that should be synced
 
   try {
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-PLAN.md`, "# Plan\n");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`, "# T01\n");
-    // Non-md file should be ignored
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/.DS_Store`, "junk");
-    writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/tasks/notes.txt`, "notes");
-
+    writeFile(wtBase, ".gsd/completed-units.json", JSON.stringify({ units: ["M001/S01/T01"] }));
+    writeFile(wtBase, ".gsd/metrics.json", JSON.stringify({ version: 1, units: [] }));
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
+    const result = syncWorktreeStateBack(mainBase, wtBase, "M001");
 
-    // Only .md files should be synced
-    assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`)));
-    assert.ok(!existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/.DS_Store`)));
-    assert.ok(!existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/notes.txt`)));
+    assert.ok(result.synced.includes("completed-units.json"));
+    assert.ok(result.synced.includes("metrics.json"));
+    assert.ok(existsSync(join(mainBase, ".gsd/completed-units.json")));
+    assert.ok(existsSync(join(mainBase, ".gsd/metrics.json")));
   } finally {
     cleanup(mainBase, wtBase);
   }

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -56,6 +56,7 @@ export interface CompleteMilestoneParams {
 export interface CompleteMilestoneResult {
   milestoneId: string;
   summaryPath: string;
+  stale?: boolean;
 }
 
 function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams): string {
@@ -206,15 +207,15 @@ export async function handleCompleteMilestone(
   // This handles re-dispatch scenarios (DB/disk state divergence) where a prior
   // completion already wrote the file. Overwriting would silently destroy the
   // richer content the agent produced during the original completion run.
+  let projectionStale = false;
   if (!existsSync(summaryPath)) {
     try {
       await saveFile(summaryPath, summaryMd);
     } catch (renderErr) {
-      // Disk render failed — roll back DB status so state stays consistent
-      logWarning("tool", `complete_milestone — disk render failed, rolling back DB status: ${(renderErr as Error).message}`);
-      updateMilestoneStatus(params.milestoneId, 'active', null);
-      invalidateStateCache();
-      return { error: `disk render failed: ${(renderErr as Error).message}` };
+      projectionStale = true;
+      logWarning("projection", `complete_milestone projection write failed for ${params.milestoneId}; DB completion remains committed`, {
+        error: (renderErr as Error).message,
+      });
     }
   }
 
@@ -252,5 +253,6 @@ export async function handleCompleteMilestone(
   return {
     milestoneId: params.milestoneId,
     summaryPath,
+    ...(projectionStale ? { stale: true } : {}),
   };
 }

package/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -4,7 +4,8 @@
  * Validates inputs, checks all tasks are complete, writes slice row to DB in
  * a transaction, then (outside the transaction) renders SUMMARY.md + UAT.md
  * to disk, toggles the roadmap checkbox, stores rendered markdown in DB for
- * D004 recovery, and invalidates caches.
+ * D004 recovery, and invalidates caches. Projection write failures are stale
+ * projection diagnostics and do not roll back committed DB state.
  */
 
 import { join } from "node:path";
@@ -277,7 +278,6 @@ export async function handleCompleteSlice(
 
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   const completedAt = new Date().toISOString();
-  const originalSliceStatus = getSlice(params.milestoneId, params.sliceId)?.status ?? "pending";
   let guardError: string | null = null;
 
   transaction(() => {
@@ -349,10 +349,6 @@ export async function handleCompleteSlice(
     return { error: guardError };
   }
 
-  // ── Filesystem operations (outside transaction) ─────────────────────────
-  // If disk render fails, roll back the DB status so deriveState() and
-  // verifyExpectedArtifact() stay consistent (both say "not done").
-
   // Render summary markdown
   const summaryMd = renderSliceSummaryMarkdown(params);
 
@@ -371,6 +367,8 @@ export async function handleCompleteSlice(
 
   const uatMd = renderUatMarkdown(params);
   const uatPath = summaryPath.replace(/-SUMMARY\.md$/, "-UAT.md");
+  setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
+  let projectionStale = false;
 
   try {
     await saveFile(summaryPath, summaryMd);
@@ -382,16 +380,10 @@ export async function handleCompleteSlice(
       logWarning("tool", `complete_slice — could not find roadmap for ${params.milestoneId}, skipping checkbox toggle`);
     }
   } catch (renderErr) {
-    // Disk render failed — roll back DB status so state stays consistent
-    logWarning("tool", `complete_slice — disk render failed for ${params.milestoneId}/${params.sliceId}, rolling back DB status`, { error: (renderErr as Error).message });
-    updateSliceStatus(params.milestoneId, params.sliceId, originalSliceStatus);
-    invalidateStateCache();
-    return { error: `disk render failed: ${(renderErr as Error).message}` };
+    projectionStale = true;
+    logWarning("projection", `complete_slice projection write failed for ${params.milestoneId}/${params.sliceId}; DB completion remains committed`, { error: (renderErr as Error).message });
   }
 
-  // Store rendered markdown in DB for D004 recovery
-  setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
-
   // ── Close gates owned by complete-slice (Q8) ───────────────────────────
   // Each owned gate maps to a specific summary section via the registry.
   // If the caller populated the corresponding field, record `pass`; if the
@@ -493,5 +485,6 @@ export async function handleCompleteSlice(
     milestoneId: params.milestoneId,
     summaryPath,
     uatPath,
+    ...(projectionStale ? { stale: true } : {}),
   };
 }

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -1,10 +1,10 @@
 /**
  * complete-task handler — the core operation behind gsd_complete_task.
  *
- * Validates inputs, writes task row to DB in a transaction, then (outside
- * the transaction) renders SUMMARY.md to disk, toggles the plan checkbox,
- * stores the rendered markdown in the DB for D004 recovery, and invalidates
- * caches.
+ * Validates inputs, writes task row and rendered SUMMARY.md to DB in a
+ * transaction, then renders projections to disk and invalidates caches.
+ * Projection write failures are reported as stale projections and do not roll
+ * back committed DB state.
  */
 
 import { join } from "node:path";
@@ -22,13 +22,12 @@ import {
   getSlice,
   getTask,
   updateTaskStatus,
-  setTaskSummaryMd,
   deleteVerificationEvidence,
   saveGateResult,
   getPendingGatesForTurn,
 } from "../gsd-db.js";
 import { getGatesForTurn } from "../gate-registry.js";
-import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
+import { resolveTasksDir, clearPathCache } from "../paths.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
@@ -168,6 +167,7 @@ export async function handleCompleteTask(
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   const completedAt = new Date().toISOString();
   let guardError: string | null = null;
+  let summaryMd = "";
 
   // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
   // Building the artifact runs the full shape validation (2-4 options, unique
@@ -237,6 +237,9 @@ export async function handleCompleteTask(
     }
 
     // All guards passed — perform writes
+    const taskRow = paramsToTaskRow(params, completedAt);
+    summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence ?? []);
+
     insertMilestone({ id: params.milestoneId, title: params.milestoneId });
     insertSlice({ id: params.sliceId, milestoneId: params.milestoneId, title: params.sliceId });
     insertTask({
@@ -254,6 +257,7 @@ export async function handleCompleteTask(
       knownIssues: params.knownIssues ?? "None.",
       keyFiles: params.keyFiles ?? [],
       keyDecisions: params.keyDecisions ?? [],
+      fullSummaryMd: summaryMd,
     });
 
     for (const evidence of (params.verificationEvidence ?? [])) {
@@ -301,13 +305,7 @@ export async function handleCompleteTask(
     return { error: guardError };
   }
 
-  // ── Filesystem operations (outside transaction) ─────────────────────────
-  // If disk render fails, roll back the DB status so deriveState() and
-  // verifyExpectedArtifact() stay consistent (both say "not done").
-
-  // Render summary markdown via the single source of truth (#2720)
-  const taskRow = paramsToTaskRow(params, completedAt);
-  const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence ?? []);
+  let projectionStale = false;
 
   // Resolve and write summary to disk
   let summaryPath: string;
@@ -325,30 +323,16 @@ export async function handleCompleteTask(
   try {
     await saveFile(summaryPath, summaryMd);
 
-    // Toggle plan checkbox via renderer module
-    const planPath = resolveSliceFile(basePath, params.milestoneId, params.sliceId, "PLAN");
-    if (planPath) {
-      await renderPlanCheckboxes(basePath, params.milestoneId, params.sliceId);
-    } else {
-      process.stderr.write(
-        `gsd-db: complete_task — could not find plan file for ${params.sliceId}/${params.milestoneId}, skipping checkbox toggle\n`,
-      );
-    }
+    // Toggle or regenerate the plan projection from DB. Missing projection
+    // files are rebuilt by the renderer instead of being skipped.
+    await renderPlanCheckboxes(basePath, params.milestoneId, params.sliceId);
   } catch (renderErr) {
-    // Disk render failed — roll back DB status so state stays consistent
-    logWarning("tool", `complete_task — disk render failed, rolling back DB status: ${(renderErr as Error).message}`);
-    // Delete orphaned verification_evidence rows first (FK constraint
-    // references tasks, so evidence must go before status change).
-    // Without this, retries accumulate duplicate evidence rows (#2724).
-    deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
-    updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
-    invalidateStateCache();
-    return { error: `disk render failed: ${(renderErr as Error).message}` };
+    projectionStale = true;
+    logWarning("projection", `complete_task projection write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}; DB completion remains committed`, {
+      error: (renderErr as Error).message,
+    });
   }
 
-  // Store rendered markdown in DB for D004 recovery
-  setTaskSummaryMd(params.milestoneId, params.sliceId, params.taskId, summaryMd);
-
   // ── Close gates owned by execute-task (Q5/Q6/Q7) for this task ────────
   // Each gate id maps to a specific params field via taskGateFieldForId.
   // When the model populates the field, record `pass`; when it's empty,
@@ -471,5 +455,6 @@ export async function handleCompleteTask(
     sliceId: params.sliceId,
     milestoneId: params.milestoneId,
     summaryPath,
+    ...(projectionStale ? { stale: true } : {}),
   };
 }

package/src/resources/extensions/gsd/tools/validate-milestone.ts

@@ -14,7 +14,6 @@ import { join } from "node:path";
 import {
   transaction,
   insertAssessment,
-  deleteAssessmentByScope,
   getMilestoneSlices,
 } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
@@ -45,6 +44,7 @@ export interface ValidateMilestoneResult {
   milestoneId: string;
   verdict: string;
   validationPath: string;
+  stale?: boolean;
 }
 
 export interface ValidateMilestoneOptions {
@@ -150,13 +150,14 @@ export async function handleValidateMilestone(
   });
 
   // ── Filesystem render (outside transaction) ────────────────────────────
-  // If disk render fails, roll back the DB row so state stays consistent.
+  let projectionStale = false;
   try {
     await saveFile(validationPath, validationMd);
   } catch (renderErr) {
-    logWarning("tool", `validate_milestone — disk render failed, rolling back DB row: ${(renderErr as Error).message}`);
-    deleteAssessmentByScope(params.milestoneId, 'milestone-validation');
-    return { error: `disk render failed: ${(renderErr as Error).message}` };
+    projectionStale = true;
+    logWarning("projection", `validate_milestone projection write failed for ${params.milestoneId}; DB validation remains committed`, {
+      error: (renderErr as Error).message,
+    });
   }
 
   invalidateStateCache();
@@ -202,5 +203,6 @@ export async function handleValidateMilestone(
     milestoneId: params.milestoneId,
     verdict: params.verdict,
     validationPath,
+    ...(projectionStale ? { stale: true } : {}),
   };
 }

package/src/resources/extensions/gsd/workflow-manifest.ts

@@ -76,7 +76,9 @@ export function snapshotState(): StateManifest {
   // Wrap all reads in a deferred transaction so the snapshot is consistent
   // (all SELECTs see the same DB state even if a concurrent write lands between them).
   return readTransaction(() => {
-  const rawMilestones = db.prepare("SELECT * FROM milestones ORDER BY id").all() as Record<string, unknown>[];
+  const rawMilestones = db.prepare(
+    "SELECT * FROM milestones ORDER BY CASE WHEN sequence > 0 THEN 0 ELSE 1 END, sequence, id",
+  ).all() as Record<string, unknown>[];
   const milestones: MilestoneRow[] = rawMilestones.map((r) => ({
     id: r["id"] as string,
     title: r["title"] as string,
@@ -95,6 +97,7 @@ export function snapshotState(): StateManifest {
     definition_of_done: JSON.parse((r["definition_of_done"] as string) || "[]"),
     requirement_coverage: (r["requirement_coverage"] as string) ?? "",
     boundary_map_markdown: (r["boundary_map_markdown"] as string) ?? "",
+    sequence: Number(r["sequence"] ?? 0),
   }));
 
   const rawSlices = db.prepare("SELECT * FROM slices ORDER BY milestone_id, sequence, id").all() as Record<string, unknown>[];

package/src/resources/extensions/gsd/workflow-mcp-auto-prep.ts

@@ -29,29 +29,13 @@ function getAuthModeSafe(
   }
 }
 
-function hasClaudeCodeProvider(ctx: WorkflowMcpAutoPrepContext): boolean {
-  return getAuthModeSafe(ctx, "claude-code") === "externalCli";
-}
-
-function isClaudeCodeProviderReady(ctx: WorkflowMcpAutoPrepContext): boolean {
-  const readyCheck = ctx.modelRegistry?.isProviderRequestReady;
-  if (typeof readyCheck !== "function") return false;
-  try {
-    return readyCheck("claude-code");
-  } catch {
-    return false;
-  }
-}
-
 export function shouldAutoPrepareWorkflowMcp(ctx: WorkflowMcpAutoPrepContext): boolean {
   const provider = ctx.model?.provider;
   const baseUrl = ctx.model?.baseUrl;
   const authMode = getAuthModeSafe(ctx, provider);
 
-  if (usesWorkflowMcpTransport(authMode as any, baseUrl)) return true;
-  if (provider === "claude-code") return true;
-  if (hasClaudeCodeProvider(ctx)) return true;
-  return isClaudeCodeProviderReady(ctx);
+  if (provider !== "claude-code") return false;
+  return usesWorkflowMcpTransport(authMode as any, baseUrl) || authMode === "externalCli";
 }
 
 export function prepareWorkflowMcpForProject(

package/src/resources/extensions/gsd/workflow-reconcile.ts

@@ -20,7 +20,7 @@ import {
 } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { invalidateStateCache } from "./state.js";
-import { clearPathCache } from "./paths.js";
+import { clearPathCache, resolveGsdPathContract } from "./paths.js";
 import { clearParseCache } from "./files.js";
 import { writeManifest } from "./workflow-manifest.js";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -492,7 +492,7 @@ function _reconcileWorktreeLogsInner(
   atomicWriteSync(join(mainBasePath, ".gsd", "event-log.jsonl"), logContent);
 
   // Step 8: Replay into DB (wrapped in a transaction by replayEvents)
-  openDatabase(join(mainBasePath, ".gsd", "gsd.db"));
+  openDatabase(resolveGsdPathContract(mainBasePath).projectDb);
   replayEvents(merged);
 
   // Step 9: Write manifest
@@ -647,7 +647,7 @@ export function resolveConflict(
   writeEventLog(targetBasePath, targetBaseEvents.concat(rewrittenTargetEvents));
 
   // Replay resolved events through the DB (updates DB state)
-  openDatabase(join(basePath, ".gsd", "gsd.db"));
+  openDatabase(resolveGsdPathContract(basePath).projectDb);
   replayEvents(eventsToReplay);
   invalidateStateCache();
   clearPathCache();

package/src/resources/extensions/gsd/worktree-command.ts

@@ -15,7 +15,7 @@ import { loadPrompt } from "./prompt-loader.js";
 import { autoCommitCurrentBranch, getMainBranch, resolveGitHeadPath, nudgeGitBranchCache } from "./worktree.js";
 import { runWorktreePostCreateHook } from "./auto-worktree.js";
 import { showConfirm } from "../shared/tui.js";
-import { gsdRoot, milestonesDir } from "./paths.js";
+import { gsdRoot, milestonesDir, resolveGsdPathContract } from "./paths.js";
 import {
   createWorktree,
   listWorktrees,
@@ -651,8 +651,9 @@ async function handleMerge(
     const commitMessage = `${commitType}: merge worktree ${name}\n\nGSD-Worktree: ${name}`;
 
     // Reconcile worktree DB into main DB before squash merge
-    const wtDbPath = join(worktreePath(basePath, name), ".gsd", "gsd.db");
-    const mainDbPath = join(basePath, ".gsd", "gsd.db");
+    const contract = resolveGsdPathContract(worktreePath(basePath, name), basePath);
+    const wtDbPath = join(contract.worktreeGsd ?? join(contract.workRoot, ".gsd"), "gsd.db");
+    const mainDbPath = contract.projectDb;
     if (existsSync(wtDbPath) && existsSync(mainDbPath)) {
       try {
         const { reconcileWorktreeDb } = await import("./gsd-db.js");

package/dist/web/standalone/.next/server/chunks/8527.js

@@ -1 +0,0 @@
-exports.id=8527,exports.ids=[8527],exports.modules={18527:(a,b,c)=>{"use strict";c.d(b,{isOnboardingComplete:()=>l,readOnboardingRecord:()=>k});var d=c(73024),e=c(76760);c(77598);var f=c(16698),g=c(48161);c(31421),process.env.GSD_ENABLE_NATIVE_GSD_PARSER,Symbol("native-unavailable"),new f.AsyncLocalStorage,c(89134),Object.values({Q3:{id:"Q3",scope:"slice",ownerTurn:"gate-evaluate",question:"How can this be exploited?",guidance:"Identify abuse scenarios: parameter tampering, replay attacks, privilege escalation.\nMap data exposure risks: PII, tokens, secrets accessible through this slice.\nDefine input trust boundaries: untrusted user input reaching DB, API, or filesystem.\nIf none apply, return verdict 'omitted' with rationale explaining why.",promptSection:"Abuse Surface"},Q4:{id:"Q4",scope:"slice",ownerTurn:"gate-evaluate",question:"Which existing requirements (R-IDs) does this slice touch, and which must be re-tested?",guidance:"List the R-IDs (e.g. R001, R003) touched by this slice; see the milestone requirements artifact at .gsd/milestones/<id>/REQUIREMENTS.md.\nIdentify what must be re-tested after shipping.\nFlag decisions that should be revisited given the new scope.\nIf no existing requirements are affected, return verdict 'omitted'.",promptSection:"Broken Promises"},Q5:{id:"Q5",scope:"task",ownerTurn:"execute-task",question:"What breaks when dependencies fail?",guidance:"Enumerate the task's external dependencies (APIs, filesystem, network, subprocesses).\nDescribe the failure path for each: timeout, malformed response, connection loss.\nVerify the implementation handles each failure or explicitly bubbles the error.\nReturn verdict 'omitted' only if the task has no external dependencies.",promptSection:"Failure Modes"},Q6:{id:"Q6",scope:"task",ownerTurn:"execute-task",question:"What is the 10x load breakpoint?",guidance:"Identify the resource that saturates first at 10x the expected load.\nDescribe the protection applied (pool sizing, rate limiting, pagination, caching).\nReturn verdict 'omitted' if the task has no runtime load dimension.",promptSection:"Load Profile"},Q7:{id:"Q7",scope:"task",ownerTurn:"execute-task",question:"What negative tests protect this task?",guidance:"List malformed inputs, error paths, and boundary conditions the tests cover.\nPoint to the specific test files or cases that assert each negative scenario.\nReturn verdict 'omitted' only if the task has no meaningful negative surface.",promptSection:"Negative Tests"},Q8:{id:"Q8",scope:"slice",ownerTurn:"complete-slice",question:"How will ops know this slice is healthy or broken?",guidance:"Describe the health signal (metric, log line, dashboard) that proves the slice works.\nDescribe the failure signal that triggers an alert or paging.\nDocument the recovery procedure and any monitoring gaps.\nReturn verdict 'omitted' only for slices with no runtime behavior at all.",promptSection:"Operational Readiness"},MV01:{id:"MV01",scope:"milestone",ownerTurn:"validate-milestone",question:"Is every success criterion in the milestone roadmap satisfied?",guidance:"Walk the success-criteria checklist from the milestone roadmap.\nFor each criterion, point to the slice / assessment / verification evidence that proves it.\nReturn verdict 'flag' if any criterion is unmet or unverifiable.",promptSection:"Success Criteria Checklist"},MV02:{id:"MV02",scope:"milestone",ownerTurn:"validate-milestone",question:"Does every slice have a SUMMARY.md and a passing assessment?",guidance:"Confirm every slice listed in the roadmap has a SUMMARY.md.\nConfirm each slice has an ASSESSMENT verdict of 'pass' (or justified 'omitted').\nFlag missing artifacts and slices with outstanding follow-ups or known limitations.",promptSection:"Slice Delivery Audit"},MV03:{id:"MV03",scope:"milestone",ownerTurn:"validate-milestone",question:"Do the slices integrate end-to-end?",guidance:"Trace at least one cross-slice flow proving the pieces compose.\nFlag gaps where two slices were built in isolation with no integration evidence.",promptSection:"Cross-Slice Integration"},MV04:{id:"MV04",scope:"milestone",ownerTurn:"validate-milestone",question:"Are all touched requirements covered and still coherent?",guidance:"For each requirement advanced, validated, surfaced, or invalidated across the milestone's slices, confirm the milestone-level evidence matches.\nFlag requirements that slices claim to advance but no artifact proves.",promptSection:"Requirement Coverage"}});let h=process.env.GSD_CODING_AGENT_DIR||(0,e.join)(process.env.GSD_HOME?(0,e.resolve)(process.env.GSD_HOME):(0,e.join)((0,g.homedir)(),".gsd"),"agent"),i=(0,e.join)(h,"onboarding.json"),j={version:1,flowVersion:1,completedAt:null,completedSteps:[],skippedSteps:[],lastResumePoint:null};function k(){if(!(0,d.existsSync)(i))return{...j};try{let a=JSON.parse((0,d.readFileSync)(i,"utf-8"));return{version:"number"==typeof a.version?a.version:1,flowVersion:"number"==typeof a.flowVersion?a.flowVersion:0,completedAt:"string"==typeof a.completedAt?a.completedAt:null,completedSteps:Array.isArray(a.completedSteps)?a.completedSteps.filter(a=>"string"==typeof a):[],skippedSteps:Array.isArray(a.skippedSteps)?a.skippedSteps.filter(a=>"string"==typeof a):[],lastResumePoint:"string"==typeof a.lastResumePoint?a.lastResumePoint:null}}catch{return{...j}}}function l(){let a=k();return null!==a.completedAt&&1===a.flowVersion}},65168:a=>{function b(a){var b=Error("Cannot find module '"+a+"'");throw b.code="MODULE_NOT_FOUND",b}b.keys=()=>[],b.resolve=b,b.id=65168,a.exports=b},89134:(a,b,c)=>{"use strict";c.d(b,{DZ:()=>e,rs:()=>d});let d="GSD_GIT_ERROR";class e extends Error{constructor(a,b,c){super(b,c),this.name="GSDError",this.code=a}}}};