@opengsd/gsd-pi 1.0.2-dev.5961fbf → 1.0.2-dev.5f7864c

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -15,16 +15,15 @@ import { delimiter, join } from "node:path";
 import { AuthStorage } from "@gsd/pi-coding-agent";
 import { getEnvApiKey } from "@gsd/pi-ai";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { getAuthPath, PROVIDER_REGISTRY } from "./key-manager.js";
+import { getAuthPath, PROVIDER_REGISTRY, supportsBrowserOAuth } from "./key-manager.js";
 import { homedir } from "node:os";
 // ── Provider routing constants ────────────────────────────────────────────────
 /**
  * Providers that use external CLI authentication (not API keys).
- * These are always considered "found" — the host CLI handles auth.
+ * When explicitly selected, the provider's own CLI/session owns auth.
  */
 const CLI_AUTH_PROVIDERS = new Set([
     "claude-code",
-    "openai-codex",
     "google-gemini-cli",
     "google-antigravity",
 ]);
@@ -126,23 +125,26 @@ function collectConfiguredModelProviders() {
  * Used for lightweight binary-presence checks (PATH scan, no subprocess).
  */
 const CLI_BINARY_MAP = {
-    "claude-code": "claude",
-    "openai-codex": "codex",
-    "google-gemini-cli": "gemini",
-    "google-antigravity": "antigravity",
+    "claude-code": ["claude", "claude-code"],
+    "google-gemini-cli": ["gemini"],
+    "google-antigravity": ["agy"],
 };
+const CLI_AUTH_PATH_CHECK_PROVIDERS = new Set([
+    "google-gemini-cli",
+    "google-antigravity",
+]);
 /**
  * Check if a CLI provider's binary exists anywhere in PATH.
  * Fast filesystem scan — no subprocess, no network, sub-1ms.
  */
 function isCliBinaryInPath(providerId) {
-    const binary = CLI_BINARY_MAP[providerId];
-    if (!binary)
+    const binaries = CLI_BINARY_MAP[providerId];
+    if (!binaries)
         return false;
     const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
     // On Windows, command shims are commonly installed as .cmd/.exe/.bat/.com.
     // Scan PATHEXT candidates in addition to the bare binary name.
-    const executableNames = [binary];
+    const executableNames = [...binaries];
     if (process.platform === "win32") {
         const rawPathExt = process.env.PATHEXT
             ?.split(";")
@@ -150,10 +152,12 @@ function isCliBinaryInPath(providerId) {
             .filter(Boolean) ?? [];
         const normalizedPathExt = rawPathExt.map(ext => ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`);
         const defaultExt = [".exe", ".cmd", ".bat", ".com"];
-        for (const ext of [...normalizedPathExt, ...defaultExt]) {
-            const candidate = `${binary}${ext}`;
-            if (!executableNames.includes(candidate))
-                executableNames.push(candidate);
+        for (const binary of binaries) {
+            for (const ext of [...normalizedPathExt, ...defaultExt]) {
+                const candidate = `${binary}${ext}`;
+                if (!executableNames.includes(candidate))
+                    executableNames.push(candidate);
+            }
         }
     }
     return pathDirs.some(dir => executableNames.some(name => existsSync(join(dir, name))));
@@ -185,11 +189,6 @@ function hasModelsJsonApiKey(providerId) {
 }
 function resolveKey(providerId) {
     const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
-    // claude-code never stores credentials in auth.json — GSD delegates entirely to
-    // the local CLI binary. Presence of the binary in PATH is the only signal.
-    if (providerId === "claude-code") {
-        return { found: isCliBinaryInPath("claude-code"), source: "env", backedOff: false };
-    }
     if (providerId === "anthropic-vertex" && process.env.ANTHROPIC_VERTEX_PROJECT_ID) {
         return { found: true, source: "env", backedOff: false };
     }
@@ -201,7 +200,16 @@ function resolveKey(providerId) {
             const creds = auth.getCredentialsForProvider(providerId);
             if (creds.length > 0) {
                 // Filter out empty placeholder keys (from skipped onboarding)
-                const hasRealKey = creds.some(c => c.type === "oauth" || (c.type === "api_key" && c.key));
+                const hasRealKey = creds.some(c => {
+                    if (c.type === "oauth")
+                        return true;
+                    if (c.type !== "api_key")
+                        return false;
+                    const key = c.key?.trim();
+                    if (!key)
+                        return false;
+                    return !(CLI_AUTH_PROVIDERS.has(providerId) && key === "cli");
+                });
                 if (hasRealKey) {
                     return {
                         found: true,
@@ -229,6 +237,11 @@ function resolveKey(providerId) {
     if (hasModelsJsonApiKey(providerId)) {
         return { found: true, source: "models.json", backedOff: false };
     }
+    // Cross-provider routes can use a local CLI when it is installed. Explicit
+    // external CLI provider selections are handled in checkLlmProviders() below.
+    if (CLI_AUTH_PROVIDERS.has(providerId) && isCliBinaryInPath(providerId)) {
+        return { found: true, source: "env", backedOff: false };
+    }
     return { found: false, source: "none", backedOff: false };
 }
 // ── Individual check groups ────────────────────────────────────────────────────
@@ -236,15 +249,32 @@ function checkLlmProviders() {
     const required = collectConfiguredModelProviders();
     const results = [];
     for (const providerId of required) {
-        // CLI-authenticated providers don't need API keys — skip key check
+        // CLI-authenticated providers don't need API keys. The provider's own
+        // request path validates CLI sessions when it is used.
         if (CLI_AUTH_PROVIDERS.has(providerId)) {
             const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
+            const label = info?.label ?? providerId;
+            if (CLI_AUTH_PATH_CHECK_PROVIDERS.has(providerId) && !isCliBinaryInPath(providerId)) {
+                const binaries = CLI_BINARY_MAP[providerId]?.map(binary => `\`${binary}\``).join(" or ");
+                results.push({
+                    name: providerId,
+                    label,
+                    category: "llm",
+                    status: "error",
+                    message: `${label} — CLI not found`,
+                    detail: binaries
+                        ? `Install ${label} and ensure ${binaries} is on PATH`
+                        : `Install ${label} and ensure its CLI is on PATH`,
+                    required: true,
+                });
+                continue;
+            }
             results.push({
                 name: providerId,
-                label: info?.label ?? providerId,
+                label,
                 category: "llm",
                 status: "ok",
-                message: `${info?.label ?? providerId} — CLI auth (no key needed)`,
+                message: `${label} — CLI auth (no key needed)`,
                 required: true,
             });
             continue;
@@ -282,7 +312,7 @@ function checkLlmProviders() {
                 message: `${label} — not configured`,
                 detail: providerId === "anthropic-vertex"
                     ? "Set ANTHROPIC_VERTEX_PROJECT_ID and authenticate with Google ADC"
-                    : info?.hasOAuth
+                    : info && supportsBrowserOAuth(info)
                         ? `Run /gsd keys to authenticate`
                         : `Set ${envVar} or run /gsd keys`,
                 required: true,

package/dist/resources/extensions/gsd/git-conflict-state.js

@@ -2,7 +2,7 @@
 // File Purpose: Detect and reconcile unresolved Git conflict state before automation runs.
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { autoResolveSafeConflictPaths } from "./git-conflict-resolve.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { abortAndReset } from "./git-self-heal.js";
@@ -10,6 +10,23 @@ import { logWarning } from "./workflow-logger.js";
 function splitZeroDelimited(output) {
     return output.split("\0").filter(Boolean);
 }
+function hasGitMarker(basePath) {
+    try {
+        let dir = resolve(basePath);
+        for (let i = 0; i < 30; i++) {
+            if (existsSync(join(dir, ".git")))
+                return true;
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // Fall through to the git probes, which will report unknown on failure.
+    }
+    return false;
+}
 export function listUnmergedGitPaths(basePath) {
     try {
         const output = spawnSync("git", ["diff", "--name-only", "--diff-filter=U", "-z"], {
@@ -57,6 +74,14 @@ export function listMergeStateBlockers(basePath) {
     return MERGE_STATE_MARKERS.filter((marker) => existsSync(join(gitDir, marker)));
 }
 export function probeGitConflictState(basePath) {
+    if (!hasGitMarker(basePath)) {
+        return {
+            status: "clean",
+            unmerged: [],
+            checkFailures: [],
+            mergeStateBlockers: [],
+        };
+    }
     const unmerged = listUnmergedGitPaths(basePath);
     if (unmerged === null) {
         return {

package/dist/resources/extensions/gsd/guided-flow.js

@@ -1045,7 +1045,7 @@ function buildHeadlessDiscussPrompt(nextId, seedContext, _basePath) {
  * Run preparation phase if enabled, then build the discuss prompt.
  * Preparation analyzes the codebase and prior context, injecting the results
  * as supplementary context into the standard discuss template. The discuss
- * template drives the conversation (asks "What's the vision?" first), while
+ * template drives the conversation with a variable vision opener, while
  * the preparation briefs give the agent grounding in the existing codebase.
  *
  * @param ctx - Extension command context with UI for progress notifications

package/dist/resources/extensions/gsd/key-manager.js

@@ -12,18 +12,18 @@ import { getErrorMessage } from "./error-utils.js";
 import { gsdHome } from "./gsd-home.js";
 export const PROVIDER_REGISTRY = [
     // LLM Providers
-    { id: "anthropic", label: "Anthropic (Claude)", category: "llm", envVar: "ANTHROPIC_API_KEY", prefixes: ["sk-ant-"], hasOAuth: true, dashboardUrl: "console.anthropic.com" },
+    { id: "anthropic", label: "Anthropic (Claude)", category: "llm", envVar: "ANTHROPIC_API_KEY", prefixes: ["sk-ant-"], authMode: "apiKey", dashboardUrl: "console.anthropic.com" },
     // Claude Code CLI: routes through the local `claude` binary — no API key,
     // authentication is handled by the CLI's own OAuth flow.
     // Referenced by doctor-providers.ts, auto-model-selection.ts, and others;
     // must be in the canonical registry so all consumers see the same catalog.
     // See: https://github.com/open-gsd/gsd-pi/issues/4541
-    { id: "claude-code", label: "Claude Code CLI", category: "llm", hasOAuth: true },
+    { id: "claude-code", label: "Claude Code CLI", category: "llm", authMode: "externalCli" },
     { id: "openai", label: "OpenAI", category: "llm", envVar: "OPENAI_API_KEY", prefixes: ["sk-"], dashboardUrl: "platform.openai.com/api-keys" },
-    { id: "github-copilot", label: "GitHub Copilot", category: "llm", envVar: "GITHUB_TOKEN", hasOAuth: true },
-    { id: "openai-codex", label: "ChatGPT Plus/Pro (Codex)", category: "llm", hasOAuth: true },
-    { id: "google-gemini-cli", label: "Google Gemini CLI", category: "llm", hasOAuth: true },
-    { id: "google-antigravity", label: "Antigravity", category: "llm", hasOAuth: true },
+    { id: "github-copilot", label: "GitHub Copilot", category: "llm", envVar: "GITHUB_TOKEN", authMode: "browserOAuth" },
+    { id: "openai-codex", label: "ChatGPT Plus/Pro (Codex)", category: "llm", authMode: "browserOAuth" },
+    { id: "google-gemini-cli", label: "Google Gemini CLI", category: "llm", authMode: "externalCli" },
+    { id: "google-antigravity", label: "Antigravity", category: "llm", authMode: "externalCli" },
     { id: "google", label: "Google (Gemini)", category: "llm", envVar: "GEMINI_API_KEY", dashboardUrl: "aistudio.google.com/apikey" },
     { id: "groq", label: "Groq", category: "llm", envVar: "GROQ_API_KEY", dashboardUrl: "console.groq.com" },
     { id: "xai", label: "xAI (Grok)", category: "llm", envVar: "XAI_API_KEY", dashboardUrl: "console.x.ai" },
@@ -49,6 +49,20 @@ export const PROVIDER_REGISTRY = [
     { id: "telegram_bot", label: "Telegram Bot", category: "remote", envVar: "TELEGRAM_BOT_TOKEN" },
 ];
 // ─── Utilities ──────────────────────────────────────────────────────────────────
+export function getProviderAuthMode(provider) {
+    return provider.authMode ?? "apiKey";
+}
+export function supportsBrowserOAuth(provider) {
+    return getProviderAuthMode(provider) === "browserOAuth";
+}
+export function supportsStoredApiKey(provider) {
+    const mode = getProviderAuthMode(provider);
+    if (mode === "externalCli" || mode === "cloudIdentity" || mode === "none")
+        return false;
+    if (mode === "browserOAuth")
+        return Boolean(provider.envVar || provider.prefixes?.length);
+    return true;
+}
 /**
  * Mask an API key for display: show first 4 + last 4 chars.
  * Keys shorter than 12 chars show only first 2 + last 2.
@@ -79,11 +93,14 @@ export function formatDuration(ms) {
 /**
  * Describe a credential's type and status.
  */
-export function describeCredential(cred) {
+export function describeCredential(cred, provider) {
     if (cred.type === "api_key") {
         const apiCred = cred;
         if (!apiCred.key)
             return "empty key";
+        if (apiCred.key === "cli" && provider && getProviderAuthMode(provider) === "externalCli") {
+            return "external CLI";
+        }
         return `API key (${maskKey(apiCred.key)})`;
     }
     if (cred.type === "oauth") {
@@ -129,7 +146,7 @@ export function getAllKeyStatuses(auth) {
             const firstCred = creds[0];
             const desc = creds.length > 1
                 ? `${creds.length} keys (round-robin)`
-                : describeCredential(firstCred);
+                : describeCredential(firstCred, provider);
             return {
                 provider,
                 configured: true,
@@ -236,9 +253,20 @@ export async function handleAddKey(providerArg, ctx, auth) {
             return false;
         provider = PROVIDER_REGISTRY[idx];
     }
-    // If OAuth is available, offer choice
-    if (provider.hasOAuth) {
-        const methods = ["API key", "Browser login (OAuth)"];
+    const authMode = getProviderAuthMode(provider);
+    if (authMode === "externalCli") {
+        ctx.ui.notify(`${provider.label} is authenticated by its own local CLI. ` +
+            `Sign in with that CLI first, then run /login to activate it in GSD.`, "info");
+        return false;
+    }
+    if (authMode === "cloudIdentity") {
+        ctx.ui.notify(`${provider.label} uses cloud identity credentials. Configure the provider's cloud CLI or environment, then restart GSD.`, "info");
+        return false;
+    }
+    if (supportsBrowserOAuth(provider)) {
+        const methods = supportsStoredApiKey(provider)
+            ? ["API token/key", "Browser login (OAuth)"]
+            : ["Browser login (OAuth)"];
         const method = await ctx.ui.select(`${provider.label} — how do you want to authenticate?`, methods);
         if (!method || typeof method !== "string")
             return false;
@@ -248,6 +276,10 @@ export async function handleAddKey(providerArg, ctx, auth) {
             return false;
         }
     }
+    if (!supportsStoredApiKey(provider)) {
+        ctx.ui.notify(`${provider.label} does not accept a GSD-stored API key. Use /login.`, "info");
+        return false;
+    }
     // API key input
     const input = await ctx.ui.input(`API key for ${provider.label}:`, provider.envVar ? `or set ${provider.envVar} env var` : "paste your key here");
     if (input === null || input === undefined)
@@ -309,7 +341,7 @@ export async function handleRemoveKey(providerArg, ctx, auth) {
     }
     // Multi-key handling
     if (creds.length > 1) {
-        const options = creds.map((c, i) => `[${i + 1}] ${describeCredential(c)}`);
+        const options = creds.map((c, i) => `[${i + 1}] ${describeCredential(c, provider)}`);
         options.push("Remove all");
         const choice = await ctx.ui.select(`${provider.label} has ${creds.length} keys. Remove which?`, options);
         if (!choice || typeof choice !== "string")
@@ -330,7 +362,7 @@ export async function handleRemoveKey(providerArg, ctx, auth) {
         }
     }
     else {
-        const confirmed = await ctx.ui.confirm("Remove key?", `Remove ${describeCredential(creds[0])} for ${provider.label}?`);
+        const confirmed = await ctx.ui.confirm("Remove key?", `Remove ${describeCredential(creds[0], provider)} for ${provider.label}?`);
         if (!confirmed)
             return false;
         auth.remove(provider.id);

package/dist/resources/extensions/gsd/notification-overlay.js

@@ -3,7 +3,7 @@
 import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
 import { readNotifications, markAllRead, clearNotifications, onNotificationStoreChange, } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
-import { padRightVisible, renderFrame, renderKeyHints, rightAlign, wrapVisibleText, } from "./tui/render-kit.js";
+import { padRightVisible, renderDialogFrame, renderKeyHints, rightAlign, wrapVisibleText, } from "./tui/render-kit.js";
 const FILTER_CYCLE = ["all", "error", "warning", "success", "info"];
 const OVERLAY_WIDTH = "58%";
 const OVERLAY_MIN_WIDTH = 68;
@@ -163,12 +163,16 @@ export class GSDNotificationOverlay {
         const terminalRows = process.stdout.rows || 32;
         const availableRows = Math.max(1, terminalRows - OVERLAY_MARGIN.top - OVERLAY_MARGIN.bottom);
         const overlayRows = Math.min(availableRows, Math.max(1, Math.floor((terminalRows * OVERLAY_MAX_HEIGHT_PERCENT) / 100)));
-        const maxVisibleRows = Math.max(5, overlayRows - 2);
+        const maxVisibleRows = Math.max(5, overlayRows - 4);
         const visibleContentRows = Math.min(content.length, maxVisibleRows);
         const maxScroll = Math.max(0, content.length - visibleContentRows);
         this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
         const visibleContent = content.slice(this.scrollOffset, this.scrollOffset + visibleContentRows);
-        const lines = renderFrame(this.theme, visibleContent, width);
+        const footer = renderKeyHints(this.theme, ["↑/↓ scroll", "f filter", "c clear", `Esc/${formattedShortcutPair("notifications")} close`], Math.max(1, width - 4));
+        const lines = renderDialogFrame(this.theme, "Notifications", visibleContent, width, {
+            footer,
+            scroll: { offset: this.scrollOffset, visibleRows: visibleContentRows, totalRows: content.length },
+        });
         this.cachedWidth = width;
         this.cachedLines = lines;
         return lines;
@@ -211,8 +215,6 @@ export class GSDNotificationOverlay {
         };
         const blank = () => row("");
         const hr = () => row(th.fg("dim", "─".repeat(contentWidth)));
-        // Header
-        const title = th.fg("accent", th.bold("Notifications"));
         const filterLabel = this.filter === "all"
             ? th.fg("dim", "all")
             : th.fg(this.filter === "error" ? "error"
@@ -220,11 +222,8 @@ export class GSDNotificationOverlay {
                     : this.filter === "success" ? "success"
                         : "dim", this.filter);
         const count = `${this.filteredEntries.length} entries`;
-        lines.push(row(rightAlign(`${title}  ${th.fg("dim", "filter:")} ${filterLabel}`, th.fg("dim", count), contentWidth)));
+        lines.push(row(rightAlign(`${th.fg("dim", "filter:")} ${filterLabel}`, th.fg("dim", count), contentWidth)));
         lines.push(hr());
-        // Controls
-        const closeShortcut = formattedShortcutPair("notifications");
-        lines.push(row(renderKeyHints(th, ["↑/↓ scroll", "f filter", "c clear", `Esc/${closeShortcut} close`], contentWidth)));
         lines.push(blank());
         // Entries
         const filtered = this.filteredEntries;

package/dist/resources/extensions/gsd/parallel-monitor-overlay.js

@@ -7,7 +7,7 @@ import { matchesKey, Key } from "@gsd/pi-tui";
 import { formatDuration } from "../shared/mod.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { resolveGsdPathContract } from "./paths.js";
-import { renderBar, renderKeyHints, renderProgressBar, safeLine, statusGlyph, } from "./tui/render-kit.js";
+import { renderBar, renderDialogFrame, renderKeyHints, renderProgressBar, safeLine, statusGlyph, } from "./tui/render-kit.js";
 // ─── Data Helpers ─────────────────────────────────────────────────────────
 function readJsonSafe(filePath) {
     try {
@@ -306,15 +306,14 @@ export class ParallelMonitorOverlay {
         const t = this.theme;
         const lines = [];
         const w = Math.max(1, width);
-        // Header
+        const contentWidth = Math.max(1, w - 4);
         const totalCost = this.workers.reduce((s, wk) => s + wk.cost, 0);
         const aliveCount = this.workers.filter((wk) => wk.alive).length;
         const now = new Date().toLocaleTimeString();
-        lines.push(t.bold(t.fg("accent", " GSD Parallel Monitor ")));
         lines.push(t.fg("muted", `  ${now}  │  ${aliveCount}/${this.workers.length} alive  │  Total: `) +
             t.bold(`$${totalCost.toFixed(2)}`) +
             t.fg("muted", "  │  5s refresh"));
-        lines.push(renderBar(t, w));
+        lines.push(renderBar(t, contentWidth));
         if (this.workers.length === 0) {
             lines.push("");
             lines.push(t.fg("warning", "  No parallel workers found."));
@@ -360,7 +359,7 @@ export class ParallelMonitorOverlay {
                     });
                     lines.push(`     ${t.fg("muted", "slices")}  ${chips.join("  ")}`);
                     // Task progress bar
-                    const barWidth = Math.max(6, Math.min(25, w - 32));
+                    const barWidth = Math.max(6, Math.min(25, contentWidth - 32));
                     const bar = renderProgressBar(t, wk.doneTasks, wk.totalTasks, barWidth, {
                         filledChar: "█",
                         emptyChar: "░",
@@ -378,7 +377,7 @@ export class ParallelMonitorOverlay {
         }
         // Event feed
         lines.push("");
-        lines.push(renderBar(t, w));
+        lines.push(renderBar(t, contentWidth));
         lines.push(`  ${t.bold("Recent Events")}`);
         if (this.events.length === 0) {
             lines.push(t.fg("muted", "  No events yet..."));
@@ -389,7 +388,6 @@ export class ParallelMonitorOverlay {
                 lines.push(`  ${t.fg("muted", "│")} ${t.fg("accent", mid)} ${evt.replace(/^✓ M\d+\//, "")}`);
             }
         }
-        // Footer
         lines.push("");
         const allDone = this.workers.length > 0 && this.workers.every((wk) => !wk.alive);
         if (allDone) {
@@ -400,16 +398,20 @@ export class ParallelMonitorOverlay {
             }
             lines.push(`  ${t.bold("Total: $" + this.workers.reduce((s, wk) => s + wk.cost, 0).toFixed(2))}`);
         }
-        lines.push(renderKeyHints(t, [`ESC/q/${formattedShortcutPair("parallel")} close`, "↑↓ scroll"], w));
         // Apply scroll — use terminal rows as height estimate
         const termHeight = process.stdout.rows || 40;
-        const maxScroll = Math.max(0, lines.length - termHeight);
+        const maxBodyRows = Math.max(1, Math.min(lines.length, termHeight - 12));
+        const maxScroll = Math.max(0, lines.length - maxBodyRows);
         this.scrollOffset = Math.min(Math.max(this.scrollOffset, 0), maxScroll);
         const visible = lines
-            .slice(this.scrollOffset, this.scrollOffset + termHeight)
-            .map((line) => safeLine(line, w));
-        this.cachedLines = visible;
+            .slice(this.scrollOffset, this.scrollOffset + maxBodyRows)
+            .map((line) => safeLine(line, contentWidth));
+        const footer = renderKeyHints(t, [`ESC/q/${formattedShortcutPair("parallel")} close`, "↑↓ scroll"], contentWidth);
+        this.cachedLines = renderDialogFrame(t, "GSD Parallel Monitor", visible, w, {
+            footer,
+            scroll: { offset: this.scrollOffset, visibleRows: maxBodyRows, totalRows: lines.length },
+        });
         this.cachedWidth = width;
-        return visible;
+        return this.cachedLines;
     }
 }

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -21,6 +21,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { logWarning } from "./workflow-logger.js";
 import { gsdHome } from "./gsd-home.js";
+import { chooseVisionAskVariant } from "./vision-ask.js";
 function hasRequiredExtensionAssets(rootDir, exists = existsSync) {
     return (exists(join(rootDir, "prompts")) &&
         exists(join(rootDir, "templates", "task-summary.md")));
@@ -168,6 +169,7 @@ export function loadPrompt(name, vars = {}) {
         planTemplatePath: join(getTemplatesDir(), "plan.md"),
         taskPlanTemplatePath: join(getTemplatesDir(), "task-plan.md"),
         taskSummaryTemplatePath: join(getTemplatesDir(), "task-summary.md"),
+        visionAsk: chooseVisionAskVariant(),
         skillActivation: "If a `GSD Skill Preferences` block is present in system context, use it and the `<available_skills>` catalog in your system prompt to decide which skills to load and follow for this unit, without relaxing required verification or artifact rules.",
         ...vars,
     };

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -1,8 +1,10 @@
 {{preamble}}
 
-Ask: "What's the vision?" once, then use the reply as vision input.
+Ask exactly this once: "{{visionAsk}}" Then use the user's reply as vision input.
 
-**Special handling:** If the **user's** message is status, branch state, clarification, or any other non-project-description, treat it as vision input and proceed instead of repeating "What's the vision?" Do **not** treat the system preamble above (e.g. "New milestone M00X.") as vision input — wait for the user.
+The opener is intentionally variable so GSD feels alive across project starts. Keep it natural, easy to answer, and assistant/developer shaped: plain language, light guidance, no corporate wording, no roleplay.
+
+**Special handling:** If the **user's** message is status, branch state, clarification, or any other non-project-description, treat it as vision input and proceed instead of repeating the opener. Do **not** treat the system preamble above (e.g. "New milestone M00X.") as vision input — wait for the user.
 
 ## Reflection Step
 

package/dist/resources/extensions/gsd/prompts/guided-discuss-milestone.md

@@ -4,6 +4,8 @@ Discuss milestone {{milestoneId}} ("{{milestoneTitle}}"). Identify real gray are
 
 **Structured questions available: {{structuredQuestionsAvailable}}**
 
+**Conversation opener:** For the first user-facing question round, if you need a broad starting question, use: "{{visionAsk}}" Pair it with investigation-shaped follow-ups. Keep the tone natural and easy to answer, like an assistant/developer helping the user shape the next piece of work.
+
 {{inlinedTemplates}}
 
 ---

package/dist/resources/extensions/gsd/queue-reorder-ui.js

@@ -8,9 +8,9 @@
  * Conflicting depends_on entries are auto-removed on confirm.
  */
 import { Key, matchesKey, truncateToWidth } from "@gsd/pi-tui";
-import { makeUI } from "../shared/tui.js";
 import { GLYPH } from "../shared/mod.js";
 import { validateQueueOrder } from "./queue-order.js";
+import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 /**
  * Show the queue reorder overlay.
  * Returns the new order + deps to remove, or null if cancelled.
@@ -26,6 +26,7 @@ export async function showQueueReorder(ctx, completed, pending) {
         let grabbed = false;
         let scrollOffset = 0;
         let cachedLines;
+        let cachedWidth;
         let validation;
         // Mutable deps map — tracks removals during this session
         const liveDeps = new Map();
@@ -42,6 +43,7 @@ export async function showQueueReorder(ctx, completed, pending) {
         revalidate();
         function refresh() {
             cachedLines = undefined;
+            cachedWidth = undefined;
             tui.requestRender();
         }
         function swapItems(fromIdx, toIdx) {
@@ -125,17 +127,14 @@ export async function showQueueReorder(ctx, completed, pending) {
             }
         }
         function render(width) {
-            if (cachedLines)
+            if (cachedLines && cachedWidth === width)
                 return cachedLines;
-            const ui = makeUI(theme, width);
+            const contentWidth = Math.max(1, width - 4);
             const lines = [];
             const queueRows = [];
-            const push = (...rows) => { for (const r of rows)
-                lines.push(...r); };
-            const add = (s) => truncateToWidth(s, width);
+            const add = (s) => truncateToWidth(s, contentWidth);
             let cursorQueueRow = 0;
-            const headerText = grabbed ? "  Queue Reorder — Moving Item" : "  Queue Reorder";
-            push(ui.bar(), ui.blank(), ui.header(headerText), ui.blank());
+            const headerText = grabbed ? "Queue Reorder - Moving Item" : "Queue Reorder";
             // Completed milestones (dimmed)
             if (completed.length > 0) {
                 lines.push(add(theme.fg("dim", "  Completed:")));
@@ -143,7 +142,7 @@ export async function showQueueReorder(ctx, completed, pending) {
                     const label = m.title && m.title !== m.id ? `${m.id}  ${m.title}` : m.id;
                     lines.push(add(`    ${theme.fg("dim", `${GLYPH.statusDone} ${label}`)}`));
                 }
-                push(ui.blank());
+                lines.push("");
             }
             // Pending milestones
             const queueLabel = grabbed ? "  Queue (space to release, ↑/↓ to move):" : "  Queue (space to grab, ↑/↓ to navigate):";
@@ -190,7 +189,7 @@ export async function showQueueReorder(ctx, completed, pending) {
             // Removed deps feedback
             const trailingLines = [];
             if (removedDeps.length > 0) {
-                trailingLines.push(...ui.blank());
+                trailingLines.push("");
                 for (const r of removedDeps) {
                     trailingLines.push(add(`  ${theme.fg("success", `${GLYPH.statusDone} Removed: ${r.milestone} depends_on ${r.dep}`)}`));
                 }
@@ -198,10 +197,9 @@ export async function showQueueReorder(ctx, completed, pending) {
             // Circular warning
             const circ = validation.violations.find(v => v.type === 'circular');
             if (circ) {
-                trailingLines.push(...ui.blank());
+                trailingLines.push("");
                 trailingLines.push(add(`  ${theme.fg("error", `${GLYPH.statusWarning} ${circ.message}`)}`));
             }
-            trailingLines.push(...ui.blank());
             // Hints — context-sensitive based on grab state
             const hints = [];
             if (grabbed) {
@@ -221,9 +219,9 @@ export async function showQueueReorder(ctx, completed, pending) {
                 hints.push("enter ok");
             }
             hints.push("esc");
-            trailingLines.push(...ui.hints(hints), ...ui.bar());
             const maxOverlayRows = Math.max(10, process.stdout.rows ? Math.floor(process.stdout.rows * 0.8) : 24);
-            const availableQueueRows = Math.max(1, maxOverlayRows - lines.length - trailingLines.length);
+            const frameRows = 4;
+            const availableQueueRows = Math.max(1, maxOverlayRows - frameRows - lines.length - trailingLines.length);
             const maxScroll = Math.max(0, queueRows.length - availableQueueRows);
             if (cursorQueueRow < scrollOffset) {
                 scrollOffset = cursorQueueRow;
@@ -232,11 +230,23 @@ export async function showQueueReorder(ctx, completed, pending) {
                 scrollOffset = cursorQueueRow - availableQueueRows + 1;
             }
             scrollOffset = Math.min(Math.max(scrollOffset, 0), maxScroll);
-            lines.push(...queueRows.slice(scrollOffset, scrollOffset + availableQueueRows), ...trailingLines);
-            cachedLines = lines;
-            return lines;
+            const queueStartRow = lines.length;
+            const visibleQueueRows = queueRows.slice(scrollOffset, scrollOffset + availableQueueRows);
+            lines.push(...visibleQueueRows, ...trailingLines);
+            cachedLines = renderDialogFrame(theme, headerText, lines, width, {
+                footer: renderKeyHints(theme, hints, contentWidth),
+                scroll: {
+                    offset: scrollOffset,
+                    visibleRows: availableQueueRows,
+                    totalRows: queueRows.length,
+                    trackOffset: queueStartRow,
+                    trackRows: visibleQueueRows.length,
+                },
+            });
+            cachedWidth = width;
+            return cachedLines;
         }
-        return { render, invalidate: () => { cachedLines = undefined; }, handleInput };
+        return { render, invalidate: () => { cachedLines = undefined; cachedWidth = undefined; }, handleInput };
     }, {
         overlay: true,
         overlayOptions: { width: "70%", minWidth: 50, maxHeight: "80%", anchor: "center" },

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -116,6 +116,15 @@ export async function handleCompleteTask(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
+    if (!params.oneLiner || typeof params.oneLiner !== "string" || params.oneLiner.trim() === "") {
+        return { error: "oneLiner is required and must be a non-empty string" };
+    }
+    if (!params.narrative || typeof params.narrative !== "string" || params.narrative.trim() === "") {
+        return { error: "narrative is required and must be a non-empty string" };
+    }
+    if (!params.verification || typeof params.verification !== "string" || params.verification.trim() === "") {
+        return { error: "verification is required and must be a non-empty string" };
+    }
     const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, params.milestoneId);
     // ── Ownership check (opt-in: only enforced when claim file exists) ──────
     const ownershipErr = checkOwnership(artifactBasePath, taskUnitKey(params.milestoneId, params.sliceId, params.taskId), params.actorName);