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

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -23,9 +23,10 @@ const DEFAULT_KNOWLEDGE_MAX_CHARS = 12_000;
 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();
-const contextMaintenanceInFlightByBasePath = new Map();
-const deferredContextMaintenanceByBasePath = new Map();
+const CONTEXT_MAINTENANCE_KEY_SEPARATOR = "\0";
+const contextMaintenanceCompletedForSession = new Set();
+const contextMaintenanceInFlightBySession = new Map();
+const deferredContextMaintenanceBySession = new Map();
 /**
  * Bundled skill triggers — resolved dynamically at runtime instead of
  * hardcoding absolute paths in the system prompt template. Only skills
@@ -100,7 +101,8 @@ function warnDeprecatedAgentInstructions() {
     }
 }
 async function runSessionStartupMaintenanceOnce(basePath, ctx) {
-    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 {
@@ -112,16 +114,16 @@ async function runSessionStartupMaintenanceOnce(basePath, ctx) {
         }
         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;
     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);
             }
         });
     }
@@ -131,7 +133,7 @@ async function runSessionStartupMaintenanceOnce(basePath, ctx) {
     const result = await inFlight;
     return isInitiator ? result : false;
 }
-async function performSessionStartupMaintenance(basePath, ctx) {
+async function performSessionStartupMaintenance(basePath, ctx, maintenanceKey) {
     // 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
     // project DB before those best-effort operations inspect it.
@@ -154,10 +156,33 @@ async function performSessionStartupMaintenance(basePath, ctx) {
     ]);
     // 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, ctx) {
+    return `${basePath}${CONTEXT_MAINTENANCE_KEY_SEPARATOR}${getContextSessionPart(ctx)}`;
+}
+function getContextSessionPart(ctx) {
+    const sessionManager = ctx.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.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.message}`);
+    }
+    return "process";
+}
 async function runDecisionsMemoryBackfill(ctx) {
     // ADR-013 step 5: opportunistic decisions->memories backfill. Idempotent
     // and best-effort — first run absorbs the existing decisions table into
@@ -188,18 +213,18 @@ async function runKnowledgeMemoryBackfill(basePath, ctx) {
         logWarning("bootstrap", `KNOWLEDGE.md backfill failed: ${e.message}`);
     }
 }
-function scheduleDeferredContextMaintenance(basePath) {
-    if (deferredContextMaintenanceByBasePath.has(basePath))
+function scheduleDeferredContextMaintenance(basePath, maintenanceKey) {
+    if (deferredContextMaintenanceBySession.has(maintenanceKey))
         return;
     const task = new Promise((resolve) => {
         setTimeout(() => {
             void runDeferredContextMaintenance(basePath).finally(resolve);
         }, 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);
         }
     });
 }
@@ -232,8 +257,10 @@ async function reportConsolidationGapsDeferred(basePath) {
 }
 export async function _flushDeferredContextMaintenanceForTest(basePath) {
     const tasks = basePath
-        ? [deferredContextMaintenanceByBasePath.get(basePath)].filter((task) => Boolean(task))
-        : [...deferredContextMaintenanceByBasePath.values()];
+        ? [...deferredContextMaintenanceBySession.entries()]
+            .filter(([key]) => key.startsWith(`${basePath}${CONTEXT_MAINTENANCE_KEY_SEPARATOR}`))
+            .map(([, task]) => task)
+        : [...deferredContextMaintenanceBySession.values()];
     await Promise.allSettled(tasks);
 }
 export async function buildBeforeAgentStartResult(event, ctx) {

package/dist/resources/extensions/gsd/bootstrap/tool-call-loop-guard.js

@@ -1,25 +1,55 @@
 /**
  * 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;
 /** Interactive/user-facing tools where even 1 duplicate is confusing. */
 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();
