@opengsd/gsd-pi 1.0.2-dev.867e002 → 1.0.2-dev.aed3486

package/dist/onboarding.js

@@ -15,6 +15,7 @@ import { dirname, join } from 'node:path';
 import { renderGsdPiLogo, GSD_PI_BRAND, GSD_WEBSITE } from './logo.js';
 import { agentDir } from './app-paths.js';
 import { isClaudeCliReady } from './claude-cli-check.js';
+import { isAntigravityCliReady, isGeminiCliReady } from './resources/extensions/google-cli/readiness.js';
 import { markOnboardingComplete, markStepCompleted, markStepSkipped, isOnboardingComplete, } from './resources/extensions/gsd/onboarding-state.js';
 import { getLlmProviderIds } from './resources/extensions/gsd/setup-catalog.js';
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -358,7 +359,13 @@ export async function runLlmStep(p, pc, authStorage) {
     if (isClaudeCliReady()) {
         authOptions.push({ value: 'claude-cli', label: 'Use Claude Code CLI', hint: 'recommended — uses your existing Claude subscription' });
     }
-    authOptions.push({ value: 'browser', label: 'Sign in with your browser', hint: 'GitHub Copilot, ChatGPT, Google, etc.' }, { value: 'api-key', label: 'Paste an API key', hint: 'from your provider dashboard' }, { value: 'skip', label: 'Skip for now', hint: 'use /login inside GSD later' });
+    if (isGeminiCliReady()) {
+        authOptions.push({ value: 'gemini-cli', label: 'Use Google Gemini CLI', hint: 'uses your existing Gemini CLI session' });
+    }
+    if (isAntigravityCliReady()) {
+        authOptions.push({ value: 'antigravity-cli', label: 'Use Antigravity CLI', hint: 'uses your existing Antigravity session' });
+    }
+    authOptions.push({ value: 'browser', label: 'Sign in with your browser', hint: 'GitHub Copilot or ChatGPT/Codex' }, { value: 'api-key', label: 'Paste an API key', hint: 'from your provider dashboard' }, { value: 'skip', label: 'Skip for now', hint: 'use /login inside GSD later' });
     const method = await p.select({
         message: existingAuth ? `LLM provider: ${existingAuth} — change it?` : 'How do you want to sign in?',
         options: authOptions,
@@ -377,6 +384,20 @@ export async function runLlmStep(p, pc, authStorage) {
         persistDefaultProvider('claude-code');
         return true;
     }
+    if (method === 'gemini-cli') {
+        p.log.success('Google Gemini CLI detected — routing through local CLI');
+        p.log.info('Your Gemini CLI session will be used for inference. No API key needed.');
+        authStorage.set('google-gemini-cli', { type: 'api_key', key: 'cli' });
+        persistDefaultProvider('google-gemini-cli');
+        return true;
+    }
+    if (method === 'antigravity-cli') {
+        p.log.success('Antigravity CLI detected — routing through local CLI');
+        p.log.info('Your Antigravity session will be used for inference. No API key needed.');
+        authStorage.set('google-antigravity', { type: 'api_key', key: 'cli' });
+        persistDefaultProvider('google-antigravity');
+        return true;
+    }
     // ── Step 2: Which provider? ──────────────────────────────────────────────
     if (method === 'browser') {
         // Anthropic OAuth is removed from browser auth — it violates Anthropic TOS for
@@ -387,8 +408,6 @@ export async function runLlmStep(p, pc, authStorage) {
             options: [
                 { value: 'github-copilot', label: 'GitHub Copilot' },
                 { value: 'openai-codex', label: 'ChatGPT Plus/Pro (Codex)' },
-                { value: 'google-gemini-cli', label: 'Google Gemini CLI' },
-                { value: 'google-antigravity', label: 'Antigravity (Gemini 3, Claude, GPT-OSS)' },
             ],
         });
         if (p.isCancel(provider))

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

@@ -1 +1 @@
-9d6ff59a3cc348a6
+679e72aa2db909a2

package/dist/resources/extensions/context7/index.js

@@ -92,6 +92,16 @@ function formatLibraryList(libs, query) {
     lines.push("\nUse the ID (e.g. /websites/react_dev) with get_library_docs to fetch documentation.");
     return lines.join("\n");
 }
+function getFirstTextContent(result) {
+    const content = result.content;
+    if (!Array.isArray(content))
+        return undefined;
+    const textBlock = content.find((block) => typeof block === "object" &&
+        block !== null &&
+        block.type === "text" &&
+        typeof block.text === "string");
+    return textBlock?.text.trim() || undefined;
+}
 // ─── Extension ───────────────────────────────────────────────────────────────
 export default function (pi) {
     // ── resolve_library ──────────────────────────────────────────────────────
@@ -164,7 +174,7 @@ export default function (pi) {
             if (isPartial)
                 return new Text(theme.fg("warning", "Searching Context7..."), 0, 0);
             if (result.isError || d?.error) {
-                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+                return new Text(theme.fg("error", `Error: ${d?.error ?? getFirstTextContent(result) ?? "unknown"}`), 0, 0);
             }
             let text = theme.fg("success", `${d?.resultCount ?? 0} ${d?.resultCount === 1 ? "library" : "libraries"} found`);
             if (d?.cached)
@@ -303,7 +313,7 @@ export default function (pi) {
             if (isPartial)
                 return new Text(theme.fg("warning", "Fetching documentation..."), 0, 0);
             if (result.isError || d?.error) {
-                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+                return new Text(theme.fg("error", `Error: ${d?.error ?? getFirstTextContent(result) ?? "unknown"}`), 0, 0);
             }
             let text = theme.fg("success", `${(d?.charCount ?? 0).toLocaleString()} chars`);
             text += theme.fg("dim", ` · ${d?.tokens ?? 5000} token budget`);

package/dist/resources/extensions/get-secrets-from-user.js

@@ -10,6 +10,7 @@ import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import { Editor, Key, matchesKey, Text, truncateToWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { renderSharedDialogFrame } from "./shared/dialog-frame.js";
 import { makeUI } from "./shared/tui.js";
 import { maskEditorLine } from "./shared/mod.js";
 import { parseSecretsManifest, formatSecretsManifest } from "./gsd/files.js";
@@ -22,6 +23,9 @@ function maskPreview(value) {
         return "*".repeat(value.length);
     return `${value.slice(0, 4)}${"*".repeat(Math.max(4, value.length - 8))}${value.slice(-4)}`;
 }
+function dialogContentWidth(width) {
+    return width < 4 ? Math.max(1, width) : Math.max(1, width - 4);
+}
 function shellEscapeSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -132,9 +136,9 @@ async function collectOneSecret(ctx, pageIndex, totalPages, keyName, hint, guida
         function render(width) {
             if (cachedLines)
                 return cachedLines;
+            const contentWidth = dialogContentWidth(width);
             const lines = [];
-            const add = (s) => lines.push(truncateToWidth(s, width));
-            add(theme.fg("accent", "─".repeat(width)));
+            const add = (s) => lines.push(truncateToWidth(s, contentWidth));
             add(theme.fg("dim", ` Page ${pageIndex + 1}/${totalPages} · Secure Env Setup`));
             lines.push("");
             // Key name as big header
@@ -148,7 +152,7 @@ async function collectOneSecret(ctx, pageIndex, totalPages, keyName, hint, guida
                 for (let g = 0; g < guidance.length; g++) {
                     const prefix = `  ${g + 1}. `;
                     const step = guidance[g];
-                    const wrappedLines = wrapTextWithAnsi(step, width - 4);
+                    const wrappedLines = wrapTextWithAnsi(step, Math.max(1, contentWidth - 4));
                     for (let w = 0; w < wrappedLines.length; w++) {
                         const indent = w === 0 ? prefix : " ".repeat(prefix.length);
                         lines.push(theme.fg("dim", `${indent}${wrappedLines[w]}`));
@@ -163,14 +167,13 @@ async function collectOneSecret(ctx, pageIndex, totalPages, keyName, hint, guida
             lines.push("");
             // Editor
             add(theme.fg("muted", " Enter value:"));
-            for (const line of editor.render(width - 2)) {
+            for (const line of editor.render(Math.max(1, contentWidth - 2))) {
                 add(theme.fg("text", maskEditorLine(line)));
             }
             lines.push("");
-            add(theme.fg("dim", ` enter to confirm  |  ctrl+s or esc to skip  |  esc cancels`));
-            add(theme.fg("accent", "─".repeat(width)));
-            cachedLines = lines;
-            return lines;
+            const footer = theme.fg("dim", " enter to confirm  |  ctrl+s or esc to skip  |  esc cancels");
+            cachedLines = renderSharedDialogFrame(theme, "Secure Env Setup", lines, width, { footer });
+            return cachedLines;
         }
         return {
             render,
@@ -224,13 +227,11 @@ export async function showSecretsSummary(ctx, entries, existingKeys) {
         function render(width) {
             if (cachedLines)
                 return cachedLines;
-            const ui = makeUI(theme, width);
+            const contentWidth = dialogContentWidth(width);
+            const ui = makeUI(theme, contentWidth);
             const lines = [];
             const push = (...rows) => { for (const r of rows)
                 lines.push(...r); };
-            push(ui.bar());
-            push(ui.blank());
-            push(ui.header("  Secrets Summary"));
             push(ui.blank());
             for (const entry of entries) {
                 let status;
@@ -251,10 +252,9 @@ export async function showSecretsSummary(ctx, entries, existingKeys) {
                 push(ui.progressItem(entry.key, status, { detail }));
             }
             push(ui.blank());
-            push(ui.hints(["any key to continue"]));
-            push(ui.bar());
-            cachedLines = lines;
-            return lines;
+            const footer = ui.hints(["any key to continue"])[0] ?? "";
+            cachedLines = renderSharedDialogFrame(theme, "Secrets Summary", lines, width, { footer });
+            return cachedLines;
         }
         return {
             render,

package/dist/resources/extensions/google-cli/index.js

@@ -0,0 +1,30 @@
+/**
+ * Google local CLI providers.
+ *
+ * These deliberately use authMode "externalCli": GSD never owns the browser
+ * OAuth flow or cached tokens. Users authenticate with the official CLI, then
+ * /login activates the provider once the local binary is available.
+ */
+import { GOOGLE_ANTIGRAVITY_MODELS, GOOGLE_GEMINI_CLI_MODELS } from "./models.js";
+import { isAntigravityCliReady, isGeminiCliReady } from "./readiness.js";
+import { streamViaGoogleCli } from "./stream-adapter.js";
+export default function googleCli(pi) {
+    pi.registerProvider("google-gemini-cli", {
+        name: "Google Gemini CLI",
+        authMode: "externalCli",
+        api: "google-gemini-cli",
+        baseUrl: "local://google-gemini-cli",
+        isReady: isGeminiCliReady,
+        streamSimple: streamViaGoogleCli,
+        models: GOOGLE_GEMINI_CLI_MODELS,
+    });
+    pi.registerProvider("google-antigravity", {
+        name: "Google Antigravity",
+        authMode: "externalCli",
+        api: "google-antigravity",
+        baseUrl: "local://google-antigravity",
+        isReady: isAntigravityCliReady,
+        streamSimple: streamViaGoogleCli,
+        models: GOOGLE_ANTIGRAVITY_MODELS,
+    });
+}

package/dist/resources/extensions/google-cli/models.js

@@ -0,0 +1,55 @@
+const ZERO_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+export const GOOGLE_GEMINI_CLI_MODELS = [
+    {
+        id: "gemini-2.5-flash",
+        name: "Gemini 2.5 Flash",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+    {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+    {
+        id: "gemini-3-flash-preview",
+        name: "Gemini 3 Flash Preview",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+    {
+        id: "gemini-3.1-pro-preview",
+        name: "Gemini 3.1 Pro Preview",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+];
+export const GOOGLE_ANTIGRAVITY_MODELS = [
+    {
+        id: "default",
+        name: "Antigravity Default",
+        reasoning: true,
+        input: ["text"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 65_536,
+    },
+];

package/dist/resources/extensions/google-cli/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@gsd/google-cli",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./index.js"
+    ]
+  }
+}

package/dist/resources/extensions/google-cli/readiness.js

@@ -0,0 +1,12 @@
+import { spawnSync } from "node:child_process";
+function isCommandInPath(command) {
+    const resolver = process.platform === "win32" ? "where" : "which";
+    const result = spawnSync(resolver, [command], { stdio: "ignore" });
+    return result.status === 0;
+}
+export function isGeminiCliReady() {
+    return isCommandInPath("gemini");
+}
+export function isAntigravityCliReady() {
+    return isCommandInPath("agy");
+}

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

@@ -0,0 +1,191 @@
+import { spawn } from "node:child_process";
+import { createAssistantMessageEventStream } from "@gsd/pi-ai";
+const ZERO_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+function textBlocks(content) {
+    return content
+        .map((block) => block.type === "text" ? block.text : `[${block.type} omitted]`)
+        .join("\n");
+}
+function messageToText(message) {
+    if (message.role === "user") {
+        const content = typeof message.content === "string" ? message.content : textBlocks(message.content);
+        return `User:\n${content}`;
+    }
+    if (message.role === "assistant") {
+        const text = message.content
+            .map((block) => {
+            if (block.type === "text")
+                return block.text;
+            if (block.type === "thinking")
+                return `[thinking omitted]`;
+            if (block.type === "toolCall")
+                return `[tool call: ${block.name}]`;
+            if (block.type === "serverToolUse")
+                return `[server tool: ${block.name}]`;
+            if (block.type === "webSearchResult")
+                return `[web search result omitted]`;
+            return `[${block.type} omitted]`;
+        })
+            .join("\n");
+        return `Assistant:\n${text}`;
+    }
+    return `Tool result (${message.toolName}):\n${textBlocks(message.content)}`;
+}
+export function buildGoogleCliPrompt(context) {
+    const parts = [];
+    if (context.systemPrompt?.trim()) {
+        parts.push(`System instructions:\n${context.systemPrompt.trim()}`);
+    }
+    if (context.messages.length > 0) {
+        parts.push(context.messages.map(messageToText).join("\n\n"));
+    }
+    if (context.tools?.length) {
+        const names = context.tools.map((tool) => tool.name).join(", ");
+        parts.push(`Available local GSD tools were not forwarded to this external CLI bridge. ` +
+            `If you need to act, use the CLI's own tools or ask the user to switch to a provider with native tool-call support. ` +
+            `Requested GSD tools: ${names}`);
+    }
+    return parts.join("\n\n").trim();
+}
+function buildAssistantMessage(model, text, stopReason = "stop", errorMessage) {
+    return {
+        role: "assistant",
+        content: text ? [{ type: "text", text }] : [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: { ...ZERO_USAGE, cost: { ...ZERO_USAGE.cost } },
+        stopReason,
+        ...(errorMessage ? { errorMessage } : {}),
+        timestamp: Date.now(),
+    };
+}
+function extractGeminiJsonResponse(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    try {
+        const parsed = JSON.parse(trimmed);
+        for (const key of ["response", "text", "content", "message"]) {
+            const value = parsed[key];
+            if (typeof value === "string")
+                return value;
+        }
+        return JSON.stringify(parsed, null, 2);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function commandForProvider(provider) {
+    return provider === "google-gemini-cli" ? "gemini" : "agy";
+}
+function argsForProvider(provider, model, prompt) {
+    if (provider === "google-gemini-cli") {
+        const args = ["-p", prompt, "--output-format", "json"];
+        if (model.id !== "default")
+            args.unshift("-m", model.id);
+        return args;
+    }
+    const args = ["-p", prompt];
+    if (model.id !== "default")
+        args.unshift("-m", model.id);
+    return args;
+}
+export function buildGoogleCliSpawnInvocation(command, args, platform = process.platform) {
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/c", command, ...args] };
+    }
+    return { command, args };
+}
+function runCli(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const invocation = buildGoogleCliSpawnInvocation(command, args);
+        const child = spawn(invocation.command, invocation.args, {
+            cwd: options?.cwd || process.cwd(),
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            options?.signal?.removeEventListener("abort", onAbort);
+            fn();
+        };
+        const onAbort = () => {
+            child.kill("SIGTERM");
+            settle(() => reject(new Error("Request was aborted")));
+        };
+        if (options?.signal?.aborted) {
+            onAbort();
+            return;
+        }
+        options?.signal?.addEventListener("abort", onAbort);
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            settle(() => reject(error));
+        });
+        child.on("close", (code, signal) => {
+            settle(() => resolve({ stdout, stderr, code, signal }));
+        });
+    });
+}
+function emitText(stream, message, text) {
+    stream.push({ type: "start", partial: { ...message, content: [] } });
+    if (text) {
+        stream.push({ type: "text_start", contentIndex: 0, partial: message });
+        stream.push({ type: "text_delta", contentIndex: 0, delta: text, partial: message });
+        stream.push({ type: "text_end", contentIndex: 0, content: text, partial: message });
+    }
+    stream.push({ type: "done", reason: "stop", message });
+    stream.end(message);
+}
+function emitError(stream, model, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const output = buildAssistantMessage(model, "", "error", message);
+    stream.push({ type: "error", reason: "error", error: output });
+    stream.end(output);
+}
+export function streamViaGoogleCli(model, context, options) {
+    const stream = createAssistantMessageEventStream();
+    const provider = model.provider;
+    queueMicrotask(async () => {
+        try {
+            const prompt = buildGoogleCliPrompt(context);
+            const command = commandForProvider(provider);
+            const args = argsForProvider(provider, model, prompt);
+            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);
+            }
+            const text = provider === "google-gemini-cli"
+                ? extractGeminiJsonResponse(result.stdout)
+                : result.stdout.trim();
+            const message = buildAssistantMessage(model, text);
+            emitText(stream, message, text);
+        }
+        catch (error) {
+            emitError(stream, model, error);
+        }
+    });
+    return stream;
+}

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

@@ -732,11 +732,36 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                                 message: orchestrationResult.reason,
                                 category: "unknown",
                             });
+                            finishTurn("paused", "manual-attention", "orchestration-blocked");
                         }
                         else {
                             await deps.stopAuto(ctx, pi, orchestrationResult.reason);
+                            finishTurn("stopped", "manual-attention", "orchestration-blocked");
                         }
-                        finishTurn("stopped", "manual-attention", "orchestration-blocked");
+                        finishIncompleteIteration({
+                            status: orchestrationResult.action === "pause" ? "paused" : "stopped",
+                            reason: orchestrationResult.reason,
+                            failureClass: "manual-attention",
+                        });
+                        break;
+                    }
+                    if (orchestrationResult.kind === "paused") {
+                        s.pendingOrchestrationDispatch = null;
+                        finishTurn("skipped");
+                        continue;
+                    }
+                    if (orchestrationResult.kind === "error") {
+                        s.pendingOrchestrationDispatch = null;
+                        await deps.pauseAuto(ctx, pi, {
+                            message: orchestrationResult.reason,
+                            category: "unknown",
+                        });
+                        finishTurn("paused", "manual-attention", `orchestration-${orchestrationResult.kind}`);
+                        finishIncompleteIteration({
+                            status: "paused",
+                            reason: orchestrationResult.reason,
+                            failureClass: "manual-attention",
+                        });
                         break;
                     }
                     if (orchestrationResult.kind === "stopped") {
@@ -769,6 +794,42 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                         isRetry: false,
                         previousTier: undefined,
                     };
+                    const preDispatchResult = deps.runPreDispatchHooks(iterData.unitType, iterData.unitId, iterData.prompt, s.basePath);
+                    if (preDispatchResult.firedHooks.length > 0) {
+                        ctx.ui.notify(`Pre-dispatch hook${preDispatchResult.firedHooks.length > 1 ? "s" : ""}: ${preDispatchResult.firedHooks.join(", ")}`, "info");
+                        deps.emitJournalEvent({
+                            ts: new Date().toISOString(),
+                            flowId: ic.flowId,
+                            seq: ic.nextSeq(),
+                            eventType: "pre-dispatch-hook",
+                            data: {
+                                firedHooks: preDispatchResult.firedHooks,
+                                action: preDispatchResult.action,
+                            },
+                        });
+                    }
+                    if (preDispatchResult.action === "skip") {
+                        ctx.ui.notify(`Skipping ${iterData.unitType} ${iterData.unitId} (pre-dispatch hook).`, "info");
+                        s.pendingOrchestrationDispatch = null;
+                        emitIterationEnd({ skipped: true });
+                        completeIteration();
+                        finishTurn("skipped");
+                        continue;
+                    }
+                    if (preDispatchResult.action === "replace") {
+                        iterData.prompt = preDispatchResult.prompt ?? iterData.prompt;
+                        iterData.finalPrompt = iterData.prompt;
+                        if (preDispatchResult.unitType) {
+                            iterData.unitType = preDispatchResult.unitType;
+                        }
+                    }
+                    else if (preDispatchResult.prompt) {
+                        iterData.prompt = preDispatchResult.prompt;
+                        iterData.finalPrompt = preDispatchResult.prompt;
+                    }
+                    if (preDispatchResult.model) {
+                        iterData.hookModelOverride = preDispatchResult.model;
+                    }
                     s.pendingOrchestrationDispatch = null;
                     phaseReporter.report("dispatch", "next", {
                         unitType: iterData.unitType,

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

@@ -369,9 +369,11 @@ export class AutoOrchestrator {
         const activeUnitKey = this.status.activeUnit
             ? `${this.status.activeUnit.unitType}:${this.status.activeUnit.unitId}`
             : null;
-        if (activeUnitKey !== unitKey)
+        if (activeUnitKey !== unitKey && this.lastFinalizedUnitKey !== unitKey)
             return;
-        this.status.activeUnit = undefined;
+        if (activeUnitKey === unitKey) {
+            this.status.activeUnit = undefined;
+        }
         this.lastAdvanceKey = null;
         this.lastFinalizedUnitKey = null;
         this.bumpTransition();

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

@@ -10,6 +10,7 @@
  */
 import { importExtensionModule } from "@gsd/pi-coding-agent";
 import { USER_DRIVEN_DEEP_UNITS, isAwaitingUserInput, } from "../auto-post-unit.js";
+import { lastAssistantText } from "../user-input-boundary.js";
 import { MAX_RECOVERY_CHARS, BUDGET_THRESHOLDS, MAX_FINALIZE_TIMEOUTS, } from "./types.js";
 import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
@@ -52,8 +53,19 @@ import { decideVerificationRetry, verificationRetryKey } from "./verification-re
 import { buildPhaseHandoffOutcome, setAutoOutcomeWidget } from "../auto-dashboard.js";
 import { getConsecutiveDispatchBlocker } from "../dispatch-guard.js";
 import { captureRootDirtySnapshot, detectRootWriteLeak, formatRootWriteLeakMessage, } from "../root-write-leak-guard.js";
+import { classifyError, isTransient } from "../error-classifier.js";
 export const STUCK_WINDOW_SIZE = 6;
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
+const ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE = /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) hit your limit\b|usage limit\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
+const ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE = /(?:\b(?:http|status(?: code)?|code|error:)\s*(?:429|500|502|503)\b|\b(?:api|provider) error\s*[:(]?\s*(?:429|500|502|503)\b|\b(?:typeerror|error):\s*(?:fetch failed\b|socket hang up\b|terminated(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|(?:network|connection|server) error(?::|$)|stream idle timeout\b|partial response received\b|unexpected eof\b)|\b(?:server_error|api_error|stream_exhausted(?:_without_result)?)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|context (?:window|length) exceed|context window exceed)/i;
+function classifyZeroToolProviderMessage(message) {
+    const firstLine = message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
+    if (!firstLine ||
+        (!ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE.test(firstLine) &&
+            !ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE.test(firstLine)))
+        return null;
+    return classifyError(firstLine);
+}
 export function resolveDispatchRecoveryAttempts(unitRecoveryCount, unitType, unitId) {
     return (unitRecoveryCount.get(`${unitType}/${unitId}`) ?? 0) > 0
         ? 0
@@ -1999,6 +2011,31 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         if (currentLedger?.units) {
             const lastUnit = [...currentLedger.units].reverse().find((u) => u.type === unitType && u.id === unitId && u.startedAt === _resolveCurrentUnitStartedAtForTest(s.currentUnit));
             if (lastUnit && lastUnit.toolCalls === 0) {
+                const lastAssistantMessage = lastAssistantText(s.lastUnitAgentEndMessages);
+                const providerMessageClass = classifyZeroToolProviderMessage(lastAssistantMessage);
+                if (providerMessageClass && isTransient(providerMessageClass)) {
+                    const retryAfterMs = "retryAfterMs" in providerMessageClass ? providerMessageClass.retryAfterMs : 15_000;
+                    await pauseAutoForProviderError(ctx.ui, ` for ${unitType} ${unitId}`, () => deps.pauseAuto(ctx, pi), {
+                        isRateLimit: providerMessageClass.kind === "rate-limit",
+                        isTransient: true,
+                        retryAfterMs,
+                        resume: () => {
+                            void resumeAutoAfterProviderDelay(pi, ctx).catch((err) => {
+                                logWarning("engine", `Provider error auto-resume failed: ${err instanceof Error ? err.message : String(err)}`);
+                            });
+                        },
+                    });
+                    await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, {
+                        message: lastAssistantMessage.slice(0, 200),
+                        category: "provider",
+                        isTransient: true,
+                        retryAfterMs,
+                    });
+                    return {
+                        action: "break",
+                        reason: providerMessageClass.kind === "rate-limit" ? "rate-limit" : "api-timeout",
+                    };
+                }
                 if (USER_DRIVEN_DEEP_UNITS.has(unitType) && isAwaitingUserInput(s.lastUnitAgentEndMessages ?? undefined)) {
                     debugLog("runUnitPhase", {
                         phase: "zero-tool-calls-awaiting-user-input",