@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.738160b9

package/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -28,9 +28,10 @@ const DEFAULT_CODEBASE_MAX_CHARS = 8_000;
 const MIN_CONTEXT_MESSAGE_MAX_CHARS = 1_000;
 const MIN_KNOWLEDGE_MAX_CHARS = 1_000;
 
-const contextMaintenanceCompletedForBasePath = new Set<string>();
-const contextMaintenanceInFlightByBasePath = new Map<string, Promise<boolean>>();
-const deferredContextMaintenanceByBasePath = new Map<string, Promise<void>>();
+const CONTEXT_MAINTENANCE_KEY_SEPARATOR = "\0";
+const contextMaintenanceCompletedForSession = new Set<string>();
+const contextMaintenanceInFlightBySession = new Map<string, Promise<boolean>>();
+const deferredContextMaintenanceBySession = new Map<string, Promise<void>>();
 
 /**
  * Bundled skill triggers — resolved dynamically at runtime instead of
@@ -114,7 +115,8 @@ async function runSessionStartupMaintenanceOnce(
   basePath: string,
   ctx: ExtensionContext,
 ): Promise<boolean> {
-  if (contextMaintenanceCompletedForBasePath.has(basePath)) {
+  const maintenanceKey = getContextMaintenanceKey(basePath, ctx);
+  if (contextMaintenanceCompletedForSession.has(maintenanceKey)) {
     // Backfills are session-once, but memory queries and other DB-backed
     // prompt assembly still need an active adapter on every turn.
     try {
@@ -126,16 +128,16 @@ async function runSessionStartupMaintenanceOnce(
     return false;
   }
 
-  const existing = contextMaintenanceInFlightByBasePath.get(basePath);
+  const existing = contextMaintenanceInFlightBySession.get(maintenanceKey);
   const isInitiator = !existing;
   // Use a definite Promise<boolean> so `await inFlight` has a known return type.
   let inFlight: Promise<boolean>;
   if (isInitiator) {
-    inFlight = performSessionStartupMaintenance(basePath, ctx);
-    contextMaintenanceInFlightByBasePath.set(basePath, inFlight);
+    inFlight = performSessionStartupMaintenance(basePath, ctx, maintenanceKey);
+    contextMaintenanceInFlightBySession.set(maintenanceKey, inFlight);
     void inFlight.finally(() => {
-      if (contextMaintenanceInFlightByBasePath.get(basePath) === inFlight) {
-        contextMaintenanceInFlightByBasePath.delete(basePath);
+      if (contextMaintenanceInFlightBySession.get(maintenanceKey) === inFlight) {
+        contextMaintenanceInFlightBySession.delete(maintenanceKey);
       }
     });
   } else {
@@ -149,6 +151,7 @@ async function runSessionStartupMaintenanceOnce(
 async function performSessionStartupMaintenance(
   basePath: string,
   ctx: ExtensionContext,
+  maintenanceKey: string,
 ): Promise<boolean> {
   // DB-backed memory backfills run below. On a cold session the database file
   // may exist without an active in-process adapter, so open the canonical
@@ -172,11 +175,40 @@ async function performSessionStartupMaintenance(
 
   // Mark session complete before scheduling deferred work so any concurrent
   // caller that observes the completed state does not re-enter maintenance.
-  contextMaintenanceCompletedForBasePath.add(basePath);
-  scheduleDeferredContextMaintenance(basePath);
+  contextMaintenanceCompletedForSession.add(maintenanceKey);
+  scheduleDeferredContextMaintenance(basePath, maintenanceKey);
   return true;
 }
 
+function getContextMaintenanceKey(basePath: string, ctx: ExtensionContext): string {
+  return `${basePath}${CONTEXT_MAINTENANCE_KEY_SEPARATOR}${getContextSessionPart(ctx)}`;
+}
+
+function getContextSessionPart(ctx: ExtensionContext): string {
+  const sessionManager = (ctx as {
+    sessionManager?: {
+      getSessionId?: () => string | undefined;
+      getSessionFile?: () => string | undefined;
+    };
+  }).sessionManager;
+
+  try {
+    const sessionId = sessionManager?.getSessionId?.();
+    if (typeof sessionId === "string" && sessionId.length > 0) return `id:${sessionId}`;
+  } catch (e) {
+    logWarning("bootstrap", `session-id fetch failed: ${(e as Error).message}`);
+  }
+
+  try {
+    const sessionFile = sessionManager?.getSessionFile?.();
+    if (typeof sessionFile === "string" && sessionFile.length > 0) return `file:${sessionFile}`;
+  } catch (e) {
+    logWarning("bootstrap", `session-file fetch failed: ${(e as Error).message}`);
+  }
+
+  return "process";
+}
+
 async function runDecisionsMemoryBackfill(ctx: ExtensionContext): Promise<void> {
   // ADR-013 step 5: opportunistic decisions->memories backfill. Idempotent
   // and best-effort — first run absorbs the existing decisions table into
@@ -210,8 +242,8 @@ async function runKnowledgeMemoryBackfill(
   }
 }
 
-function scheduleDeferredContextMaintenance(basePath: string): void {
-  if (deferredContextMaintenanceByBasePath.has(basePath)) return;
+function scheduleDeferredContextMaintenance(basePath: string, maintenanceKey: string): void {
+  if (deferredContextMaintenanceBySession.has(maintenanceKey)) return;
 
   const task = new Promise<void>((resolve) => {
     setTimeout(() => {
@@ -219,10 +251,10 @@ function scheduleDeferredContextMaintenance(basePath: string): void {
     }, 0);
   });
 
-  deferredContextMaintenanceByBasePath.set(basePath, task);
+  deferredContextMaintenanceBySession.set(maintenanceKey, task);
   void task.finally(() => {
-    if (deferredContextMaintenanceByBasePath.get(basePath) === task) {
-      deferredContextMaintenanceByBasePath.delete(basePath);
+    if (deferredContextMaintenanceBySession.get(maintenanceKey) === task) {
+      deferredContextMaintenanceBySession.delete(maintenanceKey);
     }
   });
 }
@@ -257,8 +289,10 @@ async function reportConsolidationGapsDeferred(basePath: string): Promise<void>
 
 export async function _flushDeferredContextMaintenanceForTest(basePath?: string): Promise<void> {
   const tasks = basePath
-    ? [deferredContextMaintenanceByBasePath.get(basePath)].filter((task): task is Promise<void> => Boolean(task))
-    : [...deferredContextMaintenanceByBasePath.values()];
+    ? [...deferredContextMaintenanceBySession.entries()]
+        .filter(([key]) => key.startsWith(`${basePath}${CONTEXT_MAINTENANCE_KEY_SEPARATOR}`))
+        .map(([, task]) => task)
+    : [...deferredContextMaintenanceBySession.values()];
   await Promise.allSettled(tasks);
 }
 

package/src/resources/extensions/gsd/bootstrap/tool-call-loop-guard.ts

@@ -1,18 +1,30 @@
 /**
  * Tool-call loop guard.
  *
- * Detects when a model calls the same tool with identical arguments
- * repeatedly within a single agent turn. Works in both auto-mode and
- * interactive sessions by hooking into the `tool_call` event, which
- * fires before execution and can block the call.
+ * Detects when a model repeats tool calls within a single Agent Turn.
+ * Works in both auto-mode and interactive sessions by hooking into the
+ * native engine's `tool_call` event, which fires before execution and can
+ * block the call.
  *
- * The guard uses a sliding window: it tracks the last N tool signatures
- * and blocks when the same signature appears more than MAX_CONSECUTIVE
- * times in a row. Resets on each agent turn (session_start, agent_end)
- * and when a different tool call breaks the streak.
+ * The guard has two independent checks: a sliding window for identical
+ * tool signatures, and a per-tool-name cap for repeated calls with varied
+ * arguments. State resets at Agent Turn boundaries (session_start,
+ * agent_end) and the identical-signature streak also resets when a
+ * different tool call breaks the streak. Block messages instruct the model
+ * to stop tooling for the rest of that turn and answer in text.
+ *
+ * The per-tool-name check (#783 Brief C) tracks call counts within a
+ * turn regardless of args, decaying after successful state-mutating tools.
+ * This catches improvisation
+ * loops where the model attempts the same missing workflow tool through
+ * varied surfaces (bash → `node -e` → CLI), each with a different
+ * signature, so the identical-args streak never trips, while allowing
+ * tool-heavy turns that are making file-mutation progress. Whichever guard
+ * trips first blocks.
  */
 
 import { createHash } from "node:crypto";
