@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

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/auto.js

@@ -198,6 +198,16 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
         if (!(await guardRemoteSession(ctx, pi)))
             return true;
         const basePath = projectRoot();
+        // Cold start after /quit lands at the project root, not the worktree. If the
+        // active milestone has a live worktree, chdir back into it now so the agent
+        // doesn't have to search for it. Best-effort; resolves to a no-op otherwise.
+        try {
+            const { reenterActiveWorktreeIfNeeded } = await import("../../worktree-reentry.js");
+            await reenterActiveWorktreeIfNeeded(basePath, {
+                notify: (message) => ctx.ui.notify(message, "info"),
+            });
+        }
+        catch { /* non-fatal */ }
         const { hasGsdBootstrapArtifacts } = await import("../../detection.js");
         const { gsdRoot } = await import("../../paths.js");
         if (!hasGsdBootstrapArtifacts(gsdRoot(basePath))) {

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-mcp-status.js

@@ -34,7 +34,7 @@ export function formatMcpInitResult(status, configPath, targetPath) {
         `Config:   ${configPath}`,
         "",
         "MCP-capable clients can now load the GSD workflow and gsd-browser MCP servers from this folder.",
-        "Pi Providers use the managed gsd-browser engine directly; this project config is for External MCP Clients.",
+        "Pi Providers use built-in browser tools directly; this project config is for External MCP Clients.",
         "Restart or reconnect any client that already has this project open.",
     ].join("\n");
 }

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/config-overlay.js

@@ -122,6 +122,7 @@ function collectConfigSections() {
             supRows.push({ label: "Model", value: sup.model });
         supRows.push({ label: "Soft timeout", value: `${sup.soft_timeout_minutes}m` });
         supRows.push({ label: "Idle timeout", value: `${sup.idle_timeout_minutes}m` });
+        supRows.push({ label: "Stalled tool timeout", value: `${sup.stalled_tool_timeout_minutes}m` });
         supRows.push({ label: "Hard timeout", value: `${sup.hard_timeout_minutes}m` });
         sections.push({ title: "Auto Supervisor", rows: supRows });
     }

package/dist/resources/extensions/gsd/context-masker.js

@@ -5,13 +5,36 @@
  * Reduces context bloat between compactions with zero LLM overhead.
  * Preserves message ordering, roles, and all assistant/user messages.
  *
- * Operates on the pi-ai Message[] format (post-convertToLlm, pre-provider):
+ * Operates on provider payloads after convertToLlm:
+ *
+ * pi-ai Message[] payloads:
  *   - toolResult messages: { role: "toolResult", content: TextContent[] }
  *   - bash results are already converted to: { role: "user", content: [{type:"text",text:"..."}] }
  *     and start with "Ran `" from bashExecutionToText.
+ *
+ * OpenAI/Codex Responses payloads:
+ *   - conversation items live in `input`, not `messages`
+ *   - tool results are { type: "function_call_output", output: string | content[] }
+ *   - bash results are user items with input_text content starting with "Ran `"
  */
 const MASK_PLACEHOLDER = "[result masked — within summarized history]";
 const MASK_CONTENT_BLOCK = [{ type: "text", text: MASK_PLACEHOLDER }];
+const RESPONSES_MASK_CONTENT_BLOCK = [{ type: "input_text", text: MASK_PLACEHOLDER }];
+const TRUNCATION_MARKER = "\n…[truncated]";
+function isTextLikeBlock(block) {
+    return Boolean(block && typeof block === "object" && "text" in block);
+}
+function firstTextFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return undefined;
+    const first = content.find(isTextLikeBlock);
+    return typeof first?.text === "string" ? first.text : undefined;
+}
+function isBashResultText(text) {
+    return typeof text === "string" && text.startsWith("Ran `");
+}
 function findTurnBoundary(messages, keepRecentTurns) {
     let turnsSeen = 0;
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -35,11 +58,9 @@ function findTurnBoundary(messages, keepRecentTurns) {
  * The bashExecutionToText format always starts with "Ran `".
  */
 function isBashResultUserMessage(m) {
-    if (m.role !== "user" || !Array.isArray(m.content))
+    if (m.role !== "user")
         return false;
-    const first = m.content[0];
-    return first && typeof first === "object" && "text" in first &&
-        typeof first.text === "string" && first.text.startsWith("Ran `");
+    return isBashResultText(firstTextFromContent(m.content));
 }
 function isMaskableMessage(m) {
     // Tool result messages (role: "toolResult" in pi-ai format)
@@ -66,3 +87,106 @@ export function createObservationMask(keepRecentTurns = 8) {
         });
     };
 }