+let mutationEpoch = 0;
+const perToolLastMutationEpoch = new Map();
 /** Hash tool name + args into a compact signature for comparison. */
 function hashToolCall(toolName, args) {
     const h = createHash("sha256");
@@ -38,6 +68,13 @@ function hashToolCall(toolName, args) {
  *
  * 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, args) {
     if (!enabled)
@@ -51,26 +88,65 @@ export function checkToolCallLoop(toolName, args) {
         lastSignature = sig;
         lastToolName = toolName;
     }
+    // ── Guard 1: identical-signature streak ──
     const threshold = STRICT_LOOP_TOOLS.has(toolName)
         ? MAX_CONSECUTIVE_STRICT
         : MAX_CONSECUTIVE_IDENTICAL_CALLS;
     if (consecutiveCount > threshold) {
         return {
             block: true,
-            reason: `Tool loop detected: ${toolName} called ${consecutiveCount} times ` +
+            reason: `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) {
+    if (!enabled)
+        return;
+    if (!STATE_MUTATING_TOOL_SET.has(toolName))
+        return;
+    mutationEpoch++;
+}
 /** Reset the guard state. Call at agent turn boundaries. */
 export function resetToolCallLoopGuard() {
     consecutiveCount = 0;
     lastSignature = "";
     lastToolName = "";
     enabled = true;
+    perToolCounts.clear();
+    mutationEpoch = 0;
+    perToolLastMutationEpoch.clear();
 }
 /** Disable the guard (e.g. during shutdown). */
 export function disableToolCallLoopGuard() {
@@ -78,8 +154,18 @@ export function disableToolCallLoopGuard() {
     consecutiveCount = 0;
     lastSignature = "";
     lastToolName = "";
+    perToolCounts.clear();
+    mutationEpoch = 0;
+    perToolLastMutationEpoch.clear();
 }
 /** Get current consecutive count for diagnostics. */
 export function getToolCallLoopCount() {
     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) {
+    return perToolCounts.get(toolName) ?? 0;
+}

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

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

package/dist/resources/extensions/gsd/closeout-consistency-gate.js

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getLatestAssessmentByScope, getMilestone, getMilestoneSlices, getPendingGates, getSliceTasks, insertAssessment, isDbAvailable, transaction, } from "./gsd-db.js";
 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";
@@ -144,6 +144,8 @@ export function checkCloseoutConsistencyGate(milestoneId, options = {}) {
         });
     }
     for (const slice of slices) {
+        if (isDeferredStatus(slice.status))
+            continue;
         if (!isClosedStatus(slice.status)) {
             return blocked("slice-open", `Closeout consistency blocked for ${milestoneId}: slice ${slice.id} status is "${slice.status}".`);
         }

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

@@ -190,7 +190,7 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
             }
             return true;
         }
-        await pauseAuto(ctx, pi);
+        await pauseAuto(ctx, pi, undefined, { abortActiveTurn: true });
         return true;
     }
     if (trimmed === "rate" || trimmed.startsWith("rate ")) {

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

@@ -8,6 +8,8 @@ import { formatPercent, formatTokenCount } from "./metrics.js";
 import { countTokensSync } from "./token-counter.js";
 import { writeContextChartHtml } from "./context-chart-html.js";
 import { openInBrowser } from "./export.js";
+import { truncateWithEllipsis } from "../shared/format-utils.js";
+const REDACTED_TOOL_ARGUMENT_KEYS = new Set(["content", "oldText", "newText"]);
 function resolveProvider(provider) {
     const normalized = (provider ?? "unknown").toLowerCase();
     if (normalized === "anthropic" || normalized === "claude-code")
@@ -167,6 +169,22 @@ export function parseSystemPromptSections(systemPrompt, provider) {
     }
     return sections;
 }
+function redactToolCallArguments(value) {
+    if (Array.isArray(value))
+        return value.map(redactToolCallArguments);
+    if (!value || typeof value !== "object")
+        return value;
+    const safe = {};
+    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) {
     const role = message.role;
     if (role === "assistant") {
@@ -183,7 +201,7 @@ function messageToText(message) {
                     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/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -1164,7 +1164,7 @@ async function configureContextCodebase(ctx, prefs) {
         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")
@@ -1671,19 +1671,25 @@ export function serializePreferencesToFrontmatter(prefs) {
                     const entries = Object.entries(item);
                     if (entries.length > 0) {
                         const [firstKey, firstVal] = entries[0];
-                        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)}`);
-                                }
+                        if (Array.isArray(firstVal)) {
+                            lines.push(`${prefix}  - ${firstKey}:`);
+                            for (const arrItem of firstVal) {
+                                lines.push(`${prefix}      - ${yamlSafeString(arrItem)}`);
                             }
-                            else {
-                                lines.push(`${prefix}    ${k}: ${yamlSafeString(v)}`);
+                        }
+                        else if (typeof firstVal === "object" && firstVal !== null) {
+                            lines.push(`${prefix}  - ${firstKey}:`);
+                            for (const [k, v] of Object.entries(firstVal)) {
+                                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];
+                            serializeValue(k, v, indent + 2);
+                        }
                     }
                 }
                 else {

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

@@ -83,7 +83,7 @@ function formatThresholdLines() {
     }
     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/dist/resources/extensions/gsd/commands-worktree.js

@@ -12,9 +12,9 @@ import { inferCommitType } from "./git-service.js";
 import { autoCommitCurrentBranch } from "./worktree.js";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 // ─── Status helper ─────────────────────────────────────────────────────────
-function getStatus(basePath, name, wtPath) {
-    const diff = diffWorktreeAll(basePath, name);
-    const numstat = diffWorktreeNumstat(basePath, name);
+function getStatus(basePath, name, wtPath, mainBranch) {
+    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;
@@ -31,8 +31,7 @@ function getStatus(basePath, name, wtPath) {
     }
     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
@@ -88,7 +87,8 @@ export function formatCleanKeepReason(status) {
 async function handleList(ctx) {
     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");
 }
 // ─── Subcommand: merge ──────────────────────────────────────────────────────
@@ -117,7 +117,8 @@ async function handleMerge(args, ctx) {
         ctx.ui.notify(`Worktree "${target}" not found.\n\nAvailable: ${available}`, "error");
         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 });
@@ -144,7 +145,6 @@ async function handleMerge(args, ctx) {
         }
     }
     const commitType = inferCommitType(target);
-    const mainBranch = nativeDetectMainBranch(basePath);
     const commitMessage = `${commitType}: merge worktree ${target}\n\nGSD-Worktree: ${target}`;
     try {
         mergeWorktreeToMain(basePath, target, commitMessage);
@@ -191,8 +191,9 @@ async function handleClean(ctx) {
     }
     const removed = [];
     const kept = [];
+    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 });
@@ -238,7 +239,8 @@ async function handleRemove(args, ctx) {
         ctx.ui.notify(`Worktree "${name}" not found.\n\nAvailable: ${available}`, "error");
         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([
             `Worktree "${name}" has pending changes (${formatCleanKeepReason(status)}).`,

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -21,7 +21,7 @@ import { getWorkerBatches, hasActiveWorkers } from "../subagent/worker-registry.
 import { formatDuration, padRight, joinColumns, centerLine, fitColumns, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
 import { estimateTimeRemaining } from "./auto-dashboard.js";
 import { computeProgressScore } from "./progress-score.js";
-import { runEnvironmentChecks } from "./doctor-environment.js";
+import { runEnvironmentChecksAsync } from "./doctor-environment.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 export function unitLabel(type) {
@@ -62,6 +62,9 @@ export class GSDDashboardOverlay {
     loading = true;
     loadedDashboardIdentity;
     refreshInFlight = null;
+    envRefreshInFlight = null;
+    cachedEnvBasePath;
+    cachedEnvIssues = [];
     disposed = false;
     resizeHandler = null;
     cachedMetrics = null;
@@ -155,11 +158,38 @@ export class GSDDashboardOverlay {
         if (initial) {
             this.loading = false;
         }
+        this.scheduleEnvironmentRefresh(this.dashData.basePath || process.cwd());
         if (identityChanged) {
             this.invalidate();
         }
         this.tui.requestRender();
     }
+    scheduleEnvironmentRefresh(basePath) {
+        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;
+        });
+    }
+    async refreshEnvironmentHealth(basePath) {
+        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
+        }
+    }
     async loadData() {
         const base = this.dashData.basePath || process.cwd();
         try {
@@ -540,8 +570,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/dist/resources/extensions/gsd/db/engine.js

@@ -19,7 +19,7 @@ import { createCoordinationTablesV24 } from "../db-coordination-schema.js";
 import { createDbConnectionCache } from "../db-connection-cache.js";
 import { backupDatabaseBeforeMigration, isMigrationBackupError } from "../db-migration-backup.js";
 import { applyMigrationV2Artifacts, applyMigrationV3Memories, applyMigrationV4DecisionMadeBy, applyMigrationV5HierarchyTables, applyMigrationV6SliceSummaries, applyMigrationV7Dependencies, applyMigrationV8PlanningFields, applyMigrationV9Ordering, applyMigrationV10ReplanTrigger, applyMigrationV11TaskPlanning, applyMigrationV12QualityGates, applyMigrationV13HotPathIndexes, applyMigrationV14SliceDependencies, applyMigrationV15AuditTables, applyMigrationV16EscalationSource, applyMigrationV17TaskEscalation, applyMigrationV18MemorySources, applyMigrationV19MemoryFts, applyMigrationV20MemoryRelations, applyMigrationV21StructuredMemories, applyMigrationV22QualityGateRepair, applyMigrationV23MilestoneQueue, applyMigrationV26MilestoneCommitAttributions, applyMigrationV27ArtifactHash, 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 } from "../db-open-state.js";
 import { createRuntimeKvTableV25 } from "../db-runtime-kv-schema.js";
 import { getCurrentSchemaVersion, recordSchemaVersion } from "../db-schema-metadata.js";
@@ -101,6 +101,9 @@ function initSchema(db, fileBacked, dbPath) {
         throw err;
     }
     migrateSchema(db, dbPath);
+    rebuildMemoriesFtsSchemaOnce(db, {
+        onRebuildFailed: (message) => logWarning("db", message),
+    });
 }
 export function _isLikelyWslDrvFsPathForTest(dbPath) {
     if (!dbPath || process.platform !== "linux")