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

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -145,16 +145,16 @@ export async function handleCompleteMilestone(params, basePath) {
     // 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.message}`);
-            updateMilestoneStatus(params.milestoneId, 'active', null);
-            invalidateStateCache();
-            return { error: `disk render failed: ${renderErr.message}` };
+            projectionStale = true;
+            logWarning("projection", `complete_milestone projection write failed for ${params.milestoneId}; DB completion remains committed`, {
+                error: renderErr.message,
+            });
         }
     }
     // Invalidate all caches
@@ -192,5 +192,6 @@ export async function handleCompleteMilestone(params, basePath) {
     return {
         milestoneId: params.milestoneId,
         summaryPath,
+        ...(projectionStale ? { stale: true } : {}),
     };
 }

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -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";
 import { mkdirSync } from "node:fs";
@@ -216,7 +217,6 @@ export async function handleCompleteSlice(params, basePath) {
     }
     // ── 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 = null;
     transaction(() => {
         // State machine preconditions (inside txn for atomicity).
@@ -272,9 +272,6 @@ export async function handleCompleteSlice(params, basePath) {
     if (guardError) {
         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);
     // Resolve and write summary to disk
@@ -292,6 +289,8 @@ export async function handleCompleteSlice(params, basePath) {
     }
     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);
         await saveFile(uatPath, uatMd);
@@ -302,14 +301,9 @@ export async function handleCompleteSlice(params, basePath) {
         }
     }
     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.message });
-        updateSliceStatus(params.milestoneId, params.sliceId, originalSliceStatus);
-        invalidateStateCache();
-        return { error: `disk render failed: ${renderErr.message}` };
+        projectionStale = true;
+        logWarning("projection", `complete_slice projection write failed for ${params.milestoneId}/${params.sliceId}; DB completion remains committed`, { error: renderErr.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
@@ -400,5 +394,6 @@ export async function handleCompleteSlice(params, basePath) {
         milestoneId: params.milestoneId,
         summaryPath,
         uatPath,
+        ...(projectionStale ? { stale: true } : {}),
     };
 }

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -1,17 +1,17 @@
 /**
  * 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";
 import { mkdirSync } from "node:fs";
 import { isClosedStatus } from "../status-guards.js";
-import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, setTaskSummaryMd, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, 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";
@@ -119,6 +119,7 @@ export async function handleCompleteTask(params, basePath) {
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
     let guardError = 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
     // ids, recommendation references a real id). If the payload is malformed
@@ -184,6 +185,8 @@ export async function handleCompleteTask(params, basePath) {
             return;
         }
         // 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({
@@ -201,6 +204,7 @@ export async function handleCompleteTask(params, basePath) {
             knownIssues: params.knownIssues ?? "None.",
             keyFiles: params.keyFiles ?? [],
             keyDecisions: params.keyDecisions ?? [],
+            fullSummaryMd: summaryMd,
         });
         for (const evidence of (params.verificationEvidence ?? [])) {
             insertVerificationEvidence({
@@ -235,12 +239,7 @@ export async function handleCompleteTask(params, basePath) {
     if (guardError) {
         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;
     const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
@@ -256,28 +255,16 @@ export async function handleCompleteTask(params, basePath) {
     }
     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.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.message}` };
+        projectionStale = true;
+        logWarning("projection", `complete_task projection write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}; DB completion remains committed`, {
+            error: renderErr.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,
@@ -387,5 +374,6 @@ export async function handleCompleteTask(params, basePath) {
         sliceId: params.sliceId,
         milestoneId: params.milestoneId,
         summaryPath,
+        ...(projectionStale ? { stale: true } : {}),
     };
 }

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -9,7 +9,7 @@
  * despite passing validation.
  */
 import { join } from "node:path";
-import { transaction, insertAssessment, deleteAssessmentByScope, getMilestoneSlices, } from "../gsd-db.js";
+import { transaction, insertAssessment, getMilestoneSlices, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -99,14 +99,15 @@ export async function handleValidateMilestone(params, basePath, opts) {
         insertMilestoneValidationGates(params.milestoneId, gateSliceId, params.verdict, validatedAt);
     });
     // ── 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.message}`);
-        deleteAssessmentByScope(params.milestoneId, 'milestone-validation');
-        return { error: `disk render failed: ${renderErr.message}` };
+        projectionStale = true;
+        logWarning("projection", `validate_milestone projection write failed for ${params.milestoneId}; DB validation remains committed`, {
+            error: renderErr.message,
+        });
     }
     invalidateStateCache();
     clearPathCache();
