@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.eed73bea

package/dist/resources/extensions/gsd/bootstrap/exec-tools.js

@@ -60,6 +60,7 @@ export function registerExecTools(pi) {
             return executeUatExec(params, {
                 baseDir,
                 preferences: await loadContextModePreferences(baseDir),
+                signal: _signal,
             });
         },
     });
@@ -99,6 +100,7 @@ export function registerExecTools(pi) {
             return executeGsdExec(params, {
                 baseDir,
                 preferences: await loadContextModePreferences(baseDir),
+                signal: _signal,
             });
         },
     });

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -7,7 +7,7 @@ import { isToolCallEventType } from "@gsd/pi-coding-agent";
 import { ALWAYS_PRESERVED_SHIM_TOOL_NAMES } from "@gsd/pi-ai";
 import { updateSnapshot } from "../ecosystem/gsd-extension-api.js";
 import { buildMilestoneFileName, canonicalPhaseDirName, clearPathCache, milestonesDir, legacyMilestonesDir, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
-import { applyAskUserQuestionsGateResult, clearDiscussionFlowState, formatPendingAskUserQuestionsGateMessage, formatTimedOutAskUserQuestionsGateMessage, hostWriteGateAdapter, isApprovalGateVerifiedInSnapshot, isDepthConfirmationAnswer, isMilestoneDepthVerified, isMilestoneDepthVerifiedInSnapshot, isQueuePhaseActive, resetWriteGateState, shouldBlockContextWrite, shouldBlockPlanningUnit, shouldBlockQueueExecution, shouldBlockWorktreeBash, shouldBlockWorktreeWrite, isGateQuestionId, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
+import { applyAskUserQuestionsGateResult, clearDiscussionFlowState, currentWriteGateSnapshot, formatPendingAskUserQuestionsGateMessage, formatTimedOutAskUserQuestionsGateMessage, hostWriteGateAdapter, isApprovalGateVerifiedInSnapshot, isDepthConfirmationAnswer, isMilestoneDepthVerifiedInSnapshot, isQueuePhaseActive, resetWriteGateState, shouldBlockContextWrite, shouldBlockPlanningUnit, shouldBlockQueueExecution, shouldBlockWorktreeBash, shouldBlockWorktreeWrite, isGateQuestionId, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
 import { canonicalToolName } from "../engine-hook-contract.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
@@ -436,6 +436,9 @@ function deferApprovalGate(gateId, basePath) {
     // workflow MCP child already verified this gate, deferring would block
     // tools for a gate that can never legitimately arm.
     const snapshot = hostWriteGateAdapter.readState(basePath);
+    deferApprovalGateFromSnapshot(gateId, basePath, snapshot);
+}
+function deferApprovalGateFromSnapshot(gateId, basePath, snapshot) {
     if (isApprovalGateVerifiedInSnapshot(snapshot, gateId))
         return;
     const milestoneId = extractDepthVerificationMilestoneId(gateId);
@@ -1009,14 +1012,16 @@ export function registerHooks(pi, ecosystemHandlers) {
             return;
         const gateId = approvalGateIdForUnit(unitType, unitId);
         if (gateId) {
+            const basePath = contextBasePath(ctx);
+            const gateSnapshot = currentWriteGateSnapshot(basePath);
             // Skip the gate if this milestone is already depth-verified — the approval
             // pattern matched again on post-verification text (a false-positive re-trigger).
             // Without this guard, the second firing blocks gsd_plan_milestone in the same
             // turn and leaves CONTEXT.md on disk with no DB row (#discuss-milestone-no-db).
             const gateMilestoneId = extractDepthVerificationMilestoneId(gateId);
-            if (gateMilestoneId && isMilestoneDepthVerified(gateMilestoneId, contextBasePath(ctx)))
+            if (gateMilestoneId && isMilestoneDepthVerifiedInSnapshot(gateSnapshot, gateMilestoneId))
                 return;
-            deferApprovalGate(gateId, contextBasePath(ctx));
+            deferApprovalGateFromSnapshot(gateId, basePath, gateSnapshot);
         }
         approvalQuestionAbortInFlight = true;
         ctx.ui.notify(`${unitType ?? "The discussion"}${unitId ? ` ${unitId}` : ""} is waiting for your approval - pausing before more tool calls run.`, "info");

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

@@ -10,16 +10,57 @@
  * 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.
+ *
+ * A second, independent check (#783 Brief C) tracks per-tool-name call
+ * counts within a turn regardless of args. 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. Whichever guard
+ * trips first blocks.
  */
 import { createHash } from "node:crypto";
 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;
+/**
+ * Inherently-repeatable tools: called many times per turn in normal work
+ * (reading/writing several files, running several commands, searching). These
+ * get PER_TOOL_REPEATABLE_CAP rather than the default. Keep this list
+ * conservative — a tool here can be invoked up to PER_TOOL_REPEATABLE_CAP times
+ * per turn before the guard blocks.
+ */
+const REPEATABLE_TOOLS = new Set([
+    "read",
+    "write",
+    "edit",
+    "multi_edit",
+    "bash",
+    "grep",
+    "glob",
+    "search-the-web",
+    "fetch_page",
+    "todo_write",
+    "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();
 /** Hash tool name + args into a compact signature for comparison. */
 function hashToolCall(toolName, args) {
     const h = createHash("sha256");
@@ -38,6 +79,12 @@ 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 — catches improvisation loops (#783).
  */
 export function checkToolCallLoop(toolName, args) {
     if (!enabled)
@@ -51,18 +98,36 @@ 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.`,
             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 perToolCount = (perToolCounts.get(toolName) ?? 0) + 1;
+    perToolCounts.set(toolName, perToolCount);
+    const perToolCap = REPEATABLE_TOOLS.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 — try a different approach.`,
+            count: perToolCount,
+        };
+    }
     return { block: false, count: consecutiveCount };
 }
 /** Reset the guard state. Call at agent turn boundaries. */
@@ -71,6 +136,7 @@ export function resetToolCallLoopGuard() {
     lastSignature = "";
     lastToolName = "";
     enabled = true;
+    perToolCounts.clear();
 }
 /** Disable the guard (e.g. during shutdown). */
 export function disableToolCallLoopGuard() {
@@ -78,8 +144,16 @@ export function disableToolCallLoopGuard() {
     consecutiveCount = 0;
     lastSignature = "";
     lastToolName = "";
+    perToolCounts.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/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

@@ -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-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/queries.js

@@ -12,6 +12,7 @@ import { rowToActiveDecision, rowToActiveRequirement, rowToDecision, rowToRequir
 import { rowToGate } from "../db-gate-rows.js";
 import { rowToArtifact, rowToMilestone } from "../db-milestone-artifact-rows.js";
 import { rowToSlice, rowToTask } from "../db-task-slice-rows.js";
+import { TERMINAL_STATUS_SQL } from "./sql-constants.js";
 function parseStringArrayColumn(raw) {
     if (Array.isArray(raw))
         return raw.filter((entry) => typeof entry === "string");
@@ -35,6 +36,44 @@ function parseStringArrayColumn(raw) {
 function normalizeRepoPath(file) {
     return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
 }
+function numberColumn(row, column) {
+    const value = row?.[column];
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "bigint")
+        return Number(value);
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function getCompletionCount(table) {
+    const row = getDbOrNull().prepare(`SELECT
+       COUNT(*) AS total,
+       COALESCE(SUM(CASE WHEN status IN (${TERMINAL_STATUS_SQL}) THEN 1 ELSE 0 END), 0) AS completed
+     FROM ${table}`).get();
+    return {
+        completed: numberColumn(row, "completed"),
+        total: numberColumn(row, "total"),
+    };
+}
+export function getHierarchyCompletionCounts() {
+    if (!getDbOrNull()) {
+        return { milestones: 0, milestonesTotal: 0, slices: 0, slicesTotal: 0, tasks: 0, tasksTotal: 0 };
+    }
+    const milestones = getCompletionCount("milestones");
+    const slices = getCompletionCount("slices");
+    const tasks = getCompletionCount("tasks");
+    return {
+        milestones: milestones.completed,
+        milestonesTotal: milestones.total,
+        slices: slices.completed,
+        slicesTotal: slices.total,
+        tasks: tasks.completed,
+        tasksTotal: tasks.total,
+    };
+}
 export function getDecisionById(id) {
     if (!getDbOrNull())
         return null;
@@ -391,6 +430,27 @@ export function getAssessment(path) {
     const row = getDbOrNull().prepare(`SELECT * FROM assessments WHERE path = :path`).get({ ":path": path });
     return row ?? null;
 }
+/**
+ * Look up a slice's `run-uat` assessment by (milestoneId, sliceId) identity,
+ * independent of the artifact `path`. Used as a DB fallback by the UAT
+ * closeout gate when a path migration orphans the ASSESSMENT markdown from its
+ * canonical expected path (ADR-017: DB-authoritative UAT sign-off).
+ *
+ * `status` holds the normalized verdict (`pass`/`fail`/…) written by
+ * `executeUatResultSave`; `fullContent` carries the ASSESSMENT body so callers
+ * can derive `uatType` without re-reading a file that may not exist.
+ */
+export function getSliceRunUatAssessment(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare(`SELECT status, full_content AS fullContent FROM assessments
+      WHERE milestone_id = :mid AND slice_id = :sid AND scope = 'run-uat'
+      ORDER BY created_at DESC, ROWID DESC
+      LIMIT 1`).get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row)
+        return null;
+    return { status: String(row["status"] ?? ""), fullContent: String(row["fullContent"] ?? "") };
+}
 export function getLatestAssessmentByScope(milestoneId, scope) {
     if (!getDbOrNull())
         return null;