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

package/src/resources/extensions/gsd/closeout-wizard.ts

@@ -5,6 +5,7 @@ import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
 
 import type { NextAction } from "../shared/next-action-ui.js";
 import type { GSDState } from "./types.js";
+import { setAutoOutcomeWidget } from "./auto-dashboard.js";
 import { invalidateAllCaches } from "./cache.js";
 import { mergeCompletedMilestone } from "./parallel-merge.js";
 import { cleanupQuickBranch, detectStrandedQuickBranch, type StrandedQuickBranch } from "./quick.js";
@@ -21,6 +22,13 @@ export interface CloseoutContext {
   unmergedMilestones: UnmergedMilestoneBlocker[];
 }
 
+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: string): Promise<CloseoutContext> {
   const unmergedMilestones = await findUnmergedCompletedMilestones(basePath);
   return {
@@ -91,6 +99,23 @@ export function buildIdleMenuSummary(state: GSDState, closeout: CloseoutContext)
   return [state.nextAction || "No active milestone."];
 }
 
+export function showMilestoneMergeCloseout(
+  ctx: ExtensionCommandContext,
+  blocker: UnmergedMilestoneBlocker,
+): void {
+  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: ExtensionCommandContext,
   basePath: string,
@@ -113,31 +138,23 @@ export async function runMergeQuickTask(
   return false;
 }
 
-export async function runMergeMilestone(
+export async function runMergeMilestoneBlocker(
   ctx: ExtensionCommandContext,
   basePath: string,
-  milestoneId?: string,
+  blocker: UnmergedMilestoneBlocker,
 ): Promise<boolean> {
-  const blockers = await findUnmergedCompletedMilestones(basePath);
-  const blocker = milestoneId
-    ? blockers.find((candidate) => candidate.milestoneId === milestoneId)
-    : blockers[0];
-  if (!blocker) {
-    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) {
+    invalidateAllCaches();
+    showMilestoneMergeCloseout(ctx, blocker);
     ctx.ui.notify(
-      `Milestone ${blocker.milestoneId} merged to ${blocker.integrationBranch}. Run /gsd again when ready.`,
+      `Milestone ${blocker.milestoneId} merged to ${blocker.integrationBranch}. Closeout is complete.`,
       "info",
     );
-    invalidateAllCaches();
     return true;
   }
 
@@ -148,6 +165,23 @@ export async function runMergeMilestone(
   return false;
 }
 
+export async function runMergeMilestone(
+  ctx: ExtensionCommandContext,
+  basePath: string,
+  milestoneId?: string,
+): Promise<boolean> {
+  const blockers = await findUnmergedCompletedMilestones(basePath);
+  const blocker = milestoneId
+    ? blockers.find((candidate) => candidate.milestoneId === milestoneId)
+    : blockers[0];
+  if (!blocker) {
+    ctx.ui.notify("No unmerged completed milestone found.", "warning");
+    return false;
+  }
+
+  return runMergeMilestoneBlocker(ctx, basePath, blocker);
+}
+
 export async function handleCloseoutChoice(
   ctx: ExtensionCommandContext,
   basePath: string,

package/src/resources/extensions/gsd/commands/handlers/auto.ts

@@ -209,6 +209,15 @@ export async function handleAutoCommand(trimmed: string, ctx: ExtensionCommandCo
   if (trimmed === "") {
     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/src/resources/extensions/gsd/commands/handlers/ops.ts

@@ -19,7 +19,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: string,
@@ -37,22 +37,7 @@ async function handleCompletedMilestoneRecovery(
     : 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;
 }
 

package/src/resources/extensions/gsd/commands-maintenance.ts

@@ -481,6 +481,8 @@ export async function handleCleanupProjects(args: string, ctx: ExtensionCommandC
   ctx.ui.notify(lines.join("\n"), "info");
 }
 
+type HierarchyCounts = { milestones: number; slices: number; tasks: number };
+
 function recoverConfirmed(args: string): boolean {
   return args
     .split(/\s+/)
@@ -488,27 +490,82 @@ function recoverConfirmed(args: string): boolean {
     .some((part) => part === "--confirm" || part === "--yes" || part === "confirm");
 }
 
-async function confirmRecover(ctx: ExtensionCommandContext, args: string): Promise<boolean> {
-  if (recoverConfirmed(args)) return true;
+function recoverAllowsDataLoss(args: string): boolean {
+  return args
+    .split(/\s+/)
+    .map((part) => part.trim().toLowerCase())
+    .some((part) => part === "--allow-data-loss" || part === "--force");
+}
 
+async function confirmRecover(
+  ctx: ExtensionCommandContext,
+  args: string,
+  markdown: HierarchyCounts,
+  beforeDb: HierarchyCounts,
+  dataLoss: boolean,
+): Promise<boolean> {
   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.`,
+      `${warningText}\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;
+    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.`,
+    `${warningText}\n\nNo database changes made. Re-run /gsd recover --confirm to proceed.`,
     "warning",
   );
   return false;
@@ -524,18 +581,31 @@ async function confirmRecover(ctx: ExtensionCommandContext, args: string): Promi
  * Prints counts of recovered items and the resulting project phase.
  */
 export async function handleRecover(ctx: ExtensionCommandContext, basePath: string, args = ""): Promise<void> {
-  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))) return;
+  // 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
@@ -545,9 +615,16 @@ export async function handleRecover(ctx: ExtensionCommandContext, basePath: stri
       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);
 
@@ -560,6 +637,23 @@ export async function handleRecover(ctx: ExtensionCommandContext, basePath: stri
       ``,
       `  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}`);
     }
@@ -570,10 +664,27 @@ export async function handleRecover(ctx: ExtensionCommandContext, basePath: stri
       lines.push(`  Task:       ${state.activeTask.id}: ${state.activeTask.title}`);
     }
 
+    // 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\n`,
+      `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"), "success");
+    ctx.ui.notify(lines.join("\n"), renderFailed ? "warning" : "success");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     logWarning("command", `recover failed: ${msg}`);

package/src/resources/extensions/gsd/commands-mcp-status.ts

@@ -73,7 +73,7 @@ export function formatMcpInitResult(
     `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/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -1285,7 +1285,7 @@ async function configureHooks(ctx: ExtensionCommandContext, prefs: Record<string
   if (geEnabled !== undefined) ge.enabled = geEnabled;
   const currentSliceGates = Array.isArray(ge.slice_gates) ? ge.slice_gates as string[] : [];
   const sgInput = await ctx.ui.input(
-    `Slice gates to evaluate (comma-separated, blank keeps)${currentSliceGates.length ? ` (current: ${currentSliceGates.join(", ")})` : " (default: Q3,Q4)"}:`,
+    `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) {
@@ -1751,7 +1751,7 @@ export function serializePreferencesToFrontmatter(prefs: Record<string, unknown>
   // 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/src/resources/extensions/gsd/config-overlay.ts

@@ -139,6 +139,7 @@ function collectConfigSections(): ConfigSection[] {
     if (sup.model) 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/src/resources/extensions/gsd/context-masker.ts

@@ -5,10 +5,17 @@
  * 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 `"
  */
 
 interface MaskableMessage {
@@ -20,6 +27,37 @@ interface MaskableMessage {
 
 const MASK_PLACEHOLDER = "[result masked — within summarized history]";
 const MASK_CONTENT_BLOCK = [{ type: "text" as const, text: MASK_PLACEHOLDER }];
+const RESPONSES_MASK_CONTENT_BLOCK = [{ type: "input_text" as const, text: MASK_PLACEHOLDER }];
+const TRUNCATION_MARKER = "\n…[truncated]";
+
+type TextLikeBlock = {
+  type?: string;
+  text?: unknown;
+  [key: string]: unknown;
+};
+
+interface ResponsesInputItem {
+  role?: string;
+  type?: string;
+  content?: unknown;
+  output?: unknown;
+  [key: string]: unknown;
+}
+
+function isTextLikeBlock(block: unknown): block is TextLikeBlock {
+  return Boolean(block && typeof block === "object" && "text" in block);
+}
+
+function firstTextFromContent(content: unknown): string | undefined {
+  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: string | undefined): boolean {
+  return typeof text === "string" && text.startsWith("Ran `");
+}
 
 function findTurnBoundary(messages: MaskableMessage[], keepRecentTurns: number): number {
   let turnsSeen = 0;
@@ -43,10 +81,8 @@ function findTurnBoundary(messages: MaskableMessage[], keepRecentTurns: number):
  * The bashExecutionToText format always starts with "Ran `".
  */
 function isBashResultUserMessage(m: MaskableMessage): boolean {
-  if (m.role !== "user" || !Array.isArray(m.content)) return false;
-  const first = m.content[0];
-  return first && typeof first === "object" && "text" in first &&
-    typeof first.text === "string" && first.text.startsWith("Ran `");
+  if (m.role !== "user") return false;
+  return isBashResultText(firstTextFromContent(m.content));
 }
 
 function isMaskableMessage(m: MaskableMessage): boolean {
@@ -72,3 +108,114 @@ export function createObservationMask(keepRecentTurns: number = 8) {
     });
   };
 }
+
+function isResponsesBashResultUserItem(item: ResponsesInputItem): boolean {
+  if (item.role !== "user") return false;
+  return isBashResultText(firstTextFromContent(item.content));
+}
+
+function findResponsesTurnBoundary(items: ResponsesInputItem[], keepRecentTurns: number): number {
+  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: number = 8) {
+  return (items: ResponsesInputItem[]): ResponsesInputItem[] => {
+    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: string, maxChars: number): string {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + TRUNCATION_MARKER;
+}
+
+function truncateTextBlocks(content: unknown, maxChars: number): unknown {
+  if (typeof content === "string") {
+    return truncateText(content, maxChars);
+  }
+  if (!Array.isArray(content)) return content;
+
+  let remaining = maxChars;
+  let didTruncate = false;
+  const nextBlocks: unknown[] = [];
+
+  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: number): number {
+  return Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : 800;
+}
+
+export function truncateContextResultMessages(messages: MaskableMessage[], maxChars: number = 800): MaskableMessage[] {
+  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: ResponsesInputItem[], maxChars: number = 800): ResponsesInputItem[] {
+  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/src/resources/extensions/gsd/db-writer.ts

@@ -452,6 +452,44 @@ export function _resetDecisionSaveLock(): void {
   _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: string): Promise<void> {
+  const { getAllDecisionsFromMemories } = await import('./context-store.js');
+  const allDecisions: Decision[] = getAllDecisionsFromMemories();
+
+  const filePath = resolveGsdRootFile(basePath, 'DECISIONS');
+  let existingContent: string | null = 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: string;
+  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 Decision to DB + Regenerate Markdown ────────────────────────────
 
 export interface SaveDecisionFields {