+function isResponsesBashResultUserItem(item) {
+    if (item.role !== "user")
+        return false;
+    return isBashResultText(firstTextFromContent(item.content));
+}
+function findResponsesTurnBoundary(items, keepRecentTurns) {
+    let turnsSeen = 0;
+    for (let i = items.length - 1; i >= 0; i--) {
+        const item = items[i];
+        if (item.role === "user" && !isResponsesBashResultUserItem(item)) {
+            turnsSeen++;
+            if (turnsSeen >= keepRecentTurns)
+                return i;
+        }
+    }
+    return 0;
+}
+/**
+ * Observation masking for OpenAI/Codex Responses API payloads.
+ *
+ * Responses payloads store the conversation under `input` instead of
+ * `messages`, with tool results as `function_call_output` items. Keep this
+ * separate from createObservationMask so each payload shape stays explicit.
+ */
+export function createResponsesInputObservationMask(keepRecentTurns = 8) {
+    return (items) => {
+        const boundary = findResponsesTurnBoundary(items, keepRecentTurns);
+        if (boundary === 0)
+            return items;
+        return items.map((item, i) => {
+            if (i >= boundary)
+                return item;
+            if (item.type === "function_call_output") {
+                return { ...item, output: MASK_PLACEHOLDER };
+            }
+            if (isResponsesBashResultUserItem(item)) {
+                return { ...item, content: RESPONSES_MASK_CONTENT_BLOCK };
+            }
+            return item;
+        });
+    };
+}
+function truncateText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return text.slice(0, maxChars) + TRUNCATION_MARKER;
+}
+function truncateTextBlocks(content, maxChars) {
+    if (typeof content === "string") {
+        return truncateText(content, maxChars);
+    }
+    if (!Array.isArray(content))
+        return content;
+    let remaining = maxChars;
+    let didTruncate = false;
+    const nextBlocks = [];
+    for (const block of content) {
+        if (!isTextLikeBlock(block) || typeof block.text !== "string") {
+            nextBlocks.push(block);
+            continue;
+        }
+        if (remaining <= 0) {
+            didTruncate = true;
+            continue;
+        }
+        const text = block.text;
+        if (text.length <= remaining) {
+            nextBlocks.push(block);
+            remaining -= text.length;
+            continue;
+        }
+        nextBlocks.push({ ...block, text: truncateText(text, remaining) });
+        remaining = 0;
+        didTruncate = true;
+    }
+    return didTruncate ? nextBlocks : content;
+}
+function normalizedMaxChars(maxChars) {
+    return Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : 800;
+}
+export function truncateContextResultMessages(messages, maxChars = 800) {
+    const limit = normalizedMaxChars(maxChars);
+    return messages.map((message) => {
+        if (!isMaskableMessage(message))
+            return message;
+        const content = truncateTextBlocks(message.content, limit);
+        return content === message.content ? message : { ...message, content };
+    });
+}
+export function truncateResponsesInputResultItems(items, maxChars = 800) {
+    const limit = normalizedMaxChars(maxChars);
+    return items.map((item) => {
+        if (item.type === "function_call_output") {
+            const output = truncateTextBlocks(item.output, limit);
+            return output === item.output ? item : { ...item, output };
+        }
+        if (isResponsesBashResultUserItem(item)) {
+            const content = truncateTextBlocks(item.content, limit);
+            return content === item.content ? item : { ...item, content };
+        }
+        return item;
+    });
+}

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().

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -104,14 +104,22 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `language`: preferred response language for all GSD interactions. Accepts any language name or code — `"Chinese"`, `"zh"`, `"German"`, `"de"`, `"日本語"`, etc. When set, GSD injects "Always respond in \<language\>" into every agent's system prompt, including after `/clear`. Quickest way to set it: `/gsd language <name>`. To clear: `/gsd language off`.
 