+import { INHERENTLY_REPEATABLE_TOOL_SET } from "./core-session-tools.js";
 
 const MAX_CONSECUTIVE_IDENTICAL_CALLS = 4;
 
@@ -20,11 +32,31 @@ const MAX_CONSECUTIVE_IDENTICAL_CALLS = 4;
 const STRICT_LOOP_TOOLS = new Set(["ask_user_questions"]);
 const MAX_CONSECUTIVE_STRICT = 1;
 
+/**
+ * Per-turn cap on calls to the SAME tool name, regardless of args (#783).
+ *
+ * General-purpose execution tools are routinely called many times per turn
+ * (touching multiple files, running several commands), so they get a higher
+ * ceiling. Everything else — workflow one-shot tools (e.g. gsd_complete_milestone)
+ * and any non-allowlisted tool — gets the default cap. The default is generous
+ * enough to absorb legitimate retries but catches the reported improvisation
+ * loop (~51 calls) well before a cost spike.
+ */
+const PER_TOOL_DEFAULT_CAP = 6;
+const PER_TOOL_REPEATABLE_CAP = 15;
+const PER_TOOL_CAP_EXEMPT_TOOLS = new Set(["find", "glob", "grep", "ls", "read", "search_and_read"]);
+const STATE_MUTATING_TOOL_SET = new Set(["edit", "write", "multi_edit", "notebook_edit"]);
+
 let consecutiveCount = 0;
 let lastSignature = "";
 let lastToolName = "";
 let enabled = true;
 
