@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/dist/read-cli.js

@@ -0,0 +1,90 @@
+/**
+ * `gsd read` — JSON read seam for integrations (Hermes 6c).
+ *
+ *   gsd read progress --json --project /path
+ *   gsd read roadmap --json --project /path [--milestone M001]
+ *   gsd read memory --json --project /path --query "auth"
+ */
+import { resolve } from 'node:path';
+import { graphQuery } from '@opengsd/mcp-server/readers/graph';
+import { resolveGsdRoot } from '@opengsd/mcp-server/readers/paths';
+import { readRoadmap } from '@opengsd/mcp-server/readers/roadmap';
+import { readProgress } from '@opengsd/mcp-server/readers/state';
+export const INTEGRATION_VERSION = 1;
+function parseReadArgs(argv) {
+    const readIndex = argv.indexOf('read', 2);
+    if (readIndex === -1)
+        return null;
+    const args = argv.slice(readIndex + 1);
+    if (args.length < 1)
+        return null;
+    const kind = args[0];
+    if (!['progress', 'roadmap', 'memory'].includes(kind))
+        return null;
+    let project;
+    let milestone;
+    let query;
+    let json = false;
+    for (let i = 1; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--json')
+            json = true;
+        else if (a === '--project' && i + 1 < args.length)
+            project = args[++i];
+        else if (a === '--milestone' && i + 1 < args.length)
+            milestone = args[++i];
+        else if (a === '--query' && i + 1 < args.length)
+            query = args[++i];
+    }
+    if (!project)
+        return null;
+    return { kind, project, milestone, query, json };
+}
+export async function runReadCli(argv) {
+    const opts = parseReadArgs(argv);
+    if (!opts) {
+        process.stderr.write('Usage: gsd read <progress|roadmap|memory> --json --project <path> [--milestone M001] [--query text]\n');
+        return 1;
+    }
+    const projectDir = resolve(opts.project);
+    try {
+        resolveGsdRoot(projectDir);
+    }
+    catch (err) {
+        process.stderr.write(`[gsd read] ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    let data;
+    switch (opts.kind) {
+        case 'progress':
+            data = readProgress(projectDir);
+            break;
+        case 'roadmap':
+            data = readRoadmap(projectDir, opts.milestone);
+            break;
+        case 'memory': {
+            const term = opts.query?.trim() || '';
+            if (term.length < 2) {
+                process.stderr.write('[gsd read] memory requires --query with at least 2 characters\n');
+                return 1;
+            }
+            data = await graphQuery(projectDir, term);
+            break;
+        }
+        default:
+            return 1;
+    }
+    const envelope = {
+        integration_version: INTEGRATION_VERSION,
+        kind: opts.kind,
+        projectDir,
+        data,
+    };
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(envelope, null, 2) + '\n');
+    }
+    else {
+        process.stdout.write(JSON.stringify(envelope.data, null, 2) + '\n');
+    }
+    return 0;
+}

package/dist/resource-loader.d.ts

@@ -61,9 +61,9 @@ export declare function mergedFingerprint(hoisted: string, internal: string): st
  * - gsd-browser skill → ~/.gsd/agent/skills/gsd-browser/ from @opengsd/gsd-browser
  * - GSD-WORKFLOW.md → ~/.gsd/agent/GSD-WORKFLOW.md (fallback for env var miss)
  *
- * Skips the full copy only when the managed-resources.json version, content
- * fingerprint, and package-owned gsd-browser skill all match the current
- * install, avoiding ~128ms of synchronous cpSync on steady-state startup.
+ * Skips the full copy when the managed-resources.json version and content
+ * fingerprint match the current install, avoiding ~128ms of synchronous cpSync
+ * on steady-state startup.
  * After `npm update -g @opengsd/gsd-pi`, versions will differ and the copy
  * runs once to land the new resources.
  *

package/dist/resource-loader.js

@@ -676,9 +676,9 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
  * - gsd-browser skill → ~/.gsd/agent/skills/gsd-browser/ from @opengsd/gsd-browser
  * - GSD-WORKFLOW.md → ~/.gsd/agent/GSD-WORKFLOW.md (fallback for env var miss)
  *
- * Skips the full copy only when the managed-resources.json version, content
- * fingerprint, and package-owned gsd-browser skill all match the current
- * install, avoiding ~128ms of synchronous cpSync on steady-state startup.
+ * Skips the full copy when the managed-resources.json version and content
+ * fingerprint match the current install, avoiding ~128ms of synchronous cpSync
+ * on steady-state startup.
  * After `npm update -g @opengsd/gsd-pi`, versions will differ and the copy
  * runs once to land the new resources.
  *
@@ -712,16 +712,7 @@ export function initResources(agentDir, skillsDir = join(agentDir, 'skills')) {
     if (manifest && isCurrentPackageManifest(manifest) && manifest.gsdVersion === currentVersion) {
         // Version matches — check content fingerprint for same-version staleness.
         const currentHash = getCurrentResourceFingerprint();
-        const hasStaleExtensionFiles = hasStaleCompiledExtensionSiblings(extensionsDir, bundledExtensionsDir);
-        const hasMissingSharedFiles = hasMissingBundledResourceFiles(join(agentDir, 'shared'), join(resourcesDir, 'shared'));
-        const hasMissingSkillFiles = hasMissingBundledResourceFiles(skillsDir, join(resourcesDir, 'skills'));
-        const hasStaleGsdBrowserSkill = hasStaleGsdBrowserPackageSkill(skillsDir);
-        if (manifest.contentHash &&
-            manifest.contentHash === currentHash &&
-            !hasStaleExtensionFiles &&
-            !hasMissingSharedFiles &&
-            !hasMissingSkillFiles &&
-            !hasStaleGsdBrowserSkill) {
+        if (manifest.contentHash && manifest.contentHash === currentHash) {
             return;
         }
     }

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

@@ -1 +1 @@
-e6a2fdc55c9bdca7
+0b507856bc29955a

package/dist/resources/GSD-WORKFLOW.md

@@ -5,7 +5,7 @@
 > **When to read this:** At the start of any session working on GSD-managed work, or when loaded by `/gsd`.
 >
 > **After reading this, always read `.gsd/STATE.md` to find out what's next.**
-> If the milestone has a `M###-CONTEXT.md`, read that too. If the active slice has an `S##-CONTEXT.md`, read that as well — these files contain project-specific decisions, reference paths, and implementation guidance that this generic methodology doc does not.
+> If the milestone has a `CONTEXT.md`, read that too. If the active slice has an `S##-CONTEXT.md`, read that as well — these files contain project-specific decisions, reference paths, and implementation guidance that this generic methodology doc does not.
 
 ---
 
@@ -14,8 +14,8 @@
 Read these files in order and act on what they say:
 
 1. **`.gsd/STATE.md`** — Where are we? What's the next action?
-2. **`.gsd/milestones/<active>/M###-ROADMAP.md`** — What's the plan? Which slices are done? (`STATE.md` tells you which milestone is active)
-3. **`.gsd/milestones/<active>/M###-CONTEXT.md`** — Milestone-level project decisions, reference paths, constraints. Read this before doing implementation work.
+2. **`.gsd/phases/<active>/ROADMAP.md`** — What's the plan? Which slices are done? (`STATE.md` tells you which milestone is active)
+3. **`.gsd/phases/<active>/CONTEXT.md`** — Milestone-level project decisions, reference paths, constraints. Read this before doing implementation work.
 4. If a slice is active and has one, read **`S##-CONTEXT.md`** — Slice-specific decisions and constraints.
 5. If a slice is active, read its **`S##-PLAN.md`** — Which tasks exist? Which are done?
 6. If `.gsd/CODEBASE.md` exists, skim it for fast structural orientation before broad code exploration.
@@ -46,7 +46,7 @@ All artifacts live in `.gsd/` at the project root:
   STATE.md                                  # Dashboard — always read first (derived cache; runtime, gitignored)
   DECISIONS.md                              # Append-only decisions register
   CODEBASE.md                               # Generated codebase map cache (auto-refreshed by GSD)
-  milestones/
+  phases/
     M001/
       M001-ROADMAP.md                       # Milestone plan (checkboxes = state)
       M001-CONTEXT.md                       # Optional: user decisions from discuss phase
@@ -69,7 +69,7 @@ All artifacts live in `.gsd/` at the project root:
 
 ## File Format Reference
 
-### `M###-ROADMAP.md`
+### `ROADMAP.md`
 
 ```markdown
 # M001: Title of the Milestone
@@ -96,7 +96,7 @@ All artifacts live in `.gsd/` at the project root:
 
 **Parsing rules:** `- [x]` = done, `- [ ]` = not done. The `risk:` and `depends:[]` tags are inline metadata parsed from the line. `depends:[]` lists slice IDs this slice requires to be complete first.
 
-**Boundary Map** (required section in M###-ROADMAP.md):
+**Boundary Map** (required section in ROADMAP.md):
 
 After the slices section, include a `## Boundary Map` that shows what each slice produces and consumes:
 
@@ -212,7 +212,7 @@ Critical wiring between artifacts:
 Exact next thing to do.
 ```
 
-### `M###-CONTEXT.md` / `S##-CONTEXT.md` (from discuss phase)
+### `CONTEXT.md` / `S##-CONTEXT.md` (from discuss phase)
 
 ```markdown
 # M001: Milestone or Slice Title — Context
@@ -268,7 +268,7 @@ Work flows through these phases. Each phase produces a file.
 ### Phase 1: Discuss (Optional)
 
 **Purpose:** Capture user decisions on gray areas before planning.
-**Produces:** `M###-CONTEXT.md` for milestone-level discussion or `S##-CONTEXT.md` for slice-level discussion.
+**Produces:** `CONTEXT.md` for milestone-level discussion or `S##-CONTEXT.md` for slice-level discussion.
 **When to use:** When the scope has ambiguities the user should weigh in on.
 **When to skip:** When the user already knows exactly what they want, or told you to just go.
 
@@ -276,7 +276,7 @@ Work flows through these phases. Each phase produces a file.
 1. Read the roadmap to understand the scope.
 2. Identify 3-5 gray areas — implementation decisions the user cares about.
 3. Use `ask_user_questions` to discuss each area, one round at a time. Never fabricate user input; wait for the user's actual response before the next round.
-4. Write decisions to the appropriate context file (`M###-CONTEXT.md` or `S##-CONTEXT.md`).
+4. Write decisions to the appropriate context file (`CONTEXT.md` or `S##-CONTEXT.md`).
 5. Do NOT discuss how to implement — only what the user wants.
 
 ### Phase 2: Research (Optional)
@@ -287,7 +287,7 @@ Work flows through these phases. Each phase produces a file.
 **When to skip:** When the codebase is familiar and the work is straightforward.
 
 **How to do it manually:**
-1. Read `M###-CONTEXT.md` and/or `S##-CONTEXT.md` if they exist — know what decisions are locked.
+1. Read `CONTEXT.md` and/or `S##-CONTEXT.md` if they exist — know what decisions are locked.
 2. Scout relevant code: `rg`, `find`, read key files.
 3. Use `resolve_library` / `get_library_docs` if needed.
 4. Write findings to `research.md` with these sections:
@@ -330,15 +330,15 @@ The **Don't Hand-Roll** and **Common Pitfalls** sections prevent the most expens
 **Produces:** `S##-PLAN.md` + individual `T01-PLAN.md` files.
 
 **For a milestone (roadmap):**
-1. Read `M###-CONTEXT.md`, `M###-RESEARCH.md`, and `.gsd/DECISIONS.md` if they exist.
+1. Read `CONTEXT.md`, `M###-RESEARCH.md`, and `.gsd/DECISIONS.md` if they exist.
 2. Decompose the vision into 1-10 demoable vertical slices. Prefer one slice for tiny, single-file, or static work unless the request clearly spans independent capabilities.
 3. Order by risk (high-risk first to validate feasibility early).
-4. Write `M###-ROADMAP.md` with checkboxes, risk levels, dependencies, demo sentences.
+4. Write `ROADMAP.md` with checkboxes, risk levels, dependencies, demo sentences.
 5. **Write the boundary map** — for each slice, specify what it produces (functions, types, interfaces, endpoints) and what it consumes from upstream slices. This forces interface thinking before implementation and enables deterministic verification that slices actually connect.
 
 **For a slice (task decomposition):**
-1. Read the slice's entry in `M###-ROADMAP.md` **and its boundary map section** — know what interfaces this slice must produce and consume.
-2. Read `M###-CONTEXT.md`, `S##-CONTEXT.md`, `M###-RESEARCH.md`, `S##-RESEARCH.md`, and `.gsd/DECISIONS.md` if they exist for this slice.
+1. Read the slice's entry in `ROADMAP.md` **and its boundary map section** — know what interfaces this slice must produce and consume.
+2. Read `CONTEXT.md`, `S##-CONTEXT.md`, `M###-RESEARCH.md`, `S##-RESEARCH.md`, and `.gsd/DECISIONS.md` if they exist for this slice.
 3. Read summaries from dependency slices (check `depends:[]` in roadmap).
 4. Verify that upstream slices' actual outputs match what the boundary map says this slice consumes. If they diverge, update the boundary map.
 5. Decompose into 1-7 tasks, each fitting one context window.
@@ -424,7 +424,7 @@ key_decisions:
 patterns_established:
   - "Pattern name and where it lives"
 drill_down_paths:
-  - .gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md
+  - .gsd/phases/M001/slices/S01/tasks/T01-PLAN.md
 duration: 15min
 verification_result: pass
 completed_at: 2026-03-07T16:00:00Z
@@ -466,12 +466,12 @@ key_decisions: []
 **After a task completes:**
 1. Mark the task done in `S##-PLAN.md` (checkbox).
 2. Check if there's a next task in the slice → execute it.
-3. If slice is complete → write slice summary, mark slice done in `M###-ROADMAP.md`.
+3. If slice is complete → write slice summary, mark slice done in `ROADMAP.md`.
 
 **After a slice completes:**
 1. Write slice `S##-SUMMARY.md` (compresses all task summaries).
 2. Write slice `S##-UAT.md` — a human test script derived from the slice's must-haves and demo sentence.
-3. Mark the slice checkbox in `M###-ROADMAP.md` as `[x]`.
+3. Mark the slice checkbox in `ROADMAP.md` as `[x]`.
 4. Update `STATE.md` with new position.
 5. Update milestone `M###-SUMMARY.md` with the completed slice's contributions.
 6. Continue to next slice immediately. UAT can run after slice completion; automatic milestone closure requires each slice assessment to record `PASS`.
@@ -528,7 +528,7 @@ The EXACT first thing to do when resuming. Not vague. Specific.
 It is NOT the source of truth. It's a convenience dashboard.
 
 **Sources of truth:**
-- `M###-ROADMAP.md` → which slices exist and which are done
+- `ROADMAP.md` → which slices exist and which are done
 - `S##-PLAN.md` → which tasks exist within a slice
 - `T##-SUMMARY.md` → what happened during a task
 - `S##-SUMMARY.md` and `M###-SUMMARY.md` → compressed slice and milestone outcomes
@@ -614,7 +614,7 @@ Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`
 
 When planning or executing a task, load relevant prior context:
 
-1. Check the current slice's `depends:[]` in `M###-ROADMAP.md`.
+1. Check the current slice's `depends:[]` in `ROADMAP.md`.
 2. Load summaries from those dependency slices.
 3. Start with the **highest available level** — milestone `M###-SUMMARY.md` first.
 4. Only drill down to slice/task summaries if you need specific detail.
@@ -635,10 +635,10 @@ These are soft caps — exceed them when genuinely needed, but don't let summari
 
 This methodology doc is generic. Project-specific guidance belongs in the milestone and slice context files:
 
-- **`.gsd/milestones/<active>/M###-CONTEXT.md`** — milestone-level architecture decisions, reference file paths, and implementation constraints
-- **`.gsd/milestones/<active>/slices/S##/S##-CONTEXT.md`** — slice-level decisions, edge cases, and narrow implementation guidance when present
+- **`.gsd/phases/<active>/CONTEXT.md`** — milestone-level architecture decisions, reference file paths, and implementation constraints
+- **`.gsd/phases/<active>/slices/S##/S##-CONTEXT.md`** — slice-level decisions, edge cases, and narrow implementation guidance when present
 
-**Always read the active milestone's `M###-CONTEXT.md` before starting implementation work.** If the active slice also has `S##-CONTEXT.md`, read that too. These files tell you what decisions are locked, what files to reference, and how to verify your work in this specific project.
+**Always read the active milestone's `CONTEXT.md` before starting implementation work.** If the active slice also has `S##-CONTEXT.md`, read that too. These files tell you what decisions are locked, what files to reference, and how to verify your work in this specific project.
 
 ---
 

package/dist/resources/extensions/claude-code-cli/index.js

@@ -12,8 +12,14 @@
  */
 import { CLAUDE_CODE_MODELS } from "./models.js";
 import { isClaudeCodeReady } from "./readiness.js";
-import { streamViaClaudeCode } from "./stream-adapter.js";
+import { setClaudeCodeUIContext, streamViaClaudeCode } from "./stream-adapter.js";
 export default function claudeCodeCli(pi) {
+    // Core calls `streamSimple` with a plain `SimpleStreamOptions` (no UI
+    // context), so the elicitation handler used by `ask_user_questions` is
+    // otherwise never wired and self-cancels. Capture the live UI context here.
+    pi.on("before_provider_request", (_event, ctx) => {
+        setClaudeCodeUIContext(ctx.hasUI ? ctx.ui : undefined);
+    });
     pi.registerProvider("claude-code", {
         authMode: "externalCli",
         api: "anthropic-messages",

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

@@ -28,6 +28,7 @@ import { getUnitToolSurfaceContract } from "../gsd/unit-tool-contracts.js";
 import { awaitWorkflowMcpToolRegistration, getToolSurfaceReadinessError, POST_PREFLIGHT_READINESS_RETRY_DELAYS_MS, POST_PREFLIGHT_SDK_SETTLE_MS, TOOL_SURFACE_NOT_READY, } from "../gsd/tool-surface-readiness.js";
 import { beginWorkflowMcpSdkSession, endWorkflowMcpSdkSession, } from "../gsd/workflow-mcp-readiness-cache.js";
 import { getGuidedUnitContext } from "../gsd/guided-unit-context.js";
+import { getActiveAutoUnitType, isAutoActive } from "../gsd/auto-runtime-state.js";
 import { hasBrowserContractPrefix } from "../shared/browser-contract.js";
 import { showInterviewRound } from "../shared/tui.js";
 export { buildFinalAssistantContent, extractToolResultsFromSdkUserMessage, handleClaudeCodePartialStreamEvent, mergePendingToolCalls, shouldSuppressDuplicateToolUnavailableBlock, } from "./turn-assembler.js";
@@ -175,30 +176,44 @@ function extractMessageText(msg) {
     }
     return "";
 }
+// Patterns are anchored to the `UNIT: <Phase>` dispatch header ONLY. The old
+// patterns also matched bare slugs (`run-uat`, `plan-slice`, `gsd_plan_slice`,
+// …) anywhere in the text, so any incidental occurrence — a branch name like
+// `milestone/M039`, an untracked file `m039-s05-…spec.ts`, a forensic report,
+// or the user literally typing "slice"/"UAT" while describing a problem — would
+// misclassify the turn as a dispatched unit. Only the dispatch header is an
+// authoritative phase signal, so match nothing else.
 const GSD_PHASE_PATTERNS = [
-    ["run-uat", /\b(?:UNIT:\s*Run UAT|run-uat)\b/i],
-    ["complete-milestone", /\b(?:UNIT:\s*Complete Milestone|complete-milestone)\b/i],
-    ["validate-milestone", /\b(?:UNIT:\s*Validate Milestone|validate-milestone)\b/i],
-    ["reassess-roadmap", /\b(?:UNIT:\s*Reassess Roadmap|reassess-roadmap)\b/i],
-    ["complete-slice", /\b(?:UNIT:\s*Complete Slice|complete-slice)\b/i],
-    ["replan-slice", /\b(?:UNIT:\s*Replan Slice|replan-slice)\b/i],
-    ["refine-slice", /\b(?:UNIT:\s*Refine Slice|refine-slice)\b/i],
-    ["plan-slice", /\b(?:UNIT:\s*Plan Slice|plan-slice|gsd_plan_slice)\b/i],
-    ["plan-milestone", /\b(?:UNIT:\s*Plan Milestone|plan-milestone|gsd_plan_milestone)\b/i],
-    ["execute-task", /\b(?:UNIT:\s*Execute Task|execute-task|execute-task-simple|reactive-execute)\b/i],
-    ["gate-evaluate", /\b(?:UNIT:\s*Gate Evaluate|gate-evaluate|gsd_save_gate_result)\b/i],
-    ["research-milestone", /\b(?:UNIT:\s*Research Milestone|research-milestone)\b/i],
-    ["research-slice", /\b(?:UNIT:\s*Research Slice|research-slice)\b/i],
-    ["research-decision", /\b(?:research decision|research-decision)\b/i],
-    ["discuss-milestone", /\b(?:Discuss milestone|discuss-milestone)\b/i],
-    ["discuss-slice", /\b(?:Discuss slice|discuss-slice)\b/i],
-    ["discuss-project", /\b(?:discuss-project|Discuss project)\b/i],
-    ["discuss-requirements", /\b(?:discuss-requirements|Discuss requirements)\b/i],
+    ["run-uat", /\bUNIT:\s*Run UAT\b/i],
+    ["complete-milestone", /\bUNIT:\s*Complete Milestone\b/i],
+    ["validate-milestone", /\bUNIT:\s*Validate Milestone\b/i],
+    ["reassess-roadmap", /\bUNIT:\s*Reassess Roadmap\b/i],
+    ["complete-slice", /\bUNIT:\s*Complete Slice\b/i],
+    ["replan-slice", /\bUNIT:\s*Replan Slice\b/i],
+    ["refine-slice", /\bUNIT:\s*Refine Slice\b/i],
+    ["plan-slice", /\bUNIT:\s*Plan Slice\b/i],
+    ["plan-milestone", /\bUNIT:\s*Plan Milestone\b/i],
+    ["execute-task", /\bUNIT:\s*Execute Task\b/i],
+    ["gate-evaluate", /\bUNIT:\s*Gate Evaluate\b/i],
+    ["research-milestone", /\bUNIT:\s*Research Milestone\b/i],
+    ["research-slice", /\bUNIT:\s*Research Slice\b/i],
+    ["research-decision", /\bUNIT:\s*Research Decision\b/i],
+    ["discuss-milestone", /\bUNIT:\s*Discuss Milestone\b/i],
+    ["discuss-slice", /\bUNIT:\s*Discuss Slice\b/i],
+    ["discuss-project", /\bUNIT:\s*Discuss Project\b/i],
+    ["discuss-requirements", /\bUNIT:\s*Discuss Requirements\b/i],
 ];
+/** The set of GSD phases this adapter recognises, derived from the patterns above. */
+const KNOWN_GSD_PHASES = new Set(GSD_PHASE_PATTERNS.map(([phase]) => phase));
 export function inferGsdPhaseFromContext(context) {
+    // Scan only the system prompt and the most recent user directive. Scanning
+    // the entire scrollback let a phase header that merely appeared in history
+    // (e.g. a SUMMARY the agent read, or a pasted prior dispatch) re-classify
+    // every subsequent turn.
+    const lastUser = [...context.messages].reverse().find((m) => m.role === "user");
     const text = [
         context.systemPrompt ?? "",
-        ...context.messages.map((message) => extractMessageText(message)),
+        lastUser ? extractMessageText(lastUser) : "",
     ].join("\n");
     for (const [phase, pattern] of GSD_PHASE_PATTERNS) {
         if (pattern.test(text))
@@ -222,6 +237,26 @@ export function resolveGsdPhaseForSdk(context, projectRoot) {
             return guided.unitType;
         }
     }
+    // Auto-mode records the dispatched unit type before each turn — that is the
+    // authoritative phase, so prefer it over any inference. (Guided interactive
+    // dispatch is handled above via getGuidedUnitContext.) Ignore `hook/*`
+    // pseudo-units and anything not a recognised GSD phase.
+    const autoUnit = getActiveAutoUnitType();
+    if (autoUnit && KNOWN_GSD_PHASES.has(autoUnit)) {
+        return autoUnit;
+    }
+    // No authoritative guided/auto signal → ad-hoc turn. Do NOT regex-infer a
+    // phase from prose: that would fire the workflow MCP preflight and, for
+    // run-uat, strip Bash/Write/Edit/gsd_exec for the rest of the session the
+    // moment the conversation (or the GSD system prompt itself) happened to
+    // mention a phase token. An ad-hoc turn keeps the full tool surface.
+    //
+    // The header-anchored inference remains only as a last resort while auto is
+    // running but the current unit wasn't recorded for some reason; even then it
+    // matches the `UNIT:` dispatch header only, never bare slugs in scrollback.
+    if (!isAutoActive()) {
+        return undefined;
+    }
     return inferGsdPhaseFromContext(context);
 }
 /**
@@ -1384,6 +1419,12 @@ function isRecord(value) {
 function isStringRecord(value) {
     return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
+export function resolveWorkflowMcpPreflightServerConfig(mcpServers, workflowServerName) {
+    if (!workflowServerName || !isRecord(mcpServers))
+        return undefined;
+    const workflowServerConfig = mcpServers[workflowServerName];
+    return isRecord(workflowServerConfig) ? workflowServerConfig : undefined;
+}
 function cloneSdkMcpServerConfig(config) {
     if (!isRecord(config))
         return undefined;
@@ -1707,6 +1748,17 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
 // ---------------------------------------------------------------------------
 // streamSimple implementation
 // ---------------------------------------------------------------------------
+let capturedClaudeCodeUIContext;
+/**
+ * Capture the active extension UI context from `before_provider_request`. Core
+ * invokes `streamSimple` with a plain `SimpleStreamOptions` (no
+ * `extensionUIContext`), so without this the elicitation handler is never wired
+ * and `ask_user_questions` immediately returns cancelled. See index.ts, which
+ * registers the hook that calls this.
+ */
+export function setClaudeCodeUIContext(ui) {
+    capturedClaudeCodeUIContext = ui;
+}
 /**
  * GSD streamSimple function that delegates to the Claude Agent SDK.
  *
@@ -1736,7 +1788,7 @@ async function pumpSdkMessages(model, context, options, stream) {
     try {
         const permissionMode = await resolveClaudePermissionMode();
         const claudeOptions = options;
-        const uiContext = claudeOptions?.extensionUIContext;
+        const uiContext = claudeOptions?.extensionUIContext ?? capturedClaudeCodeUIContext;
         const onExternalToolCall = claudeOptions?.onExternalToolCall;
         const onExternalToolResult = claudeOptions?.onExternalToolResult;
         const sdkQueryForTest = claudeOptions?._sdkQueryForTest;
@@ -1808,6 +1860,7 @@ async function pumpSdkMessages(model, context, options, stream) {
                         unitType: gsdPhase,
                         workflowServerName: workflowMcpServerName,
                         projectRoot,
+                        workflowServerConfig: resolveWorkflowMcpPreflightServerConfig(sdkOpts.mcpServers, workflowMcpServerName),
                         signal: options?.signal,
                     });
                     if (preflightError) {

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

@@ -158,6 +158,21 @@ function emitText(stream, message, text) {
     stream.push({ type: "done", reason: "stop", message });
     stream.end(message);
 }
+function isGeminiCliDeprecatedCliOutput(text) {
+    return (/IneligibleTierError/i.test(text)
+        || /UNSUPPORTED_CLIENT/i.test(text)
+        || /no longer supported for Gemini Code Assist for individuals/i.test(text)
+        || /migrate to the Antigravity suite/i.test(text));
+}
+const GEMINI_CLI_DEPRECATION_HINT = "Gemini CLI is no longer supported for individual users. Install Antigravity CLI " +
+    "(curl -fsSL https://antigravity.google/cli/install.sh | bash), run `agy` to authenticate, " +
+    "then use /login → Antigravity or restart GSD to auto-migrate.";
+function formatGoogleCliError(detail, provider) {
+    if (provider === "google-gemini-cli" && isGeminiCliDeprecatedCliOutput(detail)) {
+        return `${detail}\n\n${GEMINI_CLI_DEPRECATION_HINT}`;
+    }
+    return detail;
+}
 function emitError(stream, model, error) {
     const message = error instanceof Error ? error.message : String(error);
     const output = buildAssistantMessage(model, "", "error", message);
@@ -175,7 +190,7 @@ export function streamViaGoogleCli(model, context, options) {
             const result = await runCli(command, args, options);
             if (result.code !== 0) {
                 const detail = (result.stderr || result.stdout || `CLI exited with code ${result.code}`).trim();
-                throw new Error(detail);
+                throw new Error(formatGoogleCliError(detail, provider));
             }
             const text = provider === "google-gemini-cli"
                 ? extractGeminiJsonResponse(result.stdout)

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

@@ -88,7 +88,12 @@ export function createDispatchHistory(options) {
             if (!scopeId)
                 return 0;
             try {
-                const persisted = getRecentUnitKeysForProjectRoot(scopeId, windowSize);
+                // Scope to the current session's trace_id when available (#852):
+                // a fresh session UUID that has never been written to unit_dispatches
+                // returns 0 rows so prior-session failures don't pre-populate the
+                // stuck window and immediately block the new session.
+                const traceId = options.resolveTraceId?.() ?? undefined;
+                const persisted = getRecentUnitKeysForProjectRoot(scopeId, windowSize, traceId);
                 if (persisted.length === 0)
                     return 0;
                 const rebuilt = [];

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

@@ -123,6 +123,7 @@ function resolveCompletionStopFromOutcome(outcome, stateSnapshot) {
 // tolerates — same behavior as a fresh session.
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
 const MAX_CONSECUTIVE_ALREADY_ACTIVE_SKIPS = 3;
+const MAX_CONSECUTIVE_ORCHESTRATION_SKIPS = 3;
 const ORCHESTRATION_MISSING_REASON = "Auto Orchestration Module is not wired; cannot dispatch built-in GSD Unit.";
 function stableStuckStateScopeId(s) {
     return normalizeRealPath(s.scope?.workspace.projectRoot ?? (s.originalBasePath || s.basePath));
@@ -132,7 +133,19 @@ function loadStuckState(s) {
     if (!scopeId)
         return { recentUnits: [], stuckRecoveryAttempts: 0 };
     try {
-        const recentUnits = getRecentUnitKeysForProjectRoot(scopeId, STUCK_WINDOW_SIZE);
+        // Scope the stuck window to the CURRENT session (trace_id) so stale
+        // finalize-retry entries from previous sessions don't fire detectStuck
+        // Rule 1 on the first iteration — killing auto-mode before any new
+        // dispatch runs (#852). A prior session's two consecutive finalize-retry
+        // failures would otherwise permanently block every new session.
+        //
+        // s.currentTraceId is only set inside the first loop iteration (line ~443),
+        // so at this call-site it is always null for a fresh session. Return []
+        // directly in that case — no prior dispatch has occurred in this session,
+        // so the stuck window is trivially empty and the DB query is skipped.
+        const recentUnits = s.currentTraceId != null
+            ? getRecentUnitKeysForProjectRoot(scopeId, STUCK_WINDOW_SIZE, s.currentTraceId)
+            : [];
         const stuckRecoveryAttempts = getRuntimeKv("global", scopeId, STUCK_RECOVERY_ATTEMPTS_KEY) ?? 0;
         return { recentUnits, stuckRecoveryAttempts };
     }
@@ -295,6 +308,8 @@ export async function autoLoop(ctx, pi, s, deps, options) {
     let consecutiveErrors = 0;
     let consecutiveCooldowns = 0;
     let consecutiveAlreadyActiveSkips = 0;
+    let consecutiveOrchestrationSkips = 0;
+    let lastOrchestrationSkipKey = null;
     const recentErrorMessages = [];
     while (s.active) {
         iteration++;
@@ -777,11 +792,51 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     }
                     if (orchestrationResult.kind === "skipped") {
                         s.pendingOrchestrationDispatch = null;
+                        // Idempotent re-poll skips are benign (an active unit is still running).
+                        // The orchestrator's own stuck-window detection handles the truly-stuck case.
+                        // Do not count these toward the consecutive-skip streak.
+                        if (orchestrationResult.reason === "idempotent advance: unit already active") {
+                            emitIterationEnd({ skipped: true });
+                            completeIteration();
+                            finishTurn("skipped");
+                            continue;
+                        }
+                        const skipState = orchestrationResult.stateSnapshot;
+                        const skipKey = [
+                            orchestrationResult.reason,
+                            skipState?.phase,
+                            skipState?.activeMilestone?.id,
+                            skipState?.activeSlice?.id,
+                            skipState?.activeTask?.id,
+                        ].join("|");
+                        consecutiveOrchestrationSkips = skipKey === lastOrchestrationSkipKey
+                            ? consecutiveOrchestrationSkips + 1
+                            : 1;
+                        lastOrchestrationSkipKey = skipKey;
+                        if (consecutiveOrchestrationSkips >= MAX_CONSECUTIVE_ORCHESTRATION_SKIPS) {
+                            const msg = `Orchestration skipped ${consecutiveOrchestrationSkips} consecutive attempts without progress. Pausing auto-mode for manual recovery.`;
+                            ctx.ui.notify(msg, "error");
+                            await deps.pauseAuto(ctx, pi, {
+                                message: msg,
+                                category: "unknown",
+                            }, {
+                                expectedCurrentUnit: null,
+                            });
+                            finishTurn("paused", "manual-attention", orchestrationResult.reason ?? "orchestration-skipped");
+                            finishIncompleteIteration({
+                                status: "paused",
+                                reason: orchestrationResult.reason ?? "orchestration-skipped",
+                                failureClass: "manual-attention",
+                            });
+                            break;
+                        }
                         emitIterationEnd({ skipped: true });
                         completeIteration();
                         finishTurn("skipped");
                         continue;
                     }
+                    consecutiveOrchestrationSkips = 0;
+                    lastOrchestrationSkipKey = null;
                     if (orchestrationResult.kind === "paused") {
                         s.pendingOrchestrationDispatch = null;
                         finishIncompleteIteration({
@@ -1148,7 +1203,17 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             const finalizeDecision = decideFinalizeResult(finalizeResult.action === "break"
                 ? { action: "break", reason: finalizeResult.reason }
                 : finalizeResult.action === "continue"
-                    ? { action: "continue" }
+                    ? {
+                        action: "continue",
+                        // Surface the specific verification failure (e.g. "roadmap has
+                        // zero slices") in the ledger/stuck-loop reason instead of the
+                        // opaque bare "finalize-retry" token. The retry paths in
+                        // runFinalize set s.pendingVerificationRetry.failureContext
+                        // from describeArtifactVerificationFailure before returning
+                        // continue; it is cleared on the next dispatch, so reading it
+                        // here captures the reason for THIS finalize (#852 follow-up).
+                        failureDetail: s.pendingVerificationRetry?.failureContext,
+                    }
                     : { action: "next" });
             if (finalizeDecision.action === "stop") {
                 dispatchSettled = settleDispatchFailed(dispatchId, finalizeDecision.ledgerErrorSummary, {