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

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-0b507856bc29955a
+3da89e4dca62c288

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -285,8 +285,10 @@ export function buildPromptFromContext(context, toolContext = {}) {
         ? "- GSD workflow tools (gsd_exec, gsd_slice_complete, gsd_task_complete, gsd_plan_slice, gsd_save_gate_result, etc.) " +
             `are MCP tools — call them as mcp__${toolContext.workflowMcpServerName}__<tool_name> ` +
             `(e.g. mcp__${toolContext.workflowMcpServerName}__gsd_exec, mcp__${toolContext.workflowMcpServerName}__gsd_save_gate_result)\n` +
-            `- Structured user input: call mcp__${toolContext.workflowMcpServerName}__ask_user_questions. ` +
-            "Do not call bare ask_user_questions. Do not call native AskUserQuestion.\n"
+            (toolContext.questionToolAvailable !== false
+                ? `- Structured user input: call mcp__${toolContext.workflowMcpServerName}__ask_user_questions. ` +
+                    "Do not call bare ask_user_questions. Do not call native AskUserQuestion.\n"
+                : "")
         : "- GSD workflow MCP tools are unavailable in this Claude Code run.\n";
     const toolSearchLine = toolContext.workflowMcpServerName
         ? "- ToolSearch is available only for Claude Code deferred workflow MCP hydration. " +
@@ -1413,6 +1415,12 @@ function workflowMcpServerNameFromAllowedTools(allowedTools) {
     }
     return undefined;
 }