+/** Per-tool-name call counts within the current turn (#783 Brief C). */
+const perToolCounts = new Map<string, number>();
+let mutationEpoch = 0;
+const perToolLastMutationEpoch = new Map<string, number>();
+
 /** Hash tool name + args into a compact signature for comparison. */
 function hashToolCall(toolName: string, args: Record<string, unknown>): string {
   const h = createHash("sha256");
@@ -46,6 +78,13 @@ function hashToolCall(toolName: string, args: Record<string, unknown>): string {
  *
  * Returns `{ block: false }` for allowed calls.
  * Returns `{ block: true, reason }` when the loop threshold is exceeded.
+ *
+ * Two independent guards run; whichever trips first blocks:
+ *  1. Identical-signature streak (MAX_CONSECUTIVE_IDENTICAL_CALLS, strict for
+ *     ask_user_questions).
+ *  2. Per-tool-name cap (PER_TOOL_DEFAULT_CAP / PER_TOOL_REPEATABLE_CAP),
+ *     independent of args, reset after file-mutation progress — catches
+ *     improvisation loops (#783).
  */
 export function checkToolCallLoop(
   toolName: string,
@@ -63,6 +102,7 @@ export function checkToolCallLoop(
     lastToolName = toolName;
   }
 
+  // ── Guard 1: identical-signature streak ──
   const threshold = STRICT_LOOP_TOOLS.has(toolName)
     ? MAX_CONSECUTIVE_STRICT
     : MAX_CONSECUTIVE_IDENTICAL_CALLS;
@@ -71,22 +111,65 @@ export function checkToolCallLoop(
     return {
       block: true,
       reason:
-        `Tool loop detected: ${toolName} called ${consecutiveCount} times ` +
+        `Tool loop detected (identical args): ${toolName} called ${consecutiveCount} times ` +
         `with identical arguments. Blocking to prevent infinite loop. ` +
-        `Try a different approach or modify your arguments.`,
+        `Do not retry this tool or call other tools this turn — stop and respond to the user in text.`,
       count: consecutiveCount,
     };
   }
 
+  // ── Guard 2: per-tool-name cap, independent of args (#783 Brief C) ──
+  // Catches improvisation loops where the same tool is invoked many times with
+  // varied args (e.g. retrying a missing workflow tool via bash/node -e/CLI).
+  const priorPerToolCount =
+    (perToolLastMutationEpoch.get(toolName) ?? mutationEpoch) < mutationEpoch
+      ? 0
+      : (perToolCounts.get(toolName) ?? 0);
+  const perToolCount = priorPerToolCount + 1;
+  perToolCounts.set(toolName, perToolCount);
+  perToolLastMutationEpoch.set(toolName, mutationEpoch);
+
+  // Read-only navigation tools are normal context gathering; Guard 1 still
+  // catches true reread loops with identical arguments.
+  if (PER_TOOL_CAP_EXEMPT_TOOLS.has(toolName)) {
+    return { block: false, count: consecutiveCount };
+  }
+
+  const perToolCap = INHERENTLY_REPEATABLE_TOOL_SET.has(toolName)
+    ? PER_TOOL_REPEATABLE_CAP
+    : PER_TOOL_DEFAULT_CAP;
+
+  if (perToolCount > perToolCap) {
+    return {
+      block: true,
+      reason:
+        `Tool loop detected (repeated tool): ${toolName} called ${perToolCount} times ` +
+        `this turn (cap ${perToolCap}). Blocking to prevent infinite loop. ` +
+        `The tool may be unavailable or failing repeatedly. ` +
+        `Do not retry this tool or pivot to other tools this turn — stop and respond to the user in text.`,
+      count: perToolCount,
+    };
+  }
+
   return { block: false, count: consecutiveCount };
 }
 
+/** Record successful mutation progress so Guard 2 can decay on the next count. */
+export function recordToolCallLoopMutation(toolName: string): void {
+  if (!enabled) return;
+  if (!STATE_MUTATING_TOOL_SET.has(toolName)) return;
+  mutationEpoch++;
+}
+
 /** Reset the guard state. Call at agent turn boundaries. */
 export function resetToolCallLoopGuard(): void {
   consecutiveCount = 0;
   lastSignature = "";
   lastToolName = "";
   enabled = true;
+  perToolCounts.clear();
+  mutationEpoch = 0;
+  perToolLastMutationEpoch.clear();
 }
 
 /** Disable the guard (e.g. during shutdown). */
@@ -95,9 +178,20 @@ export function disableToolCallLoopGuard(): void {
   consecutiveCount = 0;
   lastSignature = "";
   lastToolName = "";
+  perToolCounts.clear();
+  mutationEpoch = 0;
+  perToolLastMutationEpoch.clear();
 }
 
 /** Get current consecutive count for diagnostics. */
 export function getToolCallLoopCount(): number {
   return consecutiveCount;
 }
+
+/**
+ * Get the per-tool-name call count for the current turn (#783 Brief C).
+ * Returns 0 for tools not yet called. Diagnostic only.
+ */
+export function getToolCallCountForTool(toolName: string): number {
+  return perToolCounts.get(toolName) ?? 0;
+}

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -180,7 +180,7 @@ function ensureWriteGateSnapshotDirectory(basePath: string): void {
   mkdirSync(join(gsdPath, "runtime"), { recursive: true });
 }
 
-function currentWriteGateSnapshot(basePath: string = process.cwd()): WriteGateSnapshot {
+export function currentWriteGateSnapshot(basePath: string = process.cwd()): WriteGateSnapshot {
   const state = getWriteGateState(basePath);
   return {
     verifiedDepthMilestones: [...state.verifiedDepthMilestones].sort(),

package/src/resources/extensions/gsd/closeout-consistency-gate.ts

@@ -18,7 +18,7 @@ import {
   getWorkflowDatabasePath,
   refreshWorkflowDatabaseFromDisk,
 } from "./db-workspace.js";
-import { isClosedStatus } from "./status-guards.js";
+import { isClosedStatus, isDeferredStatus } from "./status-guards.js";
 import { closeQualityGatesFromEvidence } from "./quality-gate-closure.js";
 import { insertMilestoneValidationGates } from "./milestone-validation-gates.js";
 import { relMilestoneFile, resolveSliceFile } from "./paths.js";
@@ -229,6 +229,7 @@ export function checkCloseoutConsistencyGate(
   }
 
   for (const slice of slices) {
+    if (isDeferredStatus(slice.status)) continue;
     if (!isClosedStatus(slice.status)) {
       return blocked(
         "slice-open",

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

@@ -200,7 +200,7 @@ export async function handleAutoCommand(trimmed: string, ctx: ExtensionCommandCo
       }
       return true;
     }
-    await pauseAuto(ctx, pi);
+    await pauseAuto(ctx, pi, undefined, { abortActiveTurn: true });
     return true;
   }
 

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

@@ -11,6 +11,7 @@ import { formatPercent, formatTokenCount } from "./metrics.js";
 import { countTokensSync, type TokenProvider } from "./token-counter.js";
 import { writeContextChartHtml } from "./context-chart-html.js";
 import { openInBrowser } from "./export.js";
+import { truncateWithEllipsis } from "../shared/format-utils.js";
 
 export interface ContextSectionBreakdown {
   label: string;
@@ -34,6 +35,7 @@ export interface ContextBreakdownReport {
   subagentSpawns: number;
 }
 
+const REDACTED_TOOL_ARGUMENT_KEYS = new Set(["content", "oldText", "newText"]);
 
 function resolveProvider(provider: string | undefined): TokenProvider {
   const normalized = (provider ?? "unknown").toLowerCase();
@@ -206,6 +208,21 @@ export function parseSystemPromptSections(systemPrompt: string, provider: TokenP
   return sections;
 }
 
+function redactToolCallArguments(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(redactToolCallArguments);
+  if (!value || typeof value !== "object") return value;
+
+  const safe: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (REDACTED_TOOL_ARGUMENT_KEYS.has(key)) {
+      safe[key] = typeof child === "string" ? truncateWithEllipsis(child, 101) : "[redacted]";
+    } else {
+      safe[key] = redactToolCallArguments(child);
+    }
+  }
+  return safe;
+}
+
 function messageToText(message: SessionMessageEntry["message"]): string {
   const role = message.role;
 
@@ -220,7 +237,7 @@ function messageToText(message: SessionMessageEntry["message"]): string {
         if (typed.type === "thinking" && typed.thinking) parts.push(typed.thinking);
         if (typed.type === "toolCall") {
           parts.push(typed.name ?? "tool");
-          parts.push(JSON.stringify(typed.arguments ?? {}));
+          parts.push(JSON.stringify(redactToolCallArguments(typed.arguments ?? {})));
         }
       }
     }

package/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -1228,7 +1228,7 @@ async function configureContextCodebase(ctx: ExtensionCommandContext, prefs: Rec
   const maskTurns = await promptInteger(ctx, "Observation mask turns (1–50)", cm.observation_mask_turns, "8");
   if (maskTurns !== undefined && maskTurns !== "clear") cm.observation_mask_turns = maskTurns;
   else if (maskTurns === "clear") delete cm.observation_mask_turns;
-  const thresh = await promptNumber(ctx, "Compaction threshold percent (0.5–0.95)", cm.compaction_threshold_percent, "0.60");
+  const thresh = await promptNumber(ctx, "Soft context warning threshold percent (0.5–0.95)", cm.compaction_threshold_percent, "0.60");
   if (thresh !== undefined && thresh !== "clear") cm.compaction_threshold_percent = thresh;
   else if (thresh === "clear") delete cm.compaction_threshold_percent;
   const toolMax = await promptInteger(ctx, "Tool result max chars (200–10000)", cm.tool_result_max_chars, "800");
@@ -1724,17 +1724,22 @@ export function serializePreferencesToFrontmatter(prefs: Record<string, unknown>
           const entries = Object.entries(item as Record<string, unknown>);
           if (entries.length > 0) {
             const [firstKey, firstVal] = entries[0];
-            lines.push(`${prefix}  - ${firstKey}: ${yamlSafeString(firstVal)}`);
+            if (Array.isArray(firstVal)) {
+              lines.push(`${prefix}  - ${firstKey}:`);
+              for (const arrItem of firstVal) {
+                lines.push(`${prefix}      - ${yamlSafeString(arrItem)}`);
+              }
+            } else if (typeof firstVal === "object" && firstVal !== null) {
+              lines.push(`${prefix}  - ${firstKey}:`);
+              for (const [k, v] of Object.entries(firstVal as Record<string, unknown>)) {
+                serializeValue(k, v, indent + 3);
+              }
+            } else {
+              lines.push(`${prefix}  - ${firstKey}: ${yamlSafeString(firstVal)}`);
+            }
             for (let i = 1; i < entries.length; i++) {
               const [k, v] = entries[i];
-              if (Array.isArray(v)) {
-                lines.push(`${prefix}    ${k}:`);
-                for (const arrItem of v) {
-                  lines.push(`${prefix}      - ${yamlSafeString(arrItem)}`);
-                }
-              } else {
-                lines.push(`${prefix}    ${k}: ${yamlSafeString(v)}`);
-              }
+              serializeValue(k, v, indent + 2);
             }
           }
         } else {

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

@@ -112,7 +112,7 @@ function formatThresholdLines(): string[] {
 
   const compactionThreshold = prefs?.context_management?.compaction_threshold_percent;
   if (typeof compactionThreshold === "number") {
-    lines.push(`Compaction: ${Math.round(compactionThreshold * 100)}%`);
+    lines.push(`Soft context warning: ${Math.round(compactionThreshold * 100)}%`);
   }
 
   return lines;

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

@@ -42,9 +42,9 @@ export interface WorktreeStatus {
 
 // ─── Status helper ─────────────────────────────────────────────────────────
 
-function getStatus(basePath: string, name: string, wtPath: string): WorktreeStatus {
-  const diff = diffWorktreeAll(basePath, name);
-  const numstat = diffWorktreeNumstat(basePath, name);
+function getStatus(basePath: string, name: string, wtPath: string, mainBranch: string): WorktreeStatus {
+  const diff = diffWorktreeAll(basePath, name, undefined, mainBranch);
+  const numstat = diffWorktreeNumstat(basePath, name, undefined, mainBranch);
   const filesChanged = diff.added.length + diff.modified.length + diff.removed.length;
   let linesAdded = 0;
   let linesRemoved = 0;
@@ -62,8 +62,7 @@ function getStatus(basePath: string, name: string, wtPath: string): WorktreeStat
 
   let commits = 0;
   try {
-    const main = nativeDetectMainBranch(basePath);
-    commits = nativeCommitCountBetween(basePath, main, worktreeBranchName(name));
+    commits = nativeCommitCountBetween(basePath, mainBranch, worktreeBranchName(name));
   } catch {
     // commit count unavailable → leave at 0
   }
@@ -129,7 +128,8 @@ export function formatCleanKeepReason(status: WorktreeStatus): string {
 async function handleList(ctx: ExtensionCommandContext): Promise<void> {
   const basePath = projectRoot();
   const worktrees = listWorktrees(basePath);
-  const statuses = worktrees.map((wt) => getStatus(basePath, wt.name, wt.path));
+  const mainBranch = worktrees.length > 0 ? nativeDetectMainBranch(basePath) : "";
+  const statuses = worktrees.map((wt) => getStatus(basePath, wt.name, wt.path, mainBranch));
   ctx.ui.notify(formatWorktreeList(statuses), "info");
 }
 
@@ -161,7 +161,8 @@ async function handleMerge(args: string, ctx: ExtensionCommandContext): Promise<
     return;
   }
 
-  const status = getStatus(basePath, target, wt.path);
+  const mainBranch = nativeDetectMainBranch(basePath);
+  const status = getStatus(basePath, target, wt.path, mainBranch);
   if (status.filesChanged === 0 && !status.uncommitted) {
     try {
       removeWorktree(basePath, target, { deleteBranch: true });
@@ -194,7 +195,6 @@ async function handleMerge(args: string, ctx: ExtensionCommandContext): Promise<
   }
 
   const commitType = inferCommitType(target);
-  const mainBranch = nativeDetectMainBranch(basePath);
   const commitMessage = `${commitType}: merge worktree ${target}\n\nGSD-Worktree: ${target}`;
 
   try {
@@ -250,8 +250,9 @@ async function handleClean(ctx: ExtensionCommandContext): Promise<void> {
 
   const removed: string[] = [];
   const kept: string[] = [];
+  const mainBranch = nativeDetectMainBranch(basePath);
   for (const wt of worktrees) {
-    const status = getStatus(basePath, wt.name, wt.path);
+    const status = getStatus(basePath, wt.name, wt.path, mainBranch);
     if (status.filesChanged === 0 && !status.uncommitted) {
       try {
         removeWorktree(basePath, wt.name, { deleteBranch: true });
@@ -298,7 +299,8 @@ async function handleRemove(args: string, ctx: ExtensionCommandContext): Promise
     return;
   }
 
-  const status = getStatus(basePath, name, wt.path);
+  const mainBranch = nativeDetectMainBranch(basePath);
+  const status = getStatus(basePath, name, wt.path, mainBranch);
   if ((status.filesChanged > 0 || status.uncommitted) && !force) {
     ctx.ui.notify(
       [

package/src/resources/extensions/gsd/dashboard-overlay.ts

@@ -29,7 +29,7 @@ import { getWorkerBatches, hasActiveWorkers, type WorkerEntry } from "../subagen
 import { formatDuration, padRight, joinColumns, centerLine, fitColumns, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
 import { estimateTimeRemaining } from "./auto-dashboard.js";
 import { computeProgressScore, formatProgressLine } from "./progress-score.js";
-import { runEnvironmentChecks, type EnvironmentCheckResult } from "./doctor-environment.js";
+import { runEnvironmentChecksAsync, type EnvironmentCheckResult } from "./doctor-environment.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 
@@ -71,6 +71,9 @@ export class GSDDashboardOverlay {
   private loading = true;
   private loadedDashboardIdentity?: string;
   private refreshInFlight: Promise<void> | null = null;
+  private envRefreshInFlight: Promise<void> | null = null;
+  private cachedEnvBasePath?: string;
+  private cachedEnvIssues: EnvironmentCheckResult[] = [];
   private disposed = false;
   private resizeHandler: (() => void) | null = null;
   private cachedMetrics: {
@@ -181,12 +184,39 @@ export class GSDDashboardOverlay {
       this.loading = false;
     }
 
+    this.scheduleEnvironmentRefresh(this.dashData.basePath || process.cwd());
+
     if (identityChanged) {
       this.invalidate();
     }
     this.tui.requestRender();
   }
 
+  private scheduleEnvironmentRefresh(basePath: string): void {
+    if (this.cachedEnvBasePath !== basePath) {
+      this.cachedEnvBasePath = basePath;
+      this.cachedEnvIssues = [];
+      this.invalidate();
+    }
+    if (this.envRefreshInFlight || this.disposed) return;
+    this.envRefreshInFlight = this.refreshEnvironmentHealth(basePath)
+      .finally(() => {
+        this.envRefreshInFlight = null;
+      });
+  }
+
+  private async refreshEnvironmentHealth(basePath: string): Promise<void> {
+    try {
+      const envResults = await runEnvironmentChecksAsync(basePath);
+      if (this.disposed || this.cachedEnvBasePath !== basePath) return;
+      this.cachedEnvIssues = envResults.filter(r => r.status !== "ok");
+      this.invalidate();
+      this.tui.requestRender();
+    } catch {
+      // Non-fatal — keep last known environment issues
+    }
+  }
+
   private async loadData(): Promise<boolean> {
     const base = this.dashData.basePath || process.cwd();
     try {
@@ -629,8 +659,7 @@ export class GSDDashboardOverlay {
     }
 
     // Environment health section (#1221) — only show issues
-    const envResults = runEnvironmentChecks(this.dashData.basePath || process.cwd());
-    const envIssues = envResults.filter(r => r.status !== "ok");
+    const envIssues = this.cachedEnvIssues;
     if (envIssues.length > 0) {
       lines.push(blank());
       lines.push(hr());

package/src/resources/extensions/gsd/db/engine.ts

@@ -47,7 +47,11 @@ import {
   applyMigrationV28MemoryLastHitAt,
   applyMigrationV29RepositoryTargets,
 } from "../db-migration-steps.js";
-import { isMemoriesFtsAvailableSchema, tryCreateMemoriesFtsSchema } from "../db-memory-fts-schema.js";
+import {
+  isMemoriesFtsAvailableSchema,
+  rebuildMemoriesFtsSchemaOnce,
+  tryCreateMemoriesFtsSchema,
+} from "../db-memory-fts-schema.js";
 import { createDbOpenState, type DbOpenPhase } from "../db-open-state.js";
 import { createRuntimeKvTableV25 } from "../db-runtime-kv-schema.js";
 import { getCurrentSchemaVersion, recordSchemaVersion } from "../db-schema-metadata.js";
@@ -134,6 +138,9 @@ function initSchema(db: DbAdapter, fileBacked: boolean, dbPath: string | null):
   }
 
   migrateSchema(db, dbPath);
+  rebuildMemoriesFtsSchemaOnce(db, {
+    onRebuildFailed: (message) => logWarning("db", message),
+  });
 }
 
 export function _isLikelyWslDrvFsPathForTest(dbPath: string | null): boolean {