@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.72e3af2a

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -1,7 +1,9 @@
 // gsd-pi + src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts - Handles provider and agent-end recovery for GSD auto-mode.
+import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { logWarning } from "../workflow-logger.js";
 import { checkDeepProjectSetupAfterTurn, checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
-import { clearPathCache } from "../paths.js";
+import { clearPathCache, gsdRoot } from "../paths.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, isAutoCompletionStopInProgress, pauseAuto, setCurrentDispatchedModelId, setCurrentUnitModelForRecovery, } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
@@ -11,7 +13,7 @@ import { resolveModelId } from "../auto-model-selection.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
 import { scheduleFallbackContinuation } from "./fallback-continuation.js";
-import { clearGuidedUnitContext } from "../guided-unit-context.js";
+import { clearGuidedUnitContext, getGuidedUnitContext } from "../guided-unit-context.js";
 import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
 import { blockModel, blockModelUntil, isModelBlocked, isModelTemporarilyUnavailable } from "../blocked-models.js";
@@ -78,10 +80,15 @@ export function isUserInitiatedAbortMessage(message) {
         return false;
     return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
 }
-export function shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg) {
+export function shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg, deferCheckMsg = rawErrorMsg) {
     if (!isTransient(cls) || cls.kind === "rate-limit")
         return false;
-    return !/retry failed after \d+ attempts:/i.test(rawErrorMsg);
+    // Empty rawErrorMsg means the SDK terminated the session without providing an
+    // error string — core is done, not mid-retry.  GSD must schedule its own
+    // retry rather than silently deferring to a core that has already exited.
+    if (!rawErrorMsg)
+        return false;
+    return !/retry failed after \d+ attempts:/i.test(deferCheckMsg);
 }
 /** Try configured fallbacks, then the auto-mode start model. Returns true if switched. */
 async function tryProviderModelFallback(params) {
@@ -277,6 +284,86 @@ export function suppressTerminalDeletedWorktreeMessageEnd(event) {
     logWarning("bootstrap", `Suppressing stale deleted-worktree provider error during terminal completion reroot: ${displayMsg || rawErrorMsg}`);
     return true;
 }
+function modelLabel(ctx) {
+    const provider = ctx.model?.provider;
+    const id = ctx.model?.id;
+    return provider && id ? `${provider}/${id}` : "unknown model";
+}
+function isFatalManualGuidedTerminalFailure(lastMsg) {
+    if (!isObjectRecord(lastMsg) || !("stopReason" in lastMsg))
+        return false;
+    if (lastMsg.stopReason === "error") {
+        const rawErrorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+        if (isUserInitiatedAbortMessage(rawErrorMsg))
+            return false;
+        return true;
+    }
+    if (lastMsg.stopReason !== "aborted")
+        return false;
+    const content = "content" in lastMsg ? lastMsg.content : undefined;
+    const hasErrorMessage = "errorMessage" in lastMsg && !!lastMsg.errorMessage;
+    return hasErrorMessage || !_hasEmptyAgentEndContent(content);
+}
+function terminalFailureDetail(lastMsg) {
+    if (!isObjectRecord(lastMsg))
+        return "Provider turn ended with an unknown terminal error.";
+    const rawErrorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+    const content = "content" in lastMsg ? lastMsg.content : undefined;
+    const displayMsg = resolveAgentEndErrorDisplay(rawErrorMsg, content).replace(/\s+/g, " ").trim();
+    if (displayMsg)
+        return displayMsg.length > 300 ? `${displayMsg.slice(0, 300)}...` : displayMsg;
+    return lastMsg.stopReason === "aborted"
+        ? "Provider turn aborted with error context."
+        : "Provider stream ended with stopReason=error.";
+}
+function nextManualActivitySequence(activityDir) {
+    let maxSeq = 0;
+    try {
+        for (const file of readdirSync(activityDir)) {
+            const match = /^(\d+)-/.exec(file);
+            if (match)
+                maxSeq = Math.max(maxSeq, Number.parseInt(match[1], 10));
+        }
+    }
+    catch {
+        return "001";
+    }
+    return String(maxSeq + 1).padStart(3, "0");
+}
+function writeManualGuidedTerminalErrorActivity(basePath, unitType, model, detail, stopReason) {
+    const activityDir = join(gsdRoot(basePath), "activity");
+    mkdirSync(activityDir, { recursive: true });
+    const seq = nextManualActivitySequence(activityDir);
+    const safeUnitType = unitType.replace(/[^a-z0-9_.-]+/gi, "-");
+    const markerPath = join(activityDir, `${seq}-${safeUnitType}-manual-terminal-provider-error.jsonl`);
+    const message = `Manual guided ${unitType} turn ended with provider ${String(stopReason)} on ${model}: ${detail}`;
+    writeFileSync(markerPath, JSON.stringify({
+        type: "message",
+        message: {
+            role: "toolResult",
+            toolCallId: "manual-guided-terminal-provider-error",
+            toolName: "provider",
+            isError: true,
+            content: [{ type: "text", text: message }],
+        },
+    }) + "\n", "utf-8");
+}
+function observeManualDiscussTerminalError(ctx, lastMsg, guidedUnit) {
+    if (!guidedUnit?.unitType.startsWith("discuss-"))
+        return;
+    if (!isFatalManualGuidedTerminalFailure(lastMsg))
+        return;
+    const model = modelLabel(ctx);
+    const detail = terminalFailureDetail(lastMsg);
+    ctx.ui.notify(`Manual /gsd discuss ${guidedUnit.unitType} ended with a provider error on ${model}: ${detail}`, "warning");
+    try {
+        writeManualGuidedTerminalErrorActivity(guidedUnit.basePath, guidedUnit.unitType, model, detail, isObjectRecord(lastMsg) ? lastMsg.stopReason : "unknown");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logWarning("bootstrap", `Failed to write manual guided terminal-error activity marker: ${message}`);
+    }
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -315,7 +402,9 @@ export async function handleAgentEnd(pi, event, ctx) {
     // rejected" loop even though the files are on disk.
     clearPathCache();
     const basePath = resolveAgentEndBasePath();
-    clearGuidedUnitContext(basePath);
+    const lastMsg = event.messages[event.messages.length - 1];
+    const guidedUnit = basePath ? getGuidedUnitContext(basePath) ?? getGuidedUnitContext() : getGuidedUnitContext();
+    clearGuidedUnitContext(guidedUnit?.basePath ?? basePath);
     try {
         if (await checkDeepProjectSetupAfterTurn(event, ctx, basePath)) {
             return;
@@ -342,12 +431,13 @@ export async function handleAgentEnd(pi, event, ctx) {
     // discussions (where isAutoActive may be false) still get recovered.
     if (maybeHandleEmptyIntentTurn(event, isAutoActive(), basePath))
         return;
-    if (!isAutoActive())
+    if (!isAutoActive()) {
+        observeManualDiscussTerminalError(ctx, lastMsg, guidedUnit);
         return;
+    }
     if (shouldIgnoreAgentEndForActiveUnit(event)) {
         return;
     }
-    const lastMsg = event.messages[event.messages.length - 1];
     if (isSessionSwitchInFlight()) {
         _handleSessionSwitchAgentEnd(lastMsg, resolveAgentEndCancelled);
         return;
@@ -435,9 +525,9 @@ export async function handleAgentEnd(pi, event, ctx) {
             });
             return;
         }
-        // #3588: When errorMessage is uninformative, extract the real error from
-        // the assistant message text content for display purposes only.
-        // Classification still uses rawErrorMsg to avoid false positives from prose.
+        // #3588/#956: When errorMessage is uninformative, extract the real error
+        // from assistant text. Prefer rawErrorMsg for classification to avoid
+        // prose false-positives, but use display text when rawErrorMsg is empty.
         const displayMsg = resolveAgentEndErrorDisplay(rawErrorMsg, "content" in lastMsg ? lastMsg.content : undefined);
         if (isAutoCompletionStopInProgress() &&
             isTerminalDeletedWorktreeProviderError(`${rawErrorMsg}\n${displayMsg}`)) {
@@ -447,8 +537,8 @@ export async function handleAgentEnd(pi, event, ctx) {
         }
         const errorDetail = displayMsg ? `: ${displayMsg}` : "";
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
-        // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
-        const cls = classifyError(rawErrorMsg, explicitRetryAfterMs);
+        // ── 1. Classify, preserving non-empty errorMessage precedence ──────
+        const cls = classifyError(rawErrorMsg || displayMsg, explicitRetryAfterMs);
         // ── 1a. Unsupported-model: provider rejected this model for the current
         //        account/plan at request time (#4513).  Persist a block so the
         //        same dead model isn't reselected on the next /gsd auto restart,
@@ -517,7 +607,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         // Core retries transient failures in-session after this handler.
         // Keep that behavior for non-rate-limit classes to avoid pause/retry races,
         // but let rate-limit continue into model fallback logic below (#4373).
-        if (shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg)) {
+        if (shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg, rawErrorMsg || displayMsg)) {
             return;
         }
         // ── Tool-schema overload: the active model repeatedly emitted tool-call

package/dist/resources/extensions/gsd/bootstrap/core-session-tools.js

@@ -0,0 +1,38 @@
+// Project/App: gsd-pi
+// File Purpose: Canonical core session tool surface shared by auto-mode scoping and loop guards.
+/** Base tools available during auto-mode execution before unit-specific GSD tools are added. */
+export const MINIMAL_AUTO_BASE_TOOL_NAMES = [
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "edit",
+    "find",
+    "glob",
+    "grep",
+    "fetch_page",
+    "search-the-web",
+    "ls",
+    "read",
+    "subagent",
+    "write",
+    "ToolSearch",
+];
+/** Tools excluded from the high per-turn loop-guard cap (strict or orchestration). */
+const NON_REPEATABLE_FROM_MINIMAL_BASE = new Set([
+    "ask_user_questions",
+    "subagent",
+    "ToolSearch",
+]);
+/** Additional core tools not in MINIMAL_AUTO_BASE but routinely multi-called per turn. */
+const EXTRA_INHERENTLY_REPEATABLE = [
+    "multi_edit",
+    "todo_write",
+    "notebook_edit",
+    "search_and_read",
+];
+/** Core session tools that may be invoked many times per agent turn. */
+export const INHERENTLY_REPEATABLE_TOOL_NAMES = [
+    ...MINIMAL_AUTO_BASE_TOOL_NAMES.filter((name) => !NON_REPEATABLE_FROM_MINIMAL_BASE.has(name)),
+    ...EXTRA_INHERENTLY_REPEATABLE,
+];
+export const INHERENTLY_REPEATABLE_TOOL_SET = new Set(INHERENTLY_REPEATABLE_TOOL_NAMES);

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

@@ -2,6 +2,7 @@
 // File Purpose: Registers DB-backed GSD workflow tools and compatibility aliases.
 import { Type, StringEnum } from "@gsd/pi-ai";
 import { Text } from "@gsd/pi-tui";
+import { SUMMARY_SAVE_CONTENT_MAX_LENGTH } from "@opengsd/contracts";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen, resolveCtxCwd, resolveWorkflowToolBasePath } from "./dynamic-tools.js";
 import { importWorkflowExecutorsModule } from "../workflow-mcp.js";
@@ -373,13 +374,17 @@ export function registerDbTools(pi) {
             "Root-level artifact paths are PROJECT.md, PROJECT-DRAFT.md, REQUIREMENTS.md, and REQUIREMENTS-DRAFT.md.",
             "artifact_type must be one of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT, CONTEXT-DRAFT, PROJECT, PROJECT-DRAFT, REQUIREMENTS, REQUIREMENTS-DRAFT.",
             "Use CONTEXT-DRAFT for incremental draft persistence; use CONTEXT for the final milestone context after depth verification.",
+            `Keep each content payload under ${SUMMARY_SAVE_CONTENT_MAX_LENGTH} characters; save large context incrementally with CONTEXT-DRAFT/PROJECT-DRAFT/REQUIREMENTS-DRAFT instead of one oversized call.`,
         ],
         parameters: Type.Object({
             milestone_id: Type.Optional(Type.String({ description: "Milestone ID (e.g. M001). Omit only for root-level PROJECT/PROJECT-DRAFT/REQUIREMENTS/REQUIREMENTS-DRAFT artifacts." })),
             slice_id: Type.Optional(Type.String({ description: "Slice ID (e.g. S01)" })),
             task_id: Type.Optional(Type.String({ description: "Task ID (e.g. T01)" })),
             artifact_type: StringEnum(["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT", "CONTEXT-DRAFT", "PROJECT", "PROJECT-DRAFT", "REQUIREMENTS", "REQUIREMENTS-DRAFT"], { description: "Artifact type to save" }),
-            content: Type.String({ description: "The full markdown content of the artifact" }),
+            content: Type.String({
+                description: `The full markdown content of the artifact. Maximum ${SUMMARY_SAVE_CONTENT_MAX_LENGTH} characters per save.`,
+                maxLength: SUMMARY_SAVE_CONTENT_MAX_LENGTH,
+            }),
         }),
         execute: summarySaveExecute,
         renderCall(args, theme) {

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";
@@ -15,6 +15,7 @@ import { loadFile, saveFile, formatContinue } from "../files.js";
 import { clearAutoCompletionStopInProgress, clearToolInvocationError, getAutoRuntimeSnapshot, getSourceObservationStore, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, isInteractiveElicitationInFlight, markToolEnd, markToolStart, recordAutoToolSurfaceSnapshot, recordToolInvocationError, } from "../auto-runtime-state.js";
 import { applyProviderPayloadPolicy } from "../provider-payload-policy.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
+import { MINIMAL_AUTO_BASE_TOOL_NAMES } from "./core-session-tools.js";
 import { maybePauseAutoForApprovalGate, resetPendingGatePauseGuard } from "./pending-gate-pause.js";
 import { saveActivityLog } from "../activity-log.js";
 import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult, saveEvidenceToDisk } from "../safety/evidence-collector.js";
@@ -138,22 +139,7 @@ export const MINIMAL_GSD_TOOL_NAMES = [
     "capture_thought",
     "gsd_capture_thought",
 ];
-export const MINIMAL_AUTO_BASE_TOOL_NAMES = [
-    "ask_user_questions",
-    "bash",
-    "bg_shell",
-    "edit",
-    "find",
-    "glob",
-    "grep",
-    "fetch_page",
-    "search-the-web",
-    "ls",
-    "read",
-    "subagent",
-    "write",
-    "ToolSearch",
-];
+export { MINIMAL_AUTO_BASE_TOOL_NAMES } from "./core-session-tools.js";
 function withPreservedShimTools(toolNames) {
     return [...new Set([...toolNames, ...ALWAYS_PRESERVED_SHIM_TOOL_NAMES])];
 }
@@ -436,6 +422,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 +998,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

@@ -1,25 +1,49 @@
 /**
  * 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. 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";
+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;
 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 +62,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 +81,37 @@ 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 perToolCount = (perToolCounts.get(toolName) ?? 0) + 1;
+    perToolCounts.set(toolName, perToolCount);
+    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 };
 }
 /** Reset the guard state. Call at agent turn boundaries. */
@@ -71,6 +120,7 @@ export function resetToolCallLoopGuard() {
     lastSignature = "";
     lastToolName = "";
     enabled = true;
+    perToolCounts.clear();
 }
 /** Disable the guard (e.g. during shutdown). */
 export function disableToolCallLoopGuard() {
@@ -78,8 +128,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 ?? {})));
                 }
             }
         }