+function workflowQuestionToolAvailableFromAllowedTools(allowedTools, workflowMcpServerName, gsdPhase) {
+    if (!workflowMcpServerName || !gsdPhase)
+        return undefined;
+    return Array.isArray(allowedTools)
+        && allowedTools.includes(`mcp__${workflowMcpServerName}__ask_user_questions`);
+}
 function isRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -1821,6 +1829,7 @@ async function pumpSdkMessages(model, context, options, stream) {
         const prompt = buildPromptFromContext(context, {
             workflowMcpServerName,
             browserMcpServerName: browserMcpServerNameFromAllowedTools(sdkOpts.allowedTools),
+            questionToolAvailable: workflowQuestionToolAvailableFromAllowedTools(sdkOpts.allowedTools, workflowMcpServerName, gsdPhase),
         });
         const queryPrompt = buildSdkQueryPrompt(context, prompt);
         // Emit start with an empty partial

package/dist/resources/extensions/google-cli/stream-adapter.js

@@ -8,6 +8,64 @@ const ZERO_USAGE = {
     totalTokens: 0,
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 };
+const WINDOWS_CHILD_ENV_KEYS = new Set([
+    "ALLUSERSPROFILE",
+    "APPDATA",
+    "COMSPEC",
+    "COMMONPROGRAMFILES",
+    "COMMONPROGRAMFILES(X86)",
+    "FORCE_COLOR",
+    "HOME",
+    "HOMEDRIVE",
+    "HOMEPATH",
+    "LANG",
+    "LC_ALL",
+    "LOCALAPPDATA",
+    "NODE_EXTRA_CA_CERTS",
+    "NO_COLOR",
+    "NO_PROXY",
+    "PATHEXT",
+    "PATH",
+    "PROGRAMDATA",
+    "PROGRAMFILES",
+    "PROGRAMFILES(X86)",
+    "SSL_CERT_FILE",
+    "SYSTEMROOT",
+    "TEMP",
+    "TERM",
+    "TMP",
+    "TMPDIR",
+    "USER",
+    "USERNAME",
+    "USERPROFILE",
+    "WINDIR",
+    "XDG_CACHE_HOME",
+    "XDG_CONFIG_HOME",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+]);
+const WINDOWS_CHILD_ENV_PREFIXES = [
+    "AGY_",
+    "ANTIGRAVITY_",
+    "CLOUDSDK_",
+    "GEMINI_",
+    "GOOGLE_",
+];
+export function buildGoogleCliChildEnv(env = process.env, platform = process.platform) {
+    if (platform !== "win32")
+        return env;
+    const childEnv = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value !== "string")
+            continue;
+        const upperKey = key.toUpperCase();
+        if (WINDOWS_CHILD_ENV_KEYS.has(upperKey) ||
+            WINDOWS_CHILD_ENV_PREFIXES.some((prefix) => upperKey.startsWith(prefix))) {
+            childEnv[key] = value;
+        }
+    }
+    return childEnv;
+}
 function textBlocks(content) {
     return content
         .map((block) => block.type === "text" ? block.text : `[${block.type} omitted]`)
@@ -87,16 +145,16 @@ function extractGeminiJsonResponse(raw) {
 function commandForProvider(provider) {
     return provider === "google-gemini-cli" ? "gemini" : "agy";
 }
-function argsForProvider(provider, model, prompt) {
+function argsForProvider(provider, modelId, prompt) {
     if (provider === "google-gemini-cli") {
-        const args = ["-p", prompt, "--output-format", "json"];
-        if (model.id !== "default")
-            args.unshift("-m", model.id);
+        const args = prompt === undefined ? ["--output-format", "json"] : ["-p", prompt, "--output-format", "json"];
+        if (modelId !== "default")
+            args.unshift("-m", modelId);
         return args;
     }
-    const args = ["-p", prompt];
-    if (model.id !== "default")
-        args.unshift("-m", model.id);
+    const args = prompt === undefined ? [] : ["-p", prompt];
+    if (modelId !== "default")
+        args.unshift("-m", modelId);
     return args;
 }
 export function buildGoogleCliSpawnInvocation(command, args, platform = process.platform) {
@@ -105,13 +163,20 @@ export function buildGoogleCliSpawnInvocation(command, args, platform = process.
     }
     return { command, args };
 }
-function runCli(command, args, options) {
+export function buildGoogleCliRunPlan(provider, modelId, prompt, platform = process.platform) {
+    const pipePrompt = platform === "win32";
+    const args = argsForProvider(provider, modelId, pipePrompt ? undefined : prompt);
+    return {
+        ...buildGoogleCliSpawnInvocation(commandForProvider(provider), args, platform),
+        ...(pipePrompt ? { stdin: prompt } : {}),
+    };
+}
+function runCli(plan, options) {
     return new Promise((resolve, reject) => {
-        const invocation = buildGoogleCliSpawnInvocation(command, args);
-        const child = spawn(invocation.command, invocation.args, {
+        const child = spawn(plan.command, plan.args, {
             cwd: options?.cwd || process.cwd(),
-            env: process.env,
-            stdio: ["ignore", "pipe", "pipe"],
+            env: buildGoogleCliChildEnv(),
+            stdio: [plan.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
         });
         let stdout = "";
         let stderr = "";
@@ -132,6 +197,10 @@ function runCli(command, args, options) {
             return;
         }
         options?.signal?.addEventListener("abort", onAbort);
+        if (plan.stdin !== undefined) {
+            child.stdin?.on("error", () => { });
+            child.stdin?.end(plan.stdin);
+        }
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
         child.stdout.on("data", (chunk) => {
@@ -185,9 +254,7 @@ export function streamViaGoogleCli(model, context, options) {
     queueMicrotask(async () => {
         try {
             const prompt = buildGoogleCliPrompt(context);
-            const command = commandForProvider(provider);
-            const args = argsForProvider(provider, model, prompt);
-            const result = await runCli(command, args, options);
+            const result = await runCli(buildGoogleCliRunPlan(provider, model.id, prompt), options);
             if (result.code !== 0) {
                 const detail = (result.stderr || result.stdout || `CLI exited with code ${result.code}`).trim();
                 throw new Error(formatGoogleCliError(detail, provider));

package/dist/resources/extensions/gsd/auto/orchestrator.js

@@ -396,14 +396,17 @@ export class AutoOrchestrator {
         }
     }
     // ── UokGateAdapter (folded) ──────────────────────────────────────────────
-    async emitUokGate(input) {
+    resolveUokGateContext() {
         const activeBasePath = this.getLiveDispatchBasePath();
         const prefs = loadEffectiveGSDPreferencesWithRegistry(this.ctx.modelRegistry, activeBasePath, resolveProfileAnchorProvider(this.ctx.model?.provider, this.s.autoModeStartModel?.provider), this.s.autoModeStartModel
             ? `${this.s.autoModeStartModel.provider}/${this.s.autoModeStartModel.id}`
             : undefined)?.preferences;
-        const uokFlags = resolveUokFlags(prefs);
-        if (!uokFlags.gates)
+        return { activeBasePath, uokFlags: resolveUokFlags(prefs) };
+    }
+    async emitUokGate(input) {
+        if (!input.uokFlags.gates)
             return;
+        const activeBasePath = input.activeBasePath;
         const milestoneId = input.milestoneId ?? this.s.currentMilestoneId ?? undefined;
         try {
             const { UokGateRunner } = await import("../uok/gate-runner.js");
@@ -760,9 +763,11 @@ export class AutoOrchestrator {
         const stopAdvanceTimer = debugTime("orchestrator-advance");
         try {
             this.ensureLockOwnership();
+            const uokGateContext = this.resolveUokGateContext();
             const staleMsg = this.checkResourcesStale();
             if (staleMsg) {
                 await this.emitUokGate({
+                    ...uokGateContext,
                     gateId: "resource-version-guard",
                     gateType: "policy",
                     outcome: "fail",
@@ -776,6 +781,7 @@ export class AutoOrchestrator {
                 return blocked;
             }
             await this.emitUokGate({
+                ...uokGateContext,
                 gateId: "resource-version-guard",
                 gateType: "policy",
                 outcome: "pass",
@@ -785,6 +791,7 @@ export class AutoOrchestrator {
             const gate = await this.preAdvanceGate();
             if (gate.kind === "fail") {
                 await this.emitUokGate({
+                    ...uokGateContext,
                     gateId: "pre-dispatch-health-gate",
                     gateType: "execution",
                     outcome: "manual-attention",
@@ -803,6 +810,7 @@ export class AutoOrchestrator {
             }
             if (gate.kind === "threw") {
                 await this.emitUokGate({
+                    ...uokGateContext,
                     gateId: "pre-dispatch-health-gate",
                     gateType: "execution",
                     outcome: "manual-attention",
@@ -814,6 +822,7 @@ export class AutoOrchestrator {
             }
             else {
                 await this.emitUokGate({
+                    ...uokGateContext,
                     gateId: "pre-dispatch-health-gate",
                     gateType: "execution",
                     outcome: "pass",

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

@@ -2,7 +2,7 @@
 // File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { getUatBrowserToolSupportError } from "./uat-policy.js";
-import { isDbAvailable, getMilestoneSlices, getMilestoneSliceSummaries, getClosedSliceIds, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getMilestoneSliceSummaries, getClosedSliceIds, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, getSliceRunUatAssessment, } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { gsdRoot, resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relTaskFile, relSliceFile, relMilestoneFile, buildTaskFileName, gsdProjectionRoot, } from "./paths.js";
@@ -155,6 +155,18 @@ export async function readUatGateVerdict(basePath, mid, sliceId) {
             return { verdict: legacyUatVerdict, uatType };
         }
     }
+    // ADR-017 DB fallback: when the ASSESSMENT markdown is missing or orphaned
+    // from its canonical path (e.g. after a milestone artifact-layout migration
+    // moves slice artifacts from `phases/…` to `milestones/…`), consult the
+    // authoritative assessments table by (mid, slice) identity instead of path.
+    // `gsd_uat_result_save` always writes this row, so it is the source of truth.
+    const runUatAssessment = getSliceRunUatAssessment(mid, sliceId);
+    if (runUatAssessment?.status) {
+        return {
+            verdict: runUatAssessment.status,
+            uatType: uatType ?? extractUatType(runUatAssessment.fullContent),
+        };
+    }
     return null;
 }
 /**
@@ -919,16 +931,13 @@ export const DISPATCH_RULES = [
             const dbSlices = getMilestoneSliceSummaries(mid);
             if (dbSlices.length === 0)
                 return null;
-            // Find slices that need research (no RESEARCH file, dependencies done)
-            const milestoneResearchFile = resolveExistingExpectedArtifact("research-milestone", mid, basePath) ??
-                resolveMilestoneFile(basePath, mid, "RESEARCH");
+            // Find slices that need research (no RESEARCH file, dependencies done).
+            // Milestone research informs slice research; it does not satisfy the
+            // per-slice RESEARCH artifact contract.
             const researchReadySlices = [];
             for (const slice of dbSlices) {
                 if (slice.done)
                     continue;
-                // Skip S01 when milestone research exists
-                if (milestoneResearchFile && slice.id === "S01")
-                    continue;
                 // Skip if already has research
                 if (resolveExistingExpectedArtifact("research-slice", `${mid}/${slice.id}`, basePath))
                     continue;
@@ -957,7 +966,7 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "planning (no research, not S01) → research-slice",
+        name: "planning (no research) → research-slice",
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
             if (state.phase !== "planning")
                 return null;
@@ -975,12 +984,6 @@ export const DISPATCH_RULES = [
                 resolveSliceFile(basePath, mid, sid, "RESEARCH");
             if (researchFile)
                 return null; // has research, fall through
-            // Skip slice research for S01 when milestone research already exists —
-            // the milestone research already covers the same ground for the first slice.
-            const milestoneResearchFile = resolveExistingExpectedArtifact("research-milestone", mid, basePath) ??
-                resolveMilestoneFile(basePath, mid, "RESEARCH");
-            if (milestoneResearchFile && sid === "S01")
-                return null; // fall through to plan-slice
             return {
                 action: "dispatch",
                 unitType: "research-slice",

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

@@ -14,7 +14,7 @@ import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksD
 import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
 import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
 import { getPendingGatesForTurn } from "./gsd-db.js";
@@ -23,6 +23,7 @@ import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { composeContextModeInstructions, composeContractedUnitContext, composeInlinedContext, composeToolSurfaceInstructions, composeUnitContext, } from "./unit-context-composer.js";
 import { resolveManifest } from "./unit-context-manifest.js";
+import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
 import { compileUnitContextContract } from "./tool-contract.js";
 import { readCompactionSnapshot } from "./compaction-snapshot.js";
 import { logWarning } from "./workflow-logger.js";
@@ -247,14 +248,37 @@ function requireComposedArtifactBlock(blocks, unitType, key) {
     return block.body;
 }
 function renderExecuteTaskOnDemandContext(base, mid, sid, artifacts) {
-    if (!artifacts.includes("slice-research"))
-        return "";
-    const researchPath = relSliceFile(base, mid, sid, "RESEARCH");
-    return [
-        "## On-demand Context",
-        "",
-        `Slice research is available at \`${researchPath}\`. Read it only if the inlined task plan, slice plan excerpt, and carry-forward context do not explain a required implementation detail.`,
-    ].join("\n");
+    if (!artifacts.includes("slice-research")) {
+        return { text: "", skipReason: "not declared by contract" };
+    }
+    // Mirror dispatch's dual-resolution logic: worktree projection path first,
+    // then the authoritative project-root path via resolveExpectedArtifactPath.
+    // In worktree layouts the RESEARCH file may live under the project-root .gsd
+    // and not have been copied into the worktree projection, so resolveSliceFile
+    // (which looks only at gsdProjectionRoot) would miss it while dispatch would
+    // still treat research as satisfied.
+    const projectedFile = resolveSliceFile(base, mid, sid, "RESEARCH");
+    const researchFile = projectedFile ?? (() => {
+        const p = resolveExpectedArtifactPath("research-slice", `${mid}/${sid}`, base);
+        return p && existsSync(p) ? p : null;
+    })();
+    if (!researchFile) {
+        return { text: "", skipReason: "missing" };
+    }
+    // Use the layout-aware relative path when the file is in the worktree
+    // projection (relSliceFile), or fall back to node:path relative() when the
+    // file was only found via the project-root resolution path.
+    const researchPath = projectedFile
+        ? relSliceFile(base, mid, sid, "RESEARCH")
+        : relative(base, researchFile);
+    return {
+        text: [
+            "## On-demand Context",
+            "",
+            `Slice research is available at \`${researchPath}\`. Read it only if the inlined task plan, slice plan excerpt, and carry-forward context do not explain a required implementation detail.`,
+        ].join("\n"),
+        skipReason: null,
+    };
 }
 // ─── Executor Constraints ─────────────────────────────────────────────────────
 /**
@@ -1459,7 +1483,13 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
     const draftPath = resolveMilestoneFile(base, mid, "CONTEXT-DRAFT");
     const draftContent = draftPath ? await loadFile(draftPath) : null;
     if (includeDraftSeed && draftContent) {
-        return `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${draftContent}`;
+        const draftRelPath = relMilestoneFile(base, mid, "CONTEXT-DRAFT");
+        const draftSeed = `### Prior Discussion Draft\nSource: \`${draftRelPath}\`\n\n${draftContent.trim()}`;
+        const cappedDraftSeed = capPreamble(draftSeed);
+        const truncationNote = cappedDraftSeed !== draftSeed
+            ? `\n\n_(Draft seed truncated; read the full draft at \`${draftRelPath}\` if needed.)_`
+            : "";
+        return `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${cappedDraftSeed}${truncationNote}`;
     }
     return promptWithContextMode;
 }
@@ -2405,8 +2435,9 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const slicePlanExcerpt = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "slice-plan");
     const contractedCarryForward = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "prior-task-summaries");
     const contractedTemplates = requireComposedArtifactBlock(contractedContext.blocks, "execute-task", "templates");
-    const onDemandContext = renderExecuteTaskOnDemandContext(base, mid, sid, contractedContext.onDemand);
-    trackPromptContext(contextTelemetry, "slice-research", onDemandContext ? "on-demand" : "skipped", onDemandContext, onDemandContext ? undefined : "not declared by contract");
+    const onDemandResult = renderExecuteTaskOnDemandContext(base, mid, sid, contractedContext.onDemand);
+    const onDemandContext = onDemandResult.text;
+    trackPromptContext(contextTelemetry, "slice-research", onDemandContext ? "on-demand" : "skipped", onDemandContext, onDemandContext ? undefined : onDemandResult.skipReason ?? undefined);
     const prompt = loadPrompt("execute-task", {
         overridesSection,
         runtimeContext,

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

@@ -452,14 +452,21 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // discuss-milestone unit with CONTEXT at phases/NN-slug/ in the project root
     // but not in the worktree resolves to null → "resolveExpectedArtifactPath
     // returned null" → finalize-retry loop (#852).
-    if (artifactBase !== base) {
+    //
+    // #870: the fallback must fire whenever the artifact is missing at
+    // `artifactBase`, NOT only when `artifactBase !== base`. When the real call
+    // site passes the worktree path as `base` (auto-post-unit.ts:1726 uses
+    // `s.currentUnit.workspaceRoot ?? s.basePath`), resolveCanonicalMilestoneRoot
+    // round-trips the worktree path back to itself, so `artifactBase === base`
+    // while still being a worktree path that lacks the projected artifact. The
+    // old `if (artifactBase !== base)` guard skipped the fallback in exactly that
+    // case, stranding CONTEXT at the project root and producing a stuck-loop.
+    if (!absPath || !existsSync(absPath)) {
         const projectRoot = resolve(resolveWorktreeProjectRoot(artifactBase));
         if (projectRoot && projectRoot !== artifactBase) {
-            if (!absPath || !existsSync(absPath)) {
-                const projectPath = resolveExpectedArtifactPath(unitType, unitId, projectRoot);
-                if (projectPath && existsSync(projectPath)) {
-                    absPath = projectPath;
-                }
+            const projectPath = resolveExpectedArtifactPath(unitType, unitId, projectRoot);
+            if (projectPath && existsSync(projectPath)) {
+                absPath = projectPath;
             }
         }
     }

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/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) {