@@ -147,5 +148,6 @@ export async function handleValidateMilestone(params, basePath, opts) {
         milestoneId: params.milestoneId,
         verdict: params.verdict,
         validationPath,
+        ...(projectionStale ? { stale: true } : {}),
     };
 }

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -42,7 +42,7 @@ export function snapshotState() {
     // 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();
+        const rawMilestones = db.prepare("SELECT * FROM milestones ORDER BY CASE WHEN sequence > 0 THEN 0 ELSE 1 END, sequence, id").all();
         const milestones = rawMilestones.map((r) => ({
             id: r["id"],
             title: r["title"],
@@ -61,6 +61,7 @@ export function snapshotState() {
             definition_of_done: JSON.parse(r["definition_of_done"] || "[]"),
             requirement_coverage: r["requirement_coverage"] ?? "",
             boundary_map_markdown: r["boundary_map_markdown"] ?? "",
+            sequence: Number(r["sequence"] ?? 0),
         }));
         const rawSlices = db.prepare("SELECT * FROM slices ORDER BY milestone_id, sequence, id").all();
         const slices = rawSlices.map((r) => ({

package/dist/resources/extensions/gsd/workflow-mcp-auto-prep.js

@@ -13,31 +13,13 @@ function getAuthModeSafe(ctx, provider) {
         return undefined;
     }
 }
-function hasClaudeCodeProvider(ctx) {
-    return getAuthModeSafe(ctx, "claude-code") === "externalCli";
-}
-function isClaudeCodeProviderReady(ctx) {
-    const readyCheck = ctx.modelRegistry?.isProviderRequestReady;
-    if (typeof readyCheck !== "function")
-        return false;
-    try {
-        return readyCheck("claude-code");
-    }
-    catch {
-        return false;
-    }
-}
 export function shouldAutoPrepareWorkflowMcp(ctx) {
     const provider = ctx.model?.provider;
     const baseUrl = ctx.model?.baseUrl;
     const authMode = getAuthModeSafe(ctx, provider);
-    if (usesWorkflowMcpTransport(authMode, 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, baseUrl) || authMode === "externalCli";
 }
 export function prepareWorkflowMcpForProject(ctx, projectRoot) {
     if (!shouldAutoPrepareWorkflowMcp(ctx))

package/dist/resources/extensions/gsd/workflow-reconcile.js

@@ -5,7 +5,7 @@ import { readEvents, findForkPoint, getSessionId } from "./workflow-events.js";
 import { transaction, updateTaskStatus, updateSliceStatus, updateMilestoneStatus, getSliceTasks, insertMilestone, getMilestoneSlices, insertVerificationEvidence, upsertDecision, openDatabase, setTaskBlockerDiscovered, insertOrIgnoreSlice, insertOrIgnoreTask, } 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";
@@ -407,7 +407,7 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
     mkdirSync(join(mainBasePath, ".gsd"), { recursive: true });
     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
     try {
@@ -540,7 +540,7 @@ pick) {
     const targetBaseEvents = pick === "main" ? wtBaseEvents : mainBaseEvents;
     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/dist/resources/extensions/gsd/worktree-command.js

@@ -13,7 +13,7 @@ import { loadPrompt } from "./prompt-loader.js";
 import { autoCommitCurrentBranch, getMainBranch, 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, removeWorktree, mergeWorktreeToMain, diffWorktreeAll, diffWorktreeNumstat, getWorktreeGSDDiff, getWorktreeCodeDiff, getWorktreeLog, worktreeBranchName, worktreePath, } from "./worktree-manager.js";
 import { inferCommitType } from "./git-service.js";
 import { existsSync, realpathSync, readdirSync, rmSync, unlinkSync } from "node:fs";
@@ -530,8 +530,9 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
         const commitType = inferCommitType(name);
         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");