@opengsd/gsd-pi 1.1.1-dev.9f86580 → 1.1.1-dev.b2556262

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -1,17 +1,17 @@
 // Project/App: gsd-pi
 // File Purpose: Registers GSD extension runtime hooks and token-saving tool policies.
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { isToolCallEventType } from "@gsd/pi-coding-agent";
 import { ALWAYS_PRESERVED_SHIM_TOOL_NAMES } from "@gsd/pi-ai";
 import { updateSnapshot } from "../ecosystem/gsd-extension-api.js";
-import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
+import { buildMilestoneFileName, clearPathCache, milestonesDir, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
 import { canonicalToolName, clearDiscussionFlowState, isDepthConfirmationAnswer, isMilestoneDepthVerified, isQueuePhaseActive, markApprovalGateVerified, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockPlanningUnit, shouldBlockQueueExecution, shouldBlockWorktreeWrite, isGateQuestionId, setPendingGate, clearPendingGate, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
-import { clearToolInvocationError, getAutoRuntimeSnapshot, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto-runtime-state.js";
+import { clearToolInvocationError, getAutoRuntimeSnapshot, getSourceObservationStore, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError, } from "../auto-runtime-state.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { maybePauseAutoForApprovalGate, resetPendingGatePauseGuard } from "./pending-gate-pause.js";
 import { saveActivityLog } from "../activity-log.js";
@@ -31,6 +31,7 @@ import { registerPlanMilestoneSchemaRecovery } from "./plan-milestone-schema-rec
 import { AUTO_UNIT_SCOPED_TOOLS, RUN_UAT_BROWSER_TOOL_NAMES, isWorkflowAliasTool } from "../auto-unit-tool-scope.js";
 import { filterToolsForProvider } from "../model-router.js";
 import { RUN_UAT_READ_ONLY_TOOL_NAMES, RUN_UAT_WORKFLOW_TOOL_NAMES } from "../tool-presentation-plan.js";
+import { injectSourceContextBlockIntoPayload, supportsSourceObservationsForUnit } from "../source-observations.js";
 let approvalQuestionAbortInFlight = false;
 async function loadWelcomeScreenModule() {
     const candidates = [];
@@ -370,6 +371,50 @@ function deferApprovalGate(gateId, basePath) {
 function contextBasePath(ctx) {
     return typeof ctx?.cwd === "string" ? ctx.cwd : process.cwd();
 }
+function beginSourceObservationStoreForCurrentUnit(ctx) {
+    if (!isAutoActive())
+        return null;
+    const dash = getAutoRuntimeSnapshot();
+    if (!dash.currentUnit)
+        return null;
+    if (!supportsSourceObservationsForUnit(dash.currentUnit.type))
+        return null;
+    const store = getSourceObservationStore();
+    store.beginUnit({
+        unitType: dash.currentUnit.type,
+        unitId: dash.currentUnit.id,
+        startedAt: dash.currentUnit.startedAt,
+        basePath: dash.currentUnit.workspaceRoot ?? (dash.basePath || contextBasePath(ctx)),
+    });
+    return store;
+}
+function refreshSourceObservationAfterMutation(canonicalName, input, ctx) {
+    if (canonicalName !== "edit" && canonicalName !== "write")
+        return;
+    if (!input || typeof input !== "object")
+        return;
+    const store = beginSourceObservationStoreForCurrentUnit(ctx);
+    if (!store)
+        return;
+    store.observeMutation(input);
+}
+function clearSourceObservationsAfterShell(canonicalName) {
+    if (!isAutoActive())
+        return;
+    if (!isShellExecutionTool(canonicalName))
+        return;
+    const dash = getAutoRuntimeSnapshot();
+    if (!dash.currentUnit || !supportsSourceObservationsForUnit(dash.currentUnit.type))
+        return;
+    getSourceObservationStore().clear();
+}
+function isShellExecutionTool(canonicalName) {
+    return canonicalName === "bash" ||
+        canonicalName === "bg_shell" ||
+        canonicalName === "async_bash" ||
+        canonicalName === "shell" ||
+        canonicalName === "powershell";
+}
 function activateDeferredApprovalGate(basePath) {
     if (deferredApprovalGate?.basePath !== basePath)
         return;
@@ -392,6 +437,79 @@ function isContextDraftSummarySave(toolName, input) {
         return false;
     return input.artifact_type === "CONTEXT-DRAFT";
 }
+function selectedAnswerLabel(selected) {
+    if (Array.isArray(selected))
+        return selected.map(String).join(", ");
+    if (selected == null)
+        return "";
+    return String(selected);
+}
+function formatQuestionExchange(questions, answers) {
+    const lines = [];
+    for (const question of questions) {
+        lines.push(`### ${question.header ?? "Question"}`, "", question.question ?? "");
+        if (Array.isArray(question.options)) {
+            lines.push("");
+            for (const opt of question.options) {
+                lines.push(`- **${opt.label ?? ""}** — ${opt.description ?? ""}`);
+            }
+        }
+        const answer = question.id ? answers?.[question.id] : undefined;
+        if (answer) {
+            lines.push("");
+            const selected = selectedAnswerLabel(answer.selected);
+            if (selected)
+                lines.push(`**Selected:** ${selected}`);
+            if (answer.notes)
+                lines.push(`**Notes:** ${String(answer.notes)}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+async function ensureMilestoneShell(basePath, milestoneId) {
+    const milestoneDir = resolveMilestonePath(basePath, milestoneId)
+        ?? join(milestonesDir(basePath), milestoneId);
+    mkdirSync(milestoneDir, { recursive: true });
+    clearPathCache();
+    try {
+        const { ensureDbOpen } = await import("./dynamic-tools.js");
+        if (await ensureDbOpen(basePath)) {
+            const { getMilestone, insertMilestone } = await import("../gsd-db.js");
+            if (!getMilestone(milestoneId)) {
+                insertMilestone({
+                    id: milestoneId,
+                    title: `New milestone ${milestoneId}`,
+                    status: "queued",
+                });
+            }
+        }
+    }
+    catch (err) {
+        safetyLogWarning("guided", `failed to persist milestone shell for ${milestoneId}: ${err.message}`);
+    }
+    return milestoneDir;
+}
+async function saveDiscussionQuestionRound(basePath, milestoneId, questions, details) {
+    const milestoneDir = await ensureMilestoneShell(basePath, milestoneId);
+    const answers = details?.response?.answers;
+    const timestamp = new Date().toISOString();
+    const exchange = formatQuestionExchange(questions, answers);
+    const discussionPath = join(milestoneDir, buildMilestoneFileName(milestoneId, "DISCUSSION"));
+    const existingDiscussion = await loadFile(discussionPath) ?? `# ${milestoneId} Discussion Log\n\n`;
+    await saveFile(discussionPath, `${existingDiscussion}## Exchange — ${timestamp}\n\n${exchange}---\n\n`);
+    const draftPath = join(milestoneDir, buildMilestoneFileName(milestoneId, "CONTEXT-DRAFT"));
+    const existingDraft = await loadFile(draftPath);
+    const draftHeader = existingDraft
+        ?? [
+            `# ${milestoneId}: New milestone ${milestoneId}`,
+            "",
+            "This draft was captured automatically from structured question responses.",
+            "Use it so `/gsd` can resume the in-flight milestone discussion.",
+            "",
+        ].join("\n");
+    await saveFile(draftPath, `${draftHeader.trimEnd()}\n\n## Captured Question Round — ${timestamp}\n\n${exchange}`);
+}
 function withDepthGateDisplayReason(result, displayReason = "Depth confirmation is waiting for your answer.") {
     if (!result.block)
         return result;
@@ -918,6 +1036,17 @@ export function registerHooks(pi, ecosystemHandlers) {
         if (isAutoActive() && typeof event.toolCallId === "string") {
             markToolEnd(event.toolCallId);
         }
+        const toolName = canonicalToolName(event.toolName);
+        if (isAutoActive() && toolName === "read" && !event.isError) {
+            const store = beginSourceObservationStoreForCurrentUnit(ctx);
+            if (store) {
+                store.observeRead(event.input);
+            }
+        }
+        if (!event.isError) {
+            refreshSourceObservationAfterMutation(toolName, event.input, ctx);
+            clearSourceObservationsAfterShell(toolName);
+        }
         if (isAutoActive() && event.isError) {
             const resultPayload = ("result" in event ? event.result : undefined);
             const errorText = typeof resultPayload === "string"
@@ -934,12 +1063,10 @@ export function registerHooks(pi, ecosystemHandlers) {
         else if (isAutoActive()) {
             clearToolInvocationError();
         }
-        const toolName = canonicalToolName(event.toolName);
         if (toolName !== "ask_user_questions")
             return;
         const basePath = contextBasePath(ctx);
         const milestoneId = await getDiscussionMilestoneIdFor(basePath);
-        const queueActive = isQueuePhaseActive(basePath);
         const details = event.details;
         // ── Discussion gate enforcement: handle gate question responses ──
         // If the result is cancelled or has no response, the pending gate stays active
@@ -1012,38 +1139,9 @@ export function registerHooks(pi, ecosystemHandlers) {
                 break;
             }
         }
-        if (!milestoneId && !queueActive)
-            return;
         if (!milestoneId)
             return;
-        const milestoneDir = resolveMilestonePath(basePath, milestoneId);
-        if (!milestoneDir)
-            return;
-        const discussionPath = join(milestoneDir, buildMilestoneFileName(milestoneId, "DISCUSSION"));
-        const timestamp = new Date().toISOString();
-        const lines = [`## Exchange — ${timestamp}`, ""];
-        for (const question of questions) {
-            lines.push(`### ${question.header ?? "Question"}`, "", question.question ?? "");
-            if (Array.isArray(question.options)) {
-                lines.push("");
-                for (const opt of question.options) {
-                    lines.push(`- **${opt.label}** — ${opt.description ?? ""}`);
-                }
-            }
-            const answer = details.response?.answers?.[question.id];
-            if (answer) {
-                lines.push("");
-                const selected = Array.isArray(answer.selected) ? answer.selected.join(", ") : answer.selected;
-                lines.push(`**Selected:** ${selected}`);
-                if (answer.notes) {
-                    lines.push(`**Notes:** ${answer.notes}`);
-                }
-            }
-            lines.push("");
-        }
-        lines.push("---", "");
-        const existing = await loadFile(discussionPath) ?? `# ${milestoneId} Discussion Log\n\n`;
-        await saveFile(discussionPath, existing + lines.join("\n"));
+        await saveDiscussionQuestionRound(basePath, milestoneId, questions, details);
     });
     pi.on("tool_execution_start", async (event, ctx) => {
         const basePath = contextBasePath(ctx);
@@ -1095,42 +1193,51 @@ export function registerHooks(pi, ecosystemHandlers) {
         const payload = event.payload;
         if (!payload || typeof payload !== "object")
             return;
-        // ── Observation Masking ─────────────────────────────────────────────
-        // Replace old tool results with placeholders to reduce context bloat.
-        // Only active during auto-mode when context_management.observation_masking is enabled.
-        if (isAutoActive()) {
-            try {
-                const { loadEffectiveGSDPreferences } = await import("../preferences.js");
-                const { createObservationMask, createResponsesInputObservationMask, truncateContextResultMessages, truncateResponsesInputResultItems, } = await import("../context-masker.js");
-                const prefs = loadEffectiveGSDPreferences();
-                const cmConfig = prefs?.preferences.context_management;
-                // Observation masking: replace old tool results with placeholders
-                if (cmConfig?.observation_masking !== false) {
-                    const keepTurns = cmConfig?.observation_mask_turns ?? 8;
-                    const messages = payload.messages;
-                    if (Array.isArray(messages)) {
-                        payload.messages = createObservationMask(keepTurns)(messages);
-                    }
-                    const input = payload.input;
-                    if (Array.isArray(input)) {
-                        payload.input = createResponsesInputObservationMask(keepTurns)(input);
-                    }
-                }
-                // Tool result truncation: cap individual tool result content length.
-                // In pi-ai format, toolResult messages have role: "toolResult" and content: TextContent[].
-                // Creates new objects to avoid mutating shared conversation state.
-                const maxChars = cmConfig?.tool_result_max_chars ?? 800;
-                const msgs = payload.messages;
-                if (Array.isArray(msgs)) {
-                    payload.messages = truncateContextResultMessages(msgs, maxChars);
+        // ── Context Management ──────────────────────────────────────────────
+        // Load preferences once for both masking and truncation.
+        try {
+            const { loadEffectiveGSDPreferences } = await import("../preferences.js");
+            const { createObservationMask, createResponsesInputObservationMask, truncateContextResultMessages, truncateResponsesInputResultItems, } = await import("../context-masker.js");
+            const prefs = loadEffectiveGSDPreferences();
+            const cmConfig = prefs?.preferences.context_management;
+            // Observation masking: replace old tool results with placeholders.
+            // Only active during auto-mode when context_management.observation_masking is enabled.
+            if (isAutoActive() && cmConfig?.observation_masking !== false) {
+                const keepTurns = cmConfig?.observation_mask_turns ?? 8;
+                const messages = payload.messages;
+                if (Array.isArray(messages)) {
+                    payload.messages = createObservationMask(keepTurns)(messages);
                 }
                 const input = payload.input;
                 if (Array.isArray(input)) {
-                    payload.input = truncateResponsesInputResultItems(input, maxChars);
+                    payload.input = createResponsesInputObservationMask(keepTurns)(input);
+                }
+            }
+            // Tool result truncation: cap individual tool result content length.
+            // Applies in ALL modes (auto + interactive) to prevent context bloat.
+            // In pi-ai format, toolResult messages have role: "toolResult" and content: TextContent[].
+            // Creates new objects to avoid mutating shared conversation state.
+            const maxChars = cmConfig?.tool_result_max_chars ?? 800;
+            const msgs = payload.messages;
+            if (Array.isArray(msgs)) {
+                payload.messages = truncateContextResultMessages(msgs, maxChars);
+            }
+            const input = payload.input;
+            if (Array.isArray(input)) {
+                payload.input = truncateResponsesInputResultItems(input, maxChars);
+            }
+        }
+        catch { /* non-fatal */ }
+        try {
+            if (isAutoActive()) {
+                const sourceContextBlock = getSourceObservationStore().renderActiveBlock();
+                if (sourceContextBlock) {
+                    const nextPayload = injectSourceContextBlockIntoPayload(payload, sourceContextBlock);
+                    Object.assign(payload, nextPayload);
                 }
             }
-            catch { /* non-fatal */ }
         }
+        catch { /* non-fatal */ }
         // ── Service Tier ────────────────────────────────────────────────────
         const modelId = event.model?.id;
         if (!modelId)

package/dist/resources/extensions/gsd/closeout-wizard.js

@@ -1,10 +1,17 @@
 // Project/App: gsd-pi
 // File Purpose: Shared closeout detection and merge actions for /gsd home and smart entry.
+import { setAutoOutcomeWidget } from "./auto-dashboard.js";
 import { invalidateAllCaches } from "./cache.js";
 import { mergeCompletedMilestone } from "./parallel-merge.js";
 import { cleanupQuickBranch, detectStrandedQuickBranch } from "./quick.js";
 import { findUnmergedCompletedMilestones, } from "./unmerged-milestone-guard.js";
 import { appendRequirementsBacklogToSummary } from "./requirements-backlog.js";
+const MILESTONE_MERGE_CLOSEOUT_COMMANDS = [
+    "/gsd status for overview",
+    "/gsd visualize to inspect",
+    "/gsd notifications for history",
+    "/gsd start for new work",
+];
 export async function loadCloseoutContext(basePath) {
     const unmergedMilestones = await findUnmergedCompletedMilestones(basePath);
     return {
@@ -65,6 +72,18 @@ export function buildIdleMenuSummary(state, closeout) {
     }
     return [state.nextAction || "No active milestone."];
 }
+export function showMilestoneMergeCloseout(ctx, blocker) {
+    ctx.ui.setStatus?.("gsd-auto", undefined);
+    ctx.ui.setStatus?.("gsd-step", undefined);
+    ctx.ui.setWidget?.("gsd-progress", undefined);
+    setAutoOutcomeWidget(ctx, {
+        status: "complete",
+        title: `Milestone ${blocker.milestoneId} merged`,
+        detail: `Merged ${blocker.branch} into ${blocker.integrationBranch}. Product changes are now on ${blocker.integrationBranch}.`,
+        nextAction: "Review the closeout, then start the next milestone when ready.",
+        commands: MILESTONE_MERGE_CLOSEOUT_COMMANDS,
+    });
+}
 export async function runMergeQuickTask(ctx, basePath, strandedQuick) {
     const merged = cleanupQuickBranch(basePath);
     if (merged) {
@@ -75,6 +94,18 @@ export async function runMergeQuickTask(ctx, basePath, strandedQuick) {
     ctx.ui.notify("Could not merge the quick-task branch automatically. Run `git status`, resolve any conflicts, then retry /gsd.", "error");
     return false;
 }
+export async function runMergeMilestoneBlocker(ctx, basePath, blocker) {
+    ctx.ui.notify(`Completing preserved milestone merge for ${blocker.milestoneId} from ${blocker.branch} into ${blocker.integrationBranch}.`, "info");
+    const result = await mergeCompletedMilestone(basePath, blocker.milestoneId);
+    if (result.success) {
+        invalidateAllCaches();
+        showMilestoneMergeCloseout(ctx, blocker);
+        ctx.ui.notify(`Milestone ${blocker.milestoneId} merged to ${blocker.integrationBranch}. Closeout is complete.`, "info");
+        return true;
+    }
+    ctx.ui.notify(`Milestone ${blocker.milestoneId} merge failed: ${result.error ?? "unknown error"}`, "error");
+    return false;
+}
 export async function runMergeMilestone(ctx, basePath, milestoneId) {
     const blockers = await findUnmergedCompletedMilestones(basePath);
     const blocker = milestoneId
@@ -84,15 +115,7 @@ export async function runMergeMilestone(ctx, basePath, milestoneId) {
         ctx.ui.notify("No unmerged completed milestone found.", "warning");
         return false;
     }
-    ctx.ui.notify(`Completing preserved milestone merge for ${blocker.milestoneId} from ${blocker.branch} into ${blocker.integrationBranch}.`, "info");
-    const result = await mergeCompletedMilestone(basePath, blocker.milestoneId);
-    if (result.success) {
-        ctx.ui.notify(`Milestone ${blocker.milestoneId} merged to ${blocker.integrationBranch}. Run /gsd again when ready.`, "info");
-        invalidateAllCaches();
-        return true;
-    }
-    ctx.ui.notify(`Milestone ${blocker.milestoneId} merge failed: ${result.error ?? "unknown error"}`, "error");
-    return false;
+    return runMergeMilestoneBlocker(ctx, basePath, blocker);
 }
 export async function handleCloseoutChoice(ctx, basePath, choice, closeout) {
     if (choice === "finish_quick") {

package/dist/resources/extensions/gsd/commands/handlers/ops.js

@@ -14,7 +14,7 @@ import { handleSessionReport } from "../../commands-session-report.js";
 import { handlePrBranch } from "../../commands-pr-branch.js";
 import { currentDirectoryRoot, projectRoot } from "../context.js";
 import { findUnmergedCompletedMilestones } from "../../unmerged-milestone-guard.js";
-import { mergeCompletedMilestone } from "../../parallel-merge.js";
+import { runMergeMilestoneBlocker } from "../../closeout-wizard.js";
 async function handleCompletedMilestoneRecovery(phase, ctx, basePath) {
     const tokens = phase.split(/\s+/).filter(Boolean);
     const dispatchPhase = tokens[0] ?? "";
@@ -27,14 +27,7 @@ async function handleCompletedMilestoneRecovery(phase, ctx, basePath) {
         : blockers[0];
     if (!blocker)
         return false;
-    ctx.ui.notify(`Completing preserved milestone merge for ${blocker.milestoneId} from ${blocker.branch} into ${blocker.integrationBranch}.`, "info");
-    const result = await mergeCompletedMilestone(basePath, blocker.milestoneId);
-    if (result.success) {
-        ctx.ui.notify(`Milestone ${blocker.milestoneId} merged to ${blocker.integrationBranch}. Run /gsd again when ready.`, "info");
-    }
-    else {
-        ctx.ui.notify(`Milestone ${blocker.milestoneId} merge recovery failed: ${result.error}`, "error");
-    }
+    await runMergeMilestoneBlocker(ctx, basePath, blocker);
     return true;
 }
 export function normalizeReportExportArgs(trimmed) {

package/dist/resources/extensions/gsd/commands-maintenance.js

@@ -448,22 +448,57 @@ function recoverConfirmed(args) {
         .map((part) => part.trim().toLowerCase())
         .some((part) => part === "--confirm" || part === "--yes" || part === "confirm");
 }
-async function confirmRecover(ctx, args) {
-    if (recoverConfirmed(args))
-        return true;
+function recoverAllowsDataLoss(args) {
+    return args
+        .split(/\s+/)
+        .map((part) => part.trim().toLowerCase())
+        .some((part) => part === "--allow-data-loss" || part === "--force");
+}
+async function confirmRecover(ctx, args, markdown, beforeDb, dataLoss) {
     const warning = [
         "gsd recover imports markdown into the database.",
         "It clears and reconstructs milestone, slice, and task hierarchy rows from rendered markdown.",
         "Use /gsd rebuild markdown for normal DB-to-markdown realignment.",
-    ].join("\n");
+        "",
+        `  Markdown on disk: ${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T`,
+        `  Current DB:       ${beforeDb.milestones}M/${beforeDb.slices}S/${beforeDb.tasks}T`,
+    ];
+    if (dataLoss) {
+        warning.push("", "⚠ The DB holds rows the markdown lacks. Recover will permanently DELETE", "  those rows. A snapshot is written to .gsd/backups/ first, but if the DB", "  is the source of truth you almost certainly want /gsd rebuild markdown.");
+    }
+    const warningText = warning.join("\n");
+    if (recoverConfirmed(args)) {
+        // Non-interactive --confirm still refuses a data-loss recover unless the
+        // caller explicitly opts in with --allow-data-loss / --force.
+        if (dataLoss && !recoverAllowsDataLoss(args)) {
+            ctx.ui.notify(`${warningText}\n\nRefusing: this would delete authoritative DB rows. Re-run with ` +
+                `/gsd recover --confirm --allow-data-loss to proceed, or use /gsd rebuild markdown ` +
+                `to re-project markdown from the DB instead.`, "error");
+            return false;
+        }
+        return true;
+    }
     if (typeof ctx.ui.confirm === "function") {
-        const confirmed = await ctx.ui.confirm("Import markdown into the DB?", `${warning}\n\nContinue only if the DB is lost or corrupt and markdown is the source you intend to import.`);
-        if (confirmed)
-            return true;
-        ctx.ui.notify("gsd recover cancelled. No database changes made.", "info");
-        return false;
+        const confirmed = await ctx.ui.confirm("Import markdown into the DB?", `${warningText}\n\nContinue only if the DB is lost or corrupt and markdown is the source you intend to import.`);
+        if (!confirmed) {
+            ctx.ui.notify("gsd recover cancelled. No database changes made.", "info");
+            return false;
+        }
+        // Data loss requires a second, explicit acknowledgement — the interactive
+        // equivalent of the --allow-data-loss opt-in the non-interactive paths
+        // demand. A single generic "yes" must not silently delete DB rows.
+        if (dataLoss) {
+            const acknowledged = await ctx.ui.confirm("Permanently delete DB rows the markdown lacks?", "This recover will DELETE authoritative DB rows the markdown does not contain. " +
+                "A snapshot is saved to .gsd/backups/ first, but /gsd rebuild markdown is usually " +
+                "what you want. Proceed with the deletion?");
+            if (!acknowledged) {
+                ctx.ui.notify("gsd recover cancelled. No database changes made.", "info");
+                return false;
+            }
+        }
+        return true;
     }
-    ctx.ui.notify(`${warning}\n\nNo database changes made. Re-run /gsd recover --confirm to proceed.`, "warning");
+    ctx.ui.notify(`${warningText}\n\nNo database changes made. Re-run /gsd recover --confirm to proceed.`, "warning");
     return false;
 }
 /**
@@ -476,16 +511,27 @@ async function confirmRecover(ctx, args) {
  * Prints counts of recovered items and the resulting project phase.
  */
 export async function handleRecover(ctx, basePath, args = "") {
-    const { isDbAvailable: dbAvailable, clearEngineHierarchy, transaction: dbTransaction } = await import("./gsd-db.js");
+    const { isDbAvailable: dbAvailable, clearEngineHierarchy, transaction: dbTransaction, backupDatabaseSnapshot } = await import("./gsd-db.js");
     const { migrateHierarchyToDb } = await import("./md-importer.js");
     const { invalidateStateCache } = await import("./state.js");
+    const { countDbHierarchy, countMarkdownHierarchy, recoverWouldDeleteDbRows } = await import("./migration-auto-check.js");
+    const { renderAllFromDb } = await import("./markdown-renderer.js");
     if (!dbAvailable()) {
         ctx.ui.notify("gsd recover: No database open. Run a GSD command first to initialize the DB.", "error");
         return;
     }
-    if (!(await confirmRecover(ctx, args)))
+    // Compare markdown-on-disk against the live DB so the confirmation prompt can
+    // surface exactly what recover will overwrite (and refuse silent data loss).
+    // The data-loss check is identity-based, not count-based: it flags any DB row
+    // markdown lacks, including equal-count divergence (DB S99 vs markdown S01).
+    const markdown = countMarkdownHierarchy(basePath);
+    const beforeDb = countDbHierarchy();
+    const dataLoss = recoverWouldDeleteDbRows(basePath);
+    if (!(await confirmRecover(ctx, args, markdown, beforeDb, dataLoss)))
         return;
     try {
+        // 0. Snapshot the DB before the destructive clear so recover is reversible.
+        const backupPath = backupDatabaseSnapshot("pre-recover");
         // 1. Delete + re-populate inside a single transaction for atomicity.
         //    clearEngineHierarchy() uses transaction() internally but transaction()
         //    is re-entrant, so wrapping in dbTransaction() keeps the whole
@@ -494,8 +540,14 @@ export async function handleRecover(ctx, basePath, args = "") {
             clearEngineHierarchy();
             return migrateHierarchyToDb(basePath);
         });
-        // 3. Invalidate state cache so deriveState() picks up fresh DB data
+        // 2. Invalidate state cache so deriveState() picks up fresh DB data
         invalidateStateCache();
+        // 3. Re-project markdown from the freshly imported DB so disk and DB agree
+        //    immediately (otherwise the markdown still reflects the pre-import state
+        //    and the next startup check would flag fresh drift). renderAllFromDb
+        //    swallows per-artifact failures into its result, so inspect them — a
+        //    silent projection failure must not be reported as a clean success.
+        const renderResult = await renderAllFromDb(basePath);
         // 4. Derive state to verify sanity
         const state = await deriveState(basePath);
         // 5. Report
@@ -507,6 +559,18 @@ export async function handleRecover(ctx, basePath, args = "") {
             ``,
             `  Phase:      ${state.phase}`,
         ];
+        // Post-import verification: markdown that failed to parse imports as fewer
+        // rows than countMarkdownHierarchy saw on disk. Surface the shortfall.
+        if (counts.milestones < markdown.milestones ||
+            counts.slices < markdown.slices ||
+            counts.tasks < markdown.tasks) {
+            lines.push(``, `  ⚠ Imported fewer rows than markdown contained ` +
+                `(${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T on disk). ` +
+                `Some markdown may have failed to parse — review before continuing.`);
+        }
+        if (backupPath) {
+            lines.push(``, `  Backup:     ${backupPath}`);
+        }
         if (state.activeMilestone) {
             lines.push(`  Active:     ${state.activeMilestone.id}: ${state.activeMilestone.title}`);
         }
@@ -516,8 +580,22 @@ export async function handleRecover(ctx, basePath, args = "") {
         if (state.activeTask) {
             lines.push(`  Task:       ${state.activeTask.id}: ${state.activeTask.title}`);
         }
-        process.stderr.write(`gsd-recover: recovered ${counts.milestones}M/${counts.slices}S/${counts.tasks}T hierarchy\n`);
-        ctx.ui.notify(lines.join("\n"), "success");
+        // Surface markdown projection failures: renderAllFromDb resolves even when
+        // individual artifacts fail to render, so a clean exit here would otherwise
+        // hide a stale/partial projection.
+        const renderFailed = renderResult.errors.length > 0;
+        if (renderFailed) {
+            lines.push(``, `  ⚠ ${renderResult.errors.length} markdown projection(s) failed to render — ` +
+                `markdown may be stale. Re-run /gsd rebuild markdown.`);
+            for (const e of renderResult.errors.slice(0, 5))
+                lines.push(`    - ${e}`);
+            if (renderResult.errors.length > 5) {
+                lines.push(`    …and ${renderResult.errors.length - 5} more`);
+            }
+        }
+        process.stderr.write(`gsd-recover: recovered ${counts.milestones}M/${counts.slices}S/${counts.tasks}T hierarchy` +
+            `${renderFailed ? ` (${renderResult.errors.length} projection errors)` : ""}\n`);
+        ctx.ui.notify(lines.join("\n"), renderFailed ? "warning" : "success");
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -1236,7 +1236,7 @@ async function configureHooks(ctx, prefs) {
     if (geEnabled !== undefined)
         ge.enabled = geEnabled;
     const currentSliceGates = Array.isArray(ge.slice_gates) ? ge.slice_gates : [];
-    const sgInput = await ctx.ui.input(`Slice gates to evaluate (comma-separated, blank keeps)${currentSliceGates.length ? ` (current: ${currentSliceGates.join(", ")})` : " (default: Q3,Q4)"}:`, currentSliceGates.join(", "));
+    const sgInput = await ctx.ui.input(`Gate-evaluate slice gates (Q3,Q4; comma-separated, blank keeps)${currentSliceGates.length ? ` (current: ${currentSliceGates.join(", ")})` : " (default: Q3,Q4)"}:`, currentSliceGates.join(", "));
     if (sgInput !== null && sgInput !== undefined) {
         const parsed = parseStringList(sgInput);
         if (parsed.length > 0)
@@ -1697,7 +1697,7 @@ export function serializePreferencesToFrontmatter(prefs) {
     // Ordered keys for consistent output
     const orderedKeys = [
         "version", "mode", "always_use_skills", "prefer_skills", "avoid_skills",
-        "skill_rules", "custom_instructions", "models", "skill_discovery",
+        "skill_rules", "custom_instructions", "models", "thinking", "skill_discovery",
         "skill_staleness_days", "auto_supervisor", "uat_dispatch", "unique_milestone_ids",
         "budget_ceiling", "budget_enforcement", "context_pause_threshold",
         "notifications", "cmux", "remote_questions", "git",

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

@@ -397,6 +397,41 @@ let _decisionSaveLock = Promise.resolve();
 export function _resetDecisionSaveLock() {
     _decisionSaveLock = Promise.resolve();
 }
+/**
+ * Re-project root DECISIONS.md from the authoritative decision records, with no
+ * new decision being added. Mirrors the projection saveDecisionToDb performs
+ * after a save, but over the full set — so a DB → markdown re-projection
+ * (recover, rebuild, reconcile) re-derives DECISIONS.md and never leaves it
+ * showing a stale subset (e.g. after a worktree merge that accepted one
+ * branch's DECISIONS.md while the DB holds the union of both branches'
+ * decisions). DB stays the single source of truth; this only writes markdown.
+ */
+export async function regenerateDecisionsMarkdown(basePath) {
+    const { getAllDecisionsFromMemories } = await import('./context-store.js');
+    const allDecisions = getAllDecisionsFromMemories();
+    const filePath = resolveGsdRootFile(basePath, 'DECISIONS');
+    let existingContent = null;
+    if (existsSync(filePath)) {
+        existingContent = readFileSync(filePath, 'utf-8');
+    }
+    // Nothing to project: no decisions in the DB and no file to normalize.
+    if (allDecisions.length === 0 && existingContent === null)
+        return;
+    let md;
+    if (existingContent && !isDecisionsTableFormat(existingContent)) {
+        // Preserve freeform content; refresh only the appended decisions table.
+        const marker = '---\n\n## Decisions Table';
+        const markerIdx = existingContent.indexOf(marker);
+        const freeformPart = markerIdx >= 0
+            ? existingContent.substring(0, markerIdx).trimEnd()
+            : existingContent.trimEnd();
+        md = freeformPart + '\n' + generateDecisionsAppendBlock(allDecisions);
+    }
+    else {
+        md = generateDecisionsMd(allDecisions);
+    }
+    await saveFile(filePath, md);
+}
 /**
  * Save a new decision to DB and regenerate DECISIONS.md.
  * Auto-assigns the next ID via nextDecisionId().