gsd-pi 2.16.0 → 2.17.0

package/dist/resources/extensions/gsd/auto-dashboard.ts

@@ -35,6 +35,10 @@ export interface AutoDashboardData {
   /** Running cost and token totals from metrics ledger */
   totalCost: number;
   totalTokens: number;
+  /** Projected remaining cost based on unit-type averages (undefined if insufficient data) */
+  projectedRemainingCost?: number;
+  /** Whether token profile has been auto-downgraded due to budget prediction */
+  profileDowngraded?: boolean;
 }
 
 // ─── Unit Description Helpers ─────────────────────────────────────────────────

package/dist/resources/extensions/gsd/auto-dispatch.ts

@@ -122,7 +122,9 @@ const DISPATCH_RULES: DispatchRule[] = [
   },
   {
     name: "reassess-roadmap (post-completion)",
-    match: async ({ state, mid, midTitle, basePath }) => {
+    match: async ({ state, mid, midTitle, basePath, prefs }) => {
+      // Phase skip: skip reassess when preference or profile says so
+      if (prefs?.phases?.skip_reassess) return null;
       const needsReassess = await checkNeedsReassessment(basePath, mid, state);
       if (!needsReassess) return null;
       return {
@@ -160,8 +162,10 @@ const DISPATCH_RULES: DispatchRule[] = [
   },
   {
     name: "pre-planning (no research) → research-milestone",
-    match: async ({ state, mid, midTitle, basePath }) => {
+    match: async ({ state, mid, midTitle, basePath, prefs }) => {
       if (state.phase !== "pre-planning") return null;
+      // Phase skip: skip research when preference or profile says so
+      if (prefs?.phases?.skip_research) return null;
       const researchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
       if (researchFile) return null; // has research, fall through
       return {
@@ -186,8 +190,10 @@ const DISPATCH_RULES: DispatchRule[] = [
   },
   {
     name: "planning (no research, not S01) → research-slice",
-    match: async ({ state, mid, midTitle, basePath }) => {
+    match: async ({ state, mid, midTitle, basePath, prefs }) => {
       if (state.phase !== "planning") return null;
+      // Phase skip: skip research when preference or profile says so
+      if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research) return null;
       const sid = state.activeSlice!.id;
       const sTitle = state.activeSlice!.title;
       const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");

package/dist/resources/extensions/gsd/auto-prompts.ts

@@ -15,8 +15,8 @@ import {
   relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath,
   resolveGsdRootFile, relGsdRootFile,
 } from "./paths.js";
-import { resolveSkillDiscoveryMode } from "./preferences.js";
-import type { GSDState } from "./types.js";
+import { resolveSkillDiscoveryMode, resolveInlineLevel } from "./preferences.js";
+import type { GSDState, InlineLevel } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
@@ -393,7 +393,8 @@ export async function buildResearchMilestonePrompt(mid: string, midTitle: string
   });
 }
 
-export async function buildPlanMilestonePrompt(mid: string, midTitle: string, base: string): Promise<string> {
+export async function buildPlanMilestonePrompt(mid: string, midTitle: string, base: string, level?: InlineLevel): Promise<string> {
+  const inlineLevel = level ?? resolveInlineLevel();
   const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
   const contextRel = relMilestoneFile(base, mid, "CONTEXT");
   const researchPath = resolveMilestoneFile(base, mid, "RESEARCH");
@@ -406,17 +407,23 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
   const { inlinePriorMilestoneSummary } = await import("./files.js");
   const priorSummaryInline = await inlinePriorMilestoneSummary(mid, base);
   if (priorSummaryInline) inlined.push(priorSummaryInline);
-  const projectInline = await inlineGsdRootFile(base, "project.md", "Project");
+  const projectInline = inlineLevel !== "minimal" ? await inlineGsdRootFile(base, "project.md", "Project") : null;
   if (projectInline) inlined.push(projectInline);
-  const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+  const requirementsInline = inlineLevel !== "minimal" ? await inlineGsdRootFile(base, "requirements.md", "Requirements") : null;
   if (requirementsInline) inlined.push(requirementsInline);
-  const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+  const decisionsInline = inlineLevel !== "minimal" ? await inlineGsdRootFile(base, "decisions.md", "Decisions") : null;
   if (decisionsInline) inlined.push(decisionsInline);
   inlined.push(inlineTemplate("roadmap", "Roadmap"));
-  inlined.push(inlineTemplate("decisions", "Decisions"));
-  inlined.push(inlineTemplate("plan", "Slice Plan"));
-  inlined.push(inlineTemplate("task-plan", "Task Plan"));
-  inlined.push(inlineTemplate("secrets-manifest", "Secrets Manifest"));
+  if (inlineLevel === "full") {
+    inlined.push(inlineTemplate("decisions", "Decisions"));
+    inlined.push(inlineTemplate("plan", "Slice Plan"));
+    inlined.push(inlineTemplate("task-plan", "Task Plan"));
+    inlined.push(inlineTemplate("secrets-manifest", "Secrets Manifest"));
+  } else if (inlineLevel === "standard") {
+    inlined.push(inlineTemplate("decisions", "Decisions"));
+    inlined.push(inlineTemplate("plan", "Slice Plan"));
+    inlined.push(inlineTemplate("task-plan", "Task Plan"));
+  }
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
@@ -479,8 +486,9 @@ export async function buildResearchSlicePrompt(
 }
 
 export async function buildPlanSlicePrompt(
-  mid: string, _midTitle: string, sid: string, sTitle: string, base: string,
+  mid: string, _midTitle: string, sid: string, sTitle: string, base: string, level?: InlineLevel,
 ): Promise<string> {
+  const inlineLevel = level ?? resolveInlineLevel();
   const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
   const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
   const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
@@ -490,12 +498,16 @@ export async function buildPlanSlicePrompt(
   inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
   const researchInline = await inlineFileOptional(researchPath, researchRel, "Slice Research");
   if (researchInline) inlined.push(researchInline);
-  const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
-  if (decisionsInline) inlined.push(decisionsInline);
-  const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
-  if (requirementsInline) inlined.push(requirementsInline);
+  if (inlineLevel !== "minimal") {
+    const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+    if (decisionsInline) inlined.push(decisionsInline);
+    const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+    if (requirementsInline) inlined.push(requirementsInline);
+  }
   inlined.push(inlineTemplate("plan", "Slice Plan"));
-  inlined.push(inlineTemplate("task-plan", "Task Plan"));
+  if (inlineLevel === "full") {
+    inlined.push(inlineTemplate("task-plan", "Task Plan"));
+  }
 
   const depContent = await inlineDependencySummaries(mid, sid, base);
   const planActiveOverrides = await loadActiveOverrides(base);
@@ -519,8 +531,9 @@ export async function buildPlanSlicePrompt(
 
 export async function buildExecuteTaskPrompt(
   mid: string, sid: string, sTitle: string,
-  tid: string, tTitle: string, base: string,
+  tid: string, tTitle: string, base: string, level?: InlineLevel,
 ): Promise<string> {
+  const inlineLevel = level ?? resolveInlineLevel();
 
   const priorSummaries = await getPriorTaskSummaryPaths(mid, sid, tid, base);
   const priorLines = priorSummaries.length > 0
@@ -560,11 +573,17 @@ export async function buildExecuteTaskPrompt(
     legacyContinuePath ? `${relSlicePath(base, mid, sid)}/continue.md` : null,
   );
 
-  const carryForwardSection = await buildCarryForwardSection(priorSummaries, base);
-  const inlinedTemplates = [
-    inlineTemplate("task-summary", "Task Summary"),
-    inlineTemplate("decisions", "Decisions"),
-  ].join("\n\n---\n\n");
+  // For minimal inline level, only carry forward the most recent prior summary
+  const effectivePriorSummaries = inlineLevel === "minimal" && priorSummaries.length > 1
+    ? priorSummaries.slice(-1)
+    : priorSummaries;
+  const carryForwardSection = await buildCarryForwardSection(effectivePriorSummaries, base);
+  const inlinedTemplates = inlineLevel === "minimal"
+    ? inlineTemplate("task-summary", "Task Summary")
+    : [
+        inlineTemplate("task-summary", "Task Summary"),
+        inlineTemplate("decisions", "Decisions"),
+      ].join("\n\n---\n\n");
 
   const taskSummaryPath = `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`;
 
@@ -589,8 +608,9 @@ export async function buildExecuteTaskPrompt(
 }
 
 export async function buildCompleteSlicePrompt(
-  mid: string, _midTitle: string, sid: string, sTitle: string, base: string,
+  mid: string, _midTitle: string, sid: string, sTitle: string, base: string, level?: InlineLevel,
 ): Promise<string> {
+  const inlineLevel = level ?? resolveInlineLevel();
 
   const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
   const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
@@ -600,8 +620,10 @@ export async function buildCompleteSlicePrompt(
   const inlined: string[] = [];
   inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
   inlined.push(await inlineFile(slicePlanPath, slicePlanRel, "Slice Plan"));
-  const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
-  if (requirementsInline) inlined.push(requirementsInline);
+  if (inlineLevel !== "minimal") {
+    const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+    if (requirementsInline) inlined.push(requirementsInline);
+  }
 
   // Inline all task summaries for this slice
   const tDir = resolveTasksDir(base, mid, sid);
@@ -618,7 +640,9 @@ export async function buildCompleteSlicePrompt(
     }
   }
   inlined.push(inlineTemplate("slice-summary", "Slice Summary"));
-  inlined.push(inlineTemplate("uat", "UAT"));
+  if (inlineLevel !== "minimal") {
+    inlined.push(inlineTemplate("uat", "UAT"));
+  }
   const completeActiveOverrides = await loadActiveOverrides(base);
   const completeOverridesInline = formatOverridesSection(completeActiveOverrides);
   if (completeOverridesInline) inlined.unshift(completeOverridesInline);
@@ -641,8 +665,9 @@ export async function buildCompleteSlicePrompt(
 }
 
 export async function buildCompleteMilestonePrompt(
-  mid: string, midTitle: string, base: string,
+  mid: string, midTitle: string, base: string, level?: InlineLevel,
 ): Promise<string> {
+  const inlineLevel = level ?? resolveInlineLevel();
   const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
   const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
 
@@ -663,13 +688,15 @@ export async function buildCompleteMilestonePrompt(
     }
   }
 
-  // Inline root GSD files
-  const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
-  if (requirementsInline) inlined.push(requirementsInline);
-  const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
-  if (decisionsInline) inlined.push(decisionsInline);
-  const projectInline = await inlineGsdRootFile(base, "project.md", "Project");
-  if (projectInline) inlined.push(projectInline);
+  // Inline root GSD files (skip for minimal — completion can read these if needed)
+  if (inlineLevel !== "minimal") {
+    const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+    if (requirementsInline) inlined.push(requirementsInline);
+    const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+    if (decisionsInline) inlined.push(decisionsInline);
+    const projectInline = await inlineGsdRootFile(base, "project.md", "Project");
+    if (projectInline) inlined.push(projectInline);
+  }
   // Inline milestone context file (milestone-level, not GSD root)
   const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
   const contextRel = relMilestoneFile(base, mid, "CONTEXT");
@@ -779,8 +806,9 @@ export async function buildRunUatPrompt(
 }
 
 export async function buildReassessRoadmapPrompt(
-  mid: string, midTitle: string, completedSliceId: string, base: string,
+  mid: string, midTitle: string, completedSliceId: string, base: string, level?: InlineLevel,
 ): Promise<string> {
+  const inlineLevel = level ?? resolveInlineLevel();
   const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
   const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
   const summaryPath = resolveSliceFile(base, mid, completedSliceId, "SUMMARY");
@@ -789,12 +817,14 @@ export async function buildReassessRoadmapPrompt(
   const inlined: string[] = [];
   inlined.push(await inlineFile(roadmapPath, roadmapRel, "Current Roadmap"));
   inlined.push(await inlineFile(summaryPath, summaryRel, `${completedSliceId} Summary`));
-  const projectInline = await inlineGsdRootFile(base, "project.md", "Project");
-  if (projectInline) inlined.push(projectInline);
-  const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
-  if (requirementsInline) inlined.push(requirementsInline);
-  const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
-  if (decisionsInline) inlined.push(decisionsInline);
+  if (inlineLevel !== "minimal") {
+    const projectInline = await inlineGsdRootFile(base, "project.md", "Project");
+    if (projectInline) inlined.push(projectInline);
+    const requirementsInline = await inlineGsdRootFile(base, "requirements.md", "Requirements");
+    if (requirementsInline) inlined.push(requirementsInline);
+    const decisionsInline = await inlineGsdRootFile(base, "decisions.md", "Decisions");
+    if (decisionsInline) inlined.push(decisionsInline);
+  }
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 

package/dist/resources/extensions/gsd/auto-recovery.ts

@@ -11,6 +11,7 @@ import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import {
   clearUnitRuntimeRecord,
 } from "./unit-runtime.js";
+import { clearParseCache } from "./files.js";
 import {
   nativeConflictFiles,
   nativeCommit,
@@ -107,9 +108,13 @@ export function verifyExpectedArtifact(unitType: string, unitId: string, base: s
   // is managed by the hook engine, not the artifact verification system.
   if (unitType.startsWith("hook/")) return true;
 
-  // Clear stale directory listing cache so artifact checks see fresh disk state (#431).
-  // Moved after hook check to avoid unnecessary cache clears for hook units.
+  // Clear stale directory listing cache AND parse cache so artifact checks see
+  // fresh disk state (#431). The parse cache must also be cleared because
+  // cacheKey() uses length + first/last 100 chars — when a checkbox changes
+  // from [ ] to [x], the key collides with the pre-edit version, returning
+  // stale parsed results (e.g., slice.done = false when it's actually true).
   clearPathCache();
+  clearParseCache();
 
   if (unitType === "rewrite-docs") {
     const overridesPath = resolveGsdRootFile(base, "OVERRIDES");

package/dist/resources/extensions/gsd/auto.ts

@@ -293,6 +293,41 @@ export function isAutoPaused(): boolean {
   return paused;
 }
 
+/**
+ * Return the base path to use for the auto.lock file.
+ * Always uses the original project root (not the worktree) so that
+ * a second terminal can discover and stop a running auto-mode session.
+ */
+function lockBase(): string {
+  return originalBasePath || basePath;
+}
+
+/**
+ * Attempt to stop a running auto-mode session from a different process.
+ * Reads the lock file at the project root, checks if the PID is alive,
+ * and sends SIGTERM to gracefully stop it.
+ *
+ * Returns true if a remote session was found and signaled, false otherwise.
+ */
+export function stopAutoRemote(projectRoot: string): { found: boolean; pid?: number; error?: string } {
+  const lock = readCrashLock(projectRoot);
+  if (!lock) return { found: false };
+
+  if (!isLockProcessAlive(lock)) {
+    // Stale lock — clean it up
+    clearLock(projectRoot);
+    return { found: false };
+  }
+
+  // Send SIGTERM — the auto-mode process has a handler that clears the lock and exits
+  try {
+    process.kill(lock.pid, "SIGTERM");
+    return { found: true, pid: lock.pid };
+  } catch (err) {
+    return { found: false, error: (err as Error).message };
+  }
+}
+
 export function isStepMode(): boolean {
   return stepMode;
 }
@@ -371,7 +406,7 @@ function startDispatchGapWatchdog(ctx: ExtensionContext, pi: ExtensionAPI): void
 export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promise<void> {
   if (!active && !paused) return;
   clearUnitTimeout();
-  if (basePath) clearLock(basePath);
+  if (lockBase()) clearLock(lockBase());
   clearSkillSnapshot();
   _dispatching = false;
   _skipDepth = 0;
@@ -454,7 +489,7 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
 export async function pauseAuto(ctx?: ExtensionContext, _pi?: ExtensionAPI): Promise<void> {
   if (!active) return;
   clearUnitTimeout();
-  if (basePath) clearLock(basePath);
+  if (lockBase()) clearLock(lockBase());
 
   // Remove SIGTERM handler registered at auto-mode start
   deregisterSigtermHandler();
@@ -527,8 +562,8 @@ export async function startAuto(
       }
     }
 
-    // Re-register SIGTERM handler for the resumed session
-    registerSigtermHandler(basePath);
+    // Re-register SIGTERM handler for the resumed session (use original base for lock)
+    registerSigtermHandler(lockBase());
 
     ctx.ui.setStatus("gsd-auto", stepMode ? "next" : "auto");
     ctx.ui.setFooter(hideFooter);
@@ -557,17 +592,21 @@ export async function startAuto(
   }
 
   // Ensure .gitignore has baseline patterns
-  ensureGitignore(base);
+  const commitDocs = loadEffectiveGSDPreferences()?.preferences?.git?.commit_docs;
+  ensureGitignore(base, { commitDocs });
   untrackRuntimeFiles(base);
 
   // Bootstrap .gsd/ if it doesn't exist
   const gsdDir = join(base, ".gsd");
   if (!existsSync(gsdDir)) {
     mkdirSync(join(gsdDir, "milestones"), { recursive: true });
-    try {
-      nativeAddPaths(base, [".gsd", ".gitignore"]);
-      nativeCommit(base, "chore: init gsd");
-    } catch { /* nothing to commit */ }
+    // Only commit .gsd/ init when commit_docs is not explicitly false
+    if (commitDocs !== false) {
+      try {
+        nativeAddPaths(base, [".gsd", ".gitignore"]);
+        nativeCommit(base, "chore: init gsd");
+      } catch { /* nothing to commit */ }
+    }
   }
 
   // Initialize GitServiceImpl — basePath is set and git repo confirmed
@@ -658,7 +697,7 @@ export async function startAuto(
   // of the repo's default (main/master). Idempotent when the branch is the
   // same; updates the record when started from a different branch (#300).
   if (currentMilestoneId) {
-    captureIntegrationBranch(base, currentMilestoneId);
+    captureIntegrationBranch(base, currentMilestoneId, { commitDocs });
     setActiveMilestoneId(base, currentMilestoneId);
   }
 
@@ -695,8 +734,8 @@ export async function startAuto(
         gitService = new GitServiceImpl(basePath, loadEffectiveGSDPreferences()?.preferences?.git ?? {});
         ctx.ui.notify(`Created auto-worktree at ${wtPath}`, "info");
       }
-      // Re-register SIGTERM handler with the new basePath
-      registerSigtermHandler(basePath);
+      // Re-register SIGTERM handler with the original basePath (lock lives there)
+      registerSigtermHandler(originalBasePath);
     } catch (err) {
       // Worktree creation is non-fatal — continue in the project root.
       ctx.ui.notify(
@@ -952,7 +991,7 @@ export async function handleAgentEnd(
         return;
       }
       const sessionFile = ctx.sessionManager.getSessionFile();
-      writeLock(basePath, hookUnit.unitType, hookUnit.unitId, completedUnits.length, sessionFile);
+      writeLock(lockBase(), hookUnit.unitType, hookUnit.unitId, completedUnits.length, sessionFile);
       // Persist hook state so cycle counts survive crashes
       persistHookState(basePath);
 
@@ -1211,7 +1250,7 @@ async function dispatchNextUnit(
     unitRecoveryCount.clear();
     unitLifetimeDispatches.clear();
     // Capture integration branch for the new milestone and update git service
-    captureIntegrationBranch(originalBasePath || basePath, mid);
+    captureIntegrationBranch(originalBasePath || basePath, mid, { commitDocs: loadEffectiveGSDPreferences()?.preferences?.git?.commit_docs });
   }
   if (mid) {
     currentMilestoneId = mid;
@@ -1758,7 +1797,7 @@ async function dispatchNextUnit(
   // Pi appends entries incrementally via appendFileSync, so on crash the
   // session file survives with every tool call up to the crash point.
   const sessionFile = ctx.sessionManager.getSessionFile();
-  writeLock(basePath, unitType, unitId, completedUnits.length, sessionFile);
+  writeLock(lockBase(), unitType, unitId, completedUnits.length, sessionFile);
 
   // On crash recovery, prepend the full recovery briefing
   // On retry (stuck detection), prepend deep diagnostic from last attempt

package/dist/resources/extensions/gsd/commands.ts

@@ -12,7 +12,7 @@ import { fileURLToPath } from "node:url";
 import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
 import { showQueue, showDiscuss } from "./guided-flow.js";
-import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode } from "./auto.js";
+import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode, stopAutoRemote } from "./auto.js";
 import {
   getGlobalGSDPreferencesPath,
   getLegacyGlobalGSDPreferencesPath,
@@ -178,7 +178,15 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
 
       if (trimmed === "stop") {
         if (!isAutoActive() && !isAutoPaused()) {
-          ctx.ui.notify("Auto-mode is not running.", "info");
+          // Not running in this process — check for a remote auto-mode session
+          const result = stopAutoRemote(process.cwd());
+          if (result.found) {
+            ctx.ui.notify(`Sent stop signal to auto-mode session (PID ${result.pid}). It will shut down gracefully.`, "info");
+          } else if (result.error) {
+            ctx.ui.notify(`Failed to stop remote auto-mode: ${result.error}`, "error");
+          } else {
+            ctx.ui.notify("Auto-mode is not running.", "info");
+          }
           return;
         }
         await stopAuto(ctx, pi);
@@ -502,6 +510,16 @@ async function handlePrefsWizard(
       delete git.main_branch;
     }
   }
+  // ─── Git commit_docs ────────────────────────────────────────────────────
+  const currentCommitDocs = git.commit_docs;
+  const commitDocsChoice = await ctx.ui.select(
+    `Track .gsd/ planning docs in git${currentCommitDocs !== undefined ? ` (current: ${currentCommitDocs})` : ""}:`,
+    ["true", "false", "(keep current)"],
+  );
+  if (commitDocsChoice && commitDocsChoice !== "(keep current)") {
+    git.commit_docs = commitDocsChoice === "true";
+  }
+
   if (Object.keys(git).length > 0) {
     prefs.git = git;
   }