-- `models`: per-stage model selection (applies to both auto-mode and guided-flow dispatches). Keys: `research`, `planning`, `discuss`, `execution`, `execution_simple`, `completion`, `validation`, `subagent`. Values can be:
+- `models`: per-stage model selection (applies to both auto-mode and guided-flow dispatches). Keys: `research`, `planning`, `discuss`, `execution`, `execution_simple`, `completion`, `validation`, `subagent`, `uat`. Values can be:
   - Simple string: `"claude-sonnet-4-6"` — single model, no fallbacks
   - Provider-qualified string: `"bedrock/claude-sonnet-4-6"` — targets a specific provider when the same model ID exists across multiple providers
   - Object with fallbacks: `{ model: "claude-opus-4-6", fallbacks: ["glm-5", "minimax-m2.5"] }` — tries fallbacks in order if primary fails
   - Object with provider: `{ model: "claude-opus-4-6", provider: "bedrock" }` — explicit provider targeting in object format
+  - Object with thinking: `{ model: "claude-opus-4-6", thinking: "xhigh" }` — pins the reasoning effort for that phase (see `thinking` below)
   - Omit a key to use whatever model is currently active (except `discuss` and `validation` which fall back to `planning` when unset). Fallbacks are tried when model switching fails (provider unavailable, rate limited, etc.).
   - `discuss` — used for milestone/slice discussion (interactive context gathering). Falls back to `planning` if unset.
   - `validation` — used for gate evaluation, roadmap reassessment, milestone validation, and doc rewrites. Falls back to `planning` if unset.
+  - `uat` — used for UAT runs. Falls back to `completion` if unset.
+
+- `thinking`: per-phase reasoning effort (ADR-026), separate from `models`. Same phase keys as `models`. Values: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`. Thinking travels with the model — model choice and reasoning effort are independent controls, so you can run one model across phases at different reasoning levels.
+  - Two equivalent ways to set it: inline as `models.<phase>.thinking`, or as a separate `thinking:` block keyed by phase. For the same phase, the inline value wins over the block; project preferences win over global; a phase that's unset inherits via the same sibling chain as `models` (e.g. `discuss → planning`).
+  - If no thinking is configured for a phase, the session level (set via `/model`) is used, exactly as before — this is fully backward-compatible.
+  - `execute-task` (code-writing) has a measured reasoning floor of `medium`: at lower levels models stop planning edits and thrash on file re-reads. The floor applies to the session/default path. An **explicit** `execution` thinking level bypasses the floor and is honored verbatim (with a one-time advisory) — set `execution: low` deliberately if you want it.
+  - Levels a model can't support are clamped to the nearest supported level at dispatch and never sent to the provider, so a model/level mismatch never fails a unit mid-run. `xhigh` is only honored by select model families.
 
 - `skill_staleness_days`: number — skills unused for this many days get deprioritized during discovery. Set to `0` to disable staleness tracking. Default: `60`.
 
@@ -448,6 +456,47 @@ models:
 ---
 ```
 
+## Per-Phase Thinking Level Example
+
+Model choice and reasoning effort are independent controls (ADR-026). You can use one model across phases at different reasoning levels, or mix per-phase models with per-phase thinking.
+
+Inline form — thinking pinned alongside the model:
+
+```yaml
+---
+version: 1
+models:
+  planning:
+    model: openai-codex/gpt-5.4
+    thinking: xhigh
+  execution:
+    model: openai-codex/gpt-5.4
+    thinking: low      # explicit → bypasses the execute-task medium floor
+  validation:
+    model: openai-codex/gpt-5.4
+    thinking: high
+---
+```
+
+Separate-block form — set thinking without pinning a model (the session model is used):
+
+```yaml
+---
+version: 1
+thinking:
+  research: medium
+  planning: xhigh
+  discuss: high
+  execution: low
+  execution_simple: low
+  completion: medium
+  validation: high
+  uat: medium
+---
+```
+
+For a single phase, an inline `models.<phase>.thinking` value wins over the same phase in the `thinking:` block; project preferences win over global. Unsupported levels are clamped to the nearest level the resolved model supports.
+
 When a model fails to switch (provider unavailable, rate limited, credits exhausted), GSD automatically tries the next model in the `fallbacks` list. This ensures auto-mode continues even when your preferred provider hits limits.
 
 ## Provider Targeting