glitool 2.0.4 → 2.1.0

package/dist/agents/graph.js

@@ -44,6 +44,30 @@ function extractTarget(args) {
     }
     return String(first ?? '');
 }
+// Look at the folder BEFORE planning, so the planner knows what it's working with.
+async function inspectProject() {
+    const files = await fg(['**/*.{ts,tsx,js,jsx,json,html,css,md}'], {
+        cwd: process.cwd(),
+        ignore: ['node_modules/**', 'dist/**', '.next/**', '.git/**', 'build/**'],
+        onlyFiles: true,
+        suppressErrors: true,
+    });
+    const codeFiles = files.filter(f => /\.(ts|tsx|js|jsx)$/.test(f));
+    const isEmpty = codeFiles.length === 0;
+    const hasPackageJson = files.includes('package.json');
+    const fileTree = files.slice(0, 200).join('\n');
+    let summary;
+    if (isEmpty && !hasPackageJson) {
+        summary = 'EMPTY PROJECT — no source files. Build from scratch with "create" steps.';
+    }
+    else if (hasPackageJson) {
+        summary = `EXISTING PROJECT — ${files.length} files, has package.json. Edit/extend existing code.`;
+    }
+    else {
+        summary = `PARTIAL PROJECT — ${files.length} files, no package.json yet.`;
+    }
+    return { isEmpty, fileCount: files.length, fileTree, hasPackageJson, summary };
+}
 export async function runAgentGraph(userMessage, systemPrompt, onToolCall, onStatus, decision, onStageEvent) {
     const plannerModel = getModelForTier('complex');
     const coderModel = decision.recommendedModel;
@@ -51,14 +75,11 @@ export async function runAgentGraph(userMessage, systemPrompt, onToolCall, onSta
     async function plannerNode(state) {
         onStatus('Planning...');
         onStageEvent?.({ type: 'stage_start', stage: 'planner' });
-        const files = await fg(['**/*.{ts,tsx,js,jsx}'], {
-            cwd: process.cwd(),
-            ignore: ['node_modules/**', 'dist/**', '.next/**', '.git/**', 'build/**'],
-            onlyFiles: true,
-            suppressErrors: true,
-        });
-        const fileTree = files.slice(0, 200).join('\n');
-        const groundedSystemPrompt = `${state.systemPrompt}\n\n=== Project file tree (use exact paths from this list when planning edits) ===\n${fileTree}`;
+        const project = await inspectProject();
+        onStageEvent?.({ type: 'reasoning', stage: 'planner', text: project.summary });
+        const groundedSystemPrompt = project.isEmpty
+            ? `${state.systemPrompt}\n\n=== PROJECT STATE: ${project.summary} ===\nPlan ONLY "create" steps (plus "run" steps for install/scaffold commands). Use real, conventional paths for the stack (e.g. package.json, app/page.tsx, src/index.ts). Do NOT plan "read", "search", or "edit" steps — there is nothing to read or edit.`
+            : `${state.systemPrompt}\n\n=== PROJECT STATE: ${project.summary} ===\n=== Project file tree (use exact paths when planning edits) ===\n${project.fileTree}`;
         const prompt = state.plannerHint
             ? `${state.userMessage}\n\nPrevious attempt failed. Fix hint: ${state.plannerHint}`
             : state.userMessage;

package/dist/agents/planner.js

@@ -42,13 +42,10 @@ Rules:
         throw new Error('empty array');
     }
     catch {
-        // Fallback — treat the whole response as a single unstructured step
-        return [{
-                id: 1,
-                action: 'edit',
-                target: 'project',
-                depends_on: [],
-                why: content,
-            }];
+        // Planner returned prose / a question instead of JSON. Don't fabricate a
+        // fake "edit" step — that sends the coder hunting for files that may not
+        // exist. Return null = "no plan", so the pipeline falls back to a normal
+        // conversational reply where the user can be asked properly.
+        return null;
     }
 }

package/dist/clarificationHandler.js

@@ -0,0 +1,7 @@
+let handler = async () => '';
+export function setClarificationHandler(fn) {
+    handler = fn;
+}
+export async function requestClarification(question, options) {
+    return handler(question, options);
+}

package/dist/clarifier.js

@@ -0,0 +1,101 @@
+import { searchCodeTool } from './tools/index.js';
+const SKIP_DOMAINS = new Set(['chat', 'explanation', 'git']);
+const UI_SEARCH_MAP = {
+    button: 'onClick',
+    btn: 'onClick',
+    click: 'onClick',
+    pressed: 'onClick',
+    form: 'onSubmit',
+    submit: 'onSubmit',
+    login: 'login',
+    signin: 'signIn',
+    signup: 'signUp',
+    register: 'register',
+    modal: 'modal',
+    dialog: 'dialog',
+    dropdown: 'dropdown',
+    menu: 'menu',
+    cart: 'addToCart',
+    checkout: 'checkout',
+    payment: 'payment',
+    search: 'handleSearch',
+    filter: 'filter',
+    upload: 'upload',
+    delete: 'delete',
+    save: 'save',
+    update: 'update',
+};
+function extractSearchTerms(prompt) {
+    const terms = [];
+    const lower = prompt.toLowerCase();
+    for (const match of prompt.matchAll(/\b[\w/.-]+\.(tsx?|jsx?|css|html|json|md)\b/gi)) {
+        terms.push(match[0]);
+    }
+    for (const match of prompt.matchAll(/\b[a-z][a-zA-Z0-9]*(?:[A-Z][a-zA-Z0-9]*)+\b/g)) {
+        terms.push(match[0]);
+    }
+    for (const [word, searchTerm] of Object.entries(UI_SEARCH_MAP)) {
+        if (lower.includes(word)) {
+            terms.push(searchTerm);
+        }
+    }
+    return [...new Set(terms)].slice(0, 4);
+}
+async function codebaseSearch(prompt) {
+    const lower = prompt.toLowerCase();
+    const isUiQuery = ['button', 'btn', 'click', 'form', 'input', 'modal', 'dropdown', 'link']
+        .some(w => lower.includes(w));
+    const terms = extractSearchTerms(prompt);
+    const sections = [];
+    for (const term of terms) {
+        try {
+            const raw = await searchCodeTool.invoke({ keyword: term });
+            if (!raw || raw === 'No matches found.')
+                continue;
+            const fileMap = new Map();
+            for (const line of raw.split('\n').filter(Boolean)) {
+                const m = line.match(/^([^:]+):(\d+):(.*)/);
+                if (!m)
+                    continue;
+                const [, file, lineNum, content] = m;
+                if (isUiQuery && /\.ts$/.test(file) && !(/\.tsx$/.test(file)))
+                    continue;
+                if (!fileMap.has(file))
+                    fileMap.set(file, []);
+                if (fileMap.get(file).length < 2) {
+                    fileMap.get(file).push(`L${lineNum}: ${content.trim().slice(0, 80)}`);
+                }
+            }
+            if (fileMap.size === 0)
+                continue;
+            const summary = [`[found "${term}" in ${fileMap.size} file(s)]`];
+            let count = 0;
+            for (const [file, snippets] of fileMap) {
+                if (count++ >= 6)
+                    break;
+                summary.push(`${file}:`);
+                snippets.forEach(s => summary.push(`  ${s}`));
+            }
+            sections.push(summary.join('\n'));
+        }
+        catch { }
+    }
+    return sections.join('\n\n');
+}
+export async function runClarifier(prompt, domain, sessionMessageCount = 0) {
+    if (SKIP_DOMAINS.has(domain))
+        return {};
+    const words = prompt.trim().split(/\s+/);
+    const isShort = words.length < 10;
+    const hasAnaphora = /\b(that|it|this|the issue|the bug|the problem|the fix|the error|the feature)\b/i.test(prompt);
+    const ACTION_VERBS = /^(do|implement|build|add|make|create|fix|run|apply|execute|start|generate|write|update|remove|delete|refactor)\b/i;
+    const isActionOnDefinite = ACTION_VERBS.test(words[0]) && /\bthe\b/i.test(prompt);
+    const isShortFollowUp = isShort && (hasAnaphora || (isActionOnDefinite && sessionMessageCount > 2));
+    if (isShortFollowUp)
+        return {};
+    const codeContext = await codebaseSearch(prompt);
+    return { codeContext: codeContext || undefined };
+}
+export function buildEnhancedPrompt(original, answers) {
+    return `[Original request]: ${original}\n\n[User clarification]: ${answers}`;
+}

package/dist/llm/factory.js

@@ -5,17 +5,44 @@ function backendUrl() {
     return process.env.GLITOOL_BACKEND ?? 'https://api.glit.in';
 }
 let currentRequestId = null;
+const resolvedModelByRequest = new Map();
 export function startNewRequest() {
     currentRequestId = randomUUID();
     return currentRequestId;
 }
+/**
+ * Returns the actual model the server resolved for the current request,
+ * captured from the X-Glitool-Resolved-Model response header.
+ * Returns null until the first response of the current request has come back,
+ * or always when running BYOK (no Glitool server in the path).
+ */
+export function getResolvedModelForCurrentRequest() {
+    return currentRequestId ? resolvedModelByRequest.get(currentRequestId) ?? null : null;
+}
 function requestIdHeader() {
     return currentRequestId ? { 'X-Glitool-Request-ID': currentRequestId } : {};
 }
+// Wraps fetch to capture the X-Glitool-Resolved-Model header from every server response.
+// requestId is bound at LLM construction time so concurrent requests stay disjoint.
+function makeCaptureFetch(requestId) {
+    return async (input, init) => {
+        const response = await fetch(input, init);
+        try {
+            const resolved = response.headers.get('X-Glitool-Resolved-Model');
+            if (resolved && requestId) {
+                resolvedModelByRequest.set(requestId, resolved);
+            }
+        }
+        catch { }
+        return response;
+    };
+}
 export function makeLlm(model, extras = {}) {
     if (process.env.OPENAI_API_KEY) {
+        // BYOK path bypasses the Glitool server entirely — no header to capture.
         return new ChatOpenAI({ model, apiKey: process.env.OPENAI_API_KEY, streaming: true, ...extras });
     }
+    const captureFetch = makeCaptureFetch(currentRequestId);
     const token = getAuthToken();
     if (token) {
         return new ChatOpenAI({
@@ -25,6 +52,7 @@ export function makeLlm(model, extras = {}) {
             configuration: {
                 baseURL: `${backendUrl()}/v1`,
                 defaultHeaders: requestIdHeader(),
+                fetch: captureFetch,
             },
             ...extras,
         });
@@ -33,9 +61,11 @@ export function makeLlm(model, extras = {}) {
         model,
         apiKey: 'anon',
         streaming: true,
+        maxTokens: 8192,
         configuration: {
             baseURL: `${backendUrl()}/v1`,
             defaultHeaders: { 'X-Anon-ID': getOrCreateAnonId(), ...requestIdHeader() },
+            fetch: captureFetch,
         },
         ...extras,
     });

package/dist/llm/router.js

@@ -1,10 +1,19 @@
 import { classifyWithLlm } from './classifier.js';
 import { loadConfig } from '../config.js';
-const MODEL_BY_TIER = {
-    quick: 'meta-llama/Llama-3.3-70B-Instruct-Turbo',
-    standard: 'Qwen/Qwen2.5-Coder-72B-Instruct',
-    complex: 'deepseek-ai/DeepSeek-V3',
+// Domain → semantic role. Server resolves role + plan to a vendor model.
+const DOMAIN_TO_ROLE = {
+    chat: 'glitool/quick',
+    explanation: 'glitool/quick',
+    git: 'glitool/quick',
+    coding: 'glitool/coder',
+    debugging: 'glitool/coder',
+    refactoring: 'glitool/coder',
+    planning: 'glitool/planner',
+    review: 'glitool/planner',
 };
+function roleFor(domain) {
+    return DOMAIN_TO_ROLE[domain] ?? 'glitool/quick';
+}
 const ANAPHORA_PATTERNS = [
     /\b(this|that|it|those|these)\b/i,
     /\b(again|instead|previous|prior)\b/i,
@@ -102,7 +111,7 @@ export function parseExplicitRoute(prompt) {
                 tier: route.tier,
                 domain: route.domain,
                 complexityScore: 0,
-                recommendedModel: getModel(route.tier),
+                recommendedModel: roleFor(route.domain),
                 reason: `explicit: ${cmd}`,
                 source: 'explicit',
                 confidence: 'high', // ← ADD
@@ -123,17 +132,6 @@ export function stripExplicitPrefix(prompt) {
     }
     return prompt;
 }
-function getModel(tier) {
-    const userPref = loadConfig().preferredModel;
-    // User preference applies ONLY to the quick tier (chat/explain).
-    // Coding, planning, refactoring always use the tier-appropriate strong model.
-    if (userPref && tier === 'quick')
-        return userPref;
-    return MODEL_BY_TIER[tier];
-}
-export function getModelForTier(tier) {
-    return MODEL_BY_TIER[tier];
-}
 function detectDomain(prompt) {
     if (CHAT_PATTERNS.some(p => p.test(prompt)))
         return { domain: 'chat', matched: true };
@@ -206,7 +204,7 @@ export async function route(prompt, recentMessages = []) {
         tier,
         domain: regexDomain,
         complexityScore,
-        recommendedModel: getModel(tier),
+        recommendedModel: roleFor(regexDomain),
         reason: `domain=${regexDomain} score=${complexityScore} tier=${tier} matched=${matched} anaphora=${anaphora}`,
         source: 'regex',
         confidence,
@@ -223,7 +221,7 @@ export async function route(prompt, recentMessages = []) {
                 tier: llmTier,
                 domain: result.domain,
                 complexityScore,
-                recommendedModel: getModel(llmTier),
+                recommendedModel: roleFor(result.domain),
                 reason: result.reason,
                 source: 'llm',
                 confidence: result.confidence,

package/dist/tools/askUserTool.js

@@ -0,0 +1,22 @@
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { requestClarification } from '../clarificationHandler.js';
+export const askUserTool = tool(async ({ question, options }) => {
+    const answer = await requestClarification(question, options);
+    if (!answer || answer.trim() === 's' || answer.trim() === '/skip') {
+        return 'User skipped. Use your best judgment and proceed with the most reasonable approach.';
+    }
+    return `User answered: ${answer}`;
+}, {
+    name: 'askUser',
+    description: `Ask the user ONE question when you cannot proceed without their input.
+ONLY call this after you have already investigated (read files, searched code).
+ONLY when multiple real candidates exist in the code and you cannot determine which one.
+Ask the most specific question possible based on what you actually found.
+Do NOT ask about design preferences, layout choices, or features — make sensible defaults.
+Do NOT ask about things you can discover by reading files.`,
+    schema: z.object({
+        question: z.string().describe('The specific question to ask the user'),
+        options: z.array(z.string()).optional().describe('2-4 choices based on what you found in the code. Omit for open questions.'),
+    }),
+});

package/dist/tools/bashTool.js

@@ -4,10 +4,13 @@ import { z } from "zod";
 import { requestConfirm } from "../confirmHandler.js";
 import { scoreShellRisk } from "../trust/riskScorer.js";
 import { registerProcess } from "./processRegistry.js";
+import path from 'path';
+import fs from 'fs';
 const MAX_OUTPUT = 10_000;
 const DEFAULT_TIMEOUT_MS = 30_000;
-export const bashTool = tool(async ({ command, timeout, runInBackground }) => {
-    // Risk check BEFORE spawn — block dangerous, confirm sensitive
+export const bashTool = tool(async ({ command, timeout, runInBackground, cwd }) => {
+    const timeoutMs = typeof timeout === 'string' ? parseInt(timeout, 10) : (timeout ?? DEFAULT_TIMEOUT_MS);
+    const bgMode = typeof runInBackground === 'string' ? runInBackground === 'true' : (runInBackground ?? false);
     const risk = scoreShellRisk(command);
     if (risk === 'block') {
         return `BLOCKED: This shell command is too dangerous to run: \`${command}\`. Try a safer alternative or ask the user to run it manually.`;
@@ -23,12 +26,21 @@ export const bashTool = tool(async ({ command, timeout, runInBackground }) => {
             return 'USER_CANCELLED: The user rejected this shell command. Do NOT retry.';
         }
     }
+    if (cwd) {
+        const resolvedCwd = path.resolve(process.cwd(), cwd);
+        if (!fs.existsSync(resolvedCwd)) {
+            return `Error: cwd "${cwd}" does not exist (resolved to ${resolvedCwd}). If you are about to CREATE this directory (e.g. a scaffolder like create-next-app), omit cwd. If you just created it, double-check the path/spelling.`;
+        }
+        if (!fs.statSync(resolvedCwd).isDirectory()) {
+            return `Error: cwd "${cwd}" exists but is not a directory.`;
+        }
+    }
     const proc = spawn(command, {
         shell: true,
-        cwd: process.cwd(),
-        ...(runInBackground ? {} : { timeout: timeout ?? DEFAULT_TIMEOUT_MS }),
+        cwd: cwd ? path.resolve(process.cwd(), cwd) : process.cwd(),
+        ...(bgMode ? {} : { timeout: timeoutMs }),
     });
-    if (runInBackground) {
+    if (bgMode) {
         const handle = registerProcess(proc, command);
         return `Background process started. Handle: ${handle}. Use the read_background_output with this handle to see output.`;
     }
@@ -84,7 +96,8 @@ export const bashTool = tool(async ({ command, timeout, runInBackground }) => {
     description: 'Run a shell command. Use runInBackground:true for dev servers and long-running tests — returns a handle immediately. Use read_background_output to read accumulating output. Dangerous commands (rm -rf, sudo, fork bombs) are blocked. Sensitive commands (git push, npm install/publish) require user confirmation.',
     schema: z.object({
         command: z.string().describe('Shell command to run'),
-        timeout: z.number().optional().describe('Timeout in ms for foreground commands (default 30000)'),
-        runInBackground: z.boolean().optional().describe('If true, run without waiting and return a handle'),
+        timeout: z.union([z.number(), z.string()]).optional().describe('Timeout in ms for foreground commands (default 30000)'),
+        runInBackground: z.union([z.boolean(), z.string()]).optional().describe('If true, run in background and return a handle'),
+        cwd: z.string().optional().describe('Working directory relative to project root'),
     }),
 });

package/dist/tools/editFileTool.js

@@ -3,13 +3,17 @@ import fs from 'fs';
 import path from 'path';
 import { z } from 'zod';
 import { requestConfirm } from '../confirmHandler.js';
-export const editFileTool = tool(async ({ filePath, oldString, newString }) => {
-    const fullPath = path.resolve(process.cwd(), filePath);
+export const editFileTool = tool(async ({ filePath, path: pathAlias, filename, oldString, newString }) => {
+    const resolvedPath = filePath ?? pathAlias ?? filename ?? '';
+    if (!resolvedPath) {
+        throw new Error('editFile requires filePath. To write a whole file, use writeFile instead.');
+    }
+    const fullPath = path.resolve(process.cwd(), resolvedPath);
     if (!fullPath.startsWith(process.cwd())) {
         throw new Error('Access denied: outside project root');
     }
     if (!fs.existsSync(fullPath)) {
-        throw new Error(`File not found: ${filePath}`);
+        throw new Error(`File not found: ${resolvedPath}`);
     }
     const content = fs.readFileSync(fullPath, 'utf-8');
     if (!content.includes(oldString)) {
@@ -17,7 +21,7 @@ export const editFileTool = tool(async ({ filePath, oldString, newString }) => {
     }
     const ok = await requestConfirm({
         type: 'edit',
-        filePath,
+        filePath: resolvedPath,
         oldString,
         newString,
         risk: 'low',
@@ -27,12 +31,14 @@ export const editFileTool = tool(async ({ filePath, oldString, newString }) => {
     }
     const update = content.split(oldString).join(newString);
     fs.writeFileSync(fullPath, update, 'utf-8');
-    return `Successfully edited ${filePath}`;
+    return `Successfully edited ${resolvedPath}`;
 }, {
     name: 'editFile',
-    description: 'Make a targeted edit to an existing file by replacing an exact string. Use readFile first to get the current content, then provide the exact oldString to replace.',
+    description: 'Make a targeted edit to an existing file by replacing an exact string. Use readFile first to get the current content, then provide the exact oldString to replace. To CREATE or fully OVERWRITE a file, use writeFile instead — editFile only modifies existing content.',
     schema: z.object({
-        filePath: z.string().describe('Relative path to the file from the project root'),
+        filePath: z.string().optional().describe('Relative path to the file from the project root'),
+        path: z.string().optional(),
+        filename: z.string().optional(),
         oldString: z.string().describe('The exact string to find and replace - must match exactly including whitespace and indentation'),
         newString: z.string().describe('The string to replace it with')
     })

package/dist/tools/index.js

@@ -7,3 +7,4 @@ export { editFileTool } from './editFileTool.js';
 export { bashTool } from './bashTool.js';
 export { readBackgroundOutputTool } from './readBackgroundOutput.js';
 export { webFetchTool } from './webFetchTool.js';
+export { askUserTool } from './askUserTool.js';

package/dist/tools/readFileTool.js

@@ -42,10 +42,11 @@ async function resolveFilePath(filePath) {
     }
     return { kind: 'ambiguous', matches };
 }
-export const readFileTool = tool(async ({ filePath }) => {
-    const resolved = await resolveFilePath(filePath);
+export const readFileTool = tool(async ({ filePath, path: pathAlias, filename }) => {
+    const resolvedPath = filePath ?? pathAlias ?? filename ?? '';
+    const resolved = await resolveFilePath(resolvedPath);
     if (resolved.kind === 'not_found') {
-        return `File not found: ${filePath}
+        return `File not found: ${resolvedPath}
 Current working directory: ${process.cwd()}
 Hint: try a bare filename (e.g. "agent.ts") to search the whole project, or use an absolute path.`;
     }
@@ -54,7 +55,7 @@ Hint: try a bare filename (e.g. "agent.ts") to search the whole project, or use
         const more = resolved.matches.length > 10
             ? `\n  ...and ${resolved.matches.length - 10} more`
             : '';
-        return `Multiple files match "${filePath}":\n${list}${more}\n\nCall readFile again with one of these specific paths.`;
+        return `Multiple files match "${resolvedPath}":\n${list}${more}\n\nCall readFile again with one of these specific paths.`;
     }
     const stat = fs.statSync(resolved.absPath);
     if (stat.size > MAX_BYTES) {
@@ -63,13 +64,15 @@ Hint: try a bare filename (e.g. "agent.ts") to search the whole project, or use
     const content = fs.readFileSync(resolved.absPath, 'utf-8');
     // If we resolved a bare filename, tell the agent which path we used so future calls can be precise.
     if (resolved.resolvedFrom) {
-        return `[resolved "${filePath}" → ${resolved.resolvedFrom}]\n\n${content}`;
+        return `[resolved "${resolvedPath}" → ${resolved.resolvedFrom}]\n\n${content}`;
     }
     return content;
 }, {
     name: 'readFile',
     description: 'Read the contents of a file. Accepts either a relative path from the project root (e.g. "src/foo.ts") or a bare filename (e.g. "foo.ts") — if a bare name is given, it searches the whole project. If multiple files match, the tool returns the list and you should call again with the specific path.',
     schema: z.object({
-        filePath: z.string().describe('Relative path from project root (e.g. "CLI/src/agent.ts") OR a bare filename (e.g. "agent.ts") to search for project-wide.'),
+        filePath: z.string().optional().describe('Relative path or bare filename to read'),
+        path: z.string().optional(),
+        filename: z.string().optional(),
     }),
 });

package/dist/tools/searchCodeTool.js

@@ -1,13 +1,17 @@
 import { tool } from "@langchain/core/tools";
 import { execFileSync } from "child_process";
 import { z } from "zod";
-export const searchCodeTool = tool(async ({ keyword }) => {
+export const searchCodeTool = tool(async ({ keyword, query }) => {
+    const searchTerm = keyword ?? query ?? '';
     try {
         const result = execFileSync('grep', [
             '-rn',
-            keyword,
+            searchTerm,
             '--include=*.ts',
+            '--include=*.tsx',
             '--include=*.js',
+            '--include=*.jsx',
+            '--include=*.html',
             '--include=*.json',
             '--exclude-dir=node_modules',
             '--exclude-dir=dist',
@@ -23,6 +27,7 @@ export const searchCodeTool = tool(async ({ keyword }) => {
     name: 'searchCode',
     description: 'Search for a keyword or function name across all project files. Returns file paths and line numbers where the keyword is found. Use this tool to quickly locate where a specific function or variable is used in the codebase.',
     schema: z.object({
-        keyword: z.string().describe('The keyword, function name, or pattern to search for in the codebase')
+        keyword: z.string().optional().describe('The keyword, function name, or pattern to search for'),
+        query: z.string().optional(),
     })
 });

package/dist/ui/App.js

@@ -14,7 +14,6 @@ import { StatusBar } from './StatusBar.js';
 import { execSync } from 'child_process';
 import { SlashPalette, filterCommands } from './SlashPalette.js';
 import { ToolLog } from "./ToolLog.js";
-import { Pipeline } from "./Pipeline.js";
 import { ConfirmCard } from './ConfirmCard.js';
 import { ExplainCard } from "./ExplainCard.js";
 import { colors } from "./tokens.js";
@@ -23,6 +22,7 @@ import { log } from "../logger.js";
 import { renderMarkdown } from "./renderMarkdown.js";
 import { ProcessTrace } from './ProcessTrace.js';
 import { AuthFlow } from './AuthFlow.js';
+import { ClarificationCard } from './ClarificationCard.js';
 import { getAnonRequestCount, incrementAnonCount, isAnonLimitReached, isAuthenticated, readAuth, ANON_LIMIT, } from '../auth.js';
 // const previousInputRef = useRef('');
 const config = loadConfig();
@@ -70,6 +70,8 @@ export const App = ({ explainMode = false }) => {
     const [streamingContent, setStreamingContent] = useState('');
     const [inputHistory, setInputHistory] = useState([]);
     const [historyIndex, setHistoryIndex] = useState(-1);
+    const [clarificationQuestions, setClarificationQuestions] = useState([]);
+    const clarificationResolverRef = useRef(null);
     const [statusState, setStatusState] = useState('idle');
     const [statusDetail, setStatusDetail] = useState('');
     const [tokens, setTokens] = useState(0);
@@ -139,6 +141,8 @@ export const App = ({ explainMode = false }) => {
             return;
         if (escalation)
             return;
+        if (clarificationQuestions.length > 0)
+            return;
         if (statusState === 'working')
             return;
         // Ctrl+V — read clipboard directly
@@ -399,10 +403,14 @@ export const App = ({ explainMode = false }) => {
                 else if (status.startsWith('Escalating')) {
                     setJudge({ status: 'active', detail: 'escalating' });
                 }
-            }, (token) => setStreamingContent(prev => prev + token), (payload) => setEscalation(payload), (newTokens, newCost) => {
+            }, (token) => setStreamingContent(prev => prev + token), (newTokens, newCost) => {
                 setTokens(prev => prev + newTokens);
                 setCost(prev => prev + newCost);
-            }, (event) => setStageEvents(prev => [...prev, event]));
+            }, (event) => setStageEvents(prev => [...prev, event]), (question, options) => new Promise((resolve) => {
+                setClarificationQuestions([{ question, options }]);
+                clarificationResolverRef.current = resolve;
+                setStatusState('awaiting');
+            }));
             if (!isAuthenticated() && !process.env.OPENAI_API_KEY) {
                 const newCount = incrementAnonCount();
                 setAnonCount(newCount);
@@ -481,6 +489,16 @@ export const App = ({ explainMode = false }) => {
                             setStatusState('working');
                             resolve?.(choice === 'y');
                             log('confirm:resolved', { value: choice === 'y' });
+                        } })) : clarificationQuestions.length > 0 ? (_jsx(ClarificationCard, { questions: clarificationQuestions, onAnswer: (answers) => {
+                            setClarificationQuestions([]);
+                            setStatusState('working');
+                            clarificationResolverRef.current?.(answers);
+                            clarificationResolverRef.current = null;
+                        }, onSkip: () => {
+                            setClarificationQuestions([]);
+                            setStatusState('working');
+                            clarificationResolverRef.current?.('s');
+                            clarificationResolverRef.current = null;
                         } })) : showAuth ? (_jsx(AuthFlow, { onDone: (auth) => {
                             setShowAuth(false);
                             setMessages(prev => [...prev, {

package/dist/ui/ClarificationCard.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { colors } from './tokens.js';
+export const ClarificationCard = ({ questions, onAnswer, onSkip }) => {
+    const [currentIndex, setCurrentIndex] = useState(0);
+    const [collectedAnswers, setCollectedAnswers] = useState([]);
+    const [input, setInput] = useState('');
+    const [otherMode, setOtherMode] = useState(false);
+    const current = questions[currentIndex];
+    const options = current?.options;
+    const showOptions = !!options && options.length > 0 && !otherMode;
+    const otherIndex = options ? options.length + 1 : 0;
+    const isLast = currentIndex === questions.length - 1;
+    const advance = (answer) => {
+        const updated = [...collectedAnswers, answer];
+        if (isLast) {
+            const combined = questions
+                .map((q, i) => `Q${i + 1}: ${q.question}\nA: ${updated[i]}`)
+                .join('\n\n');
+            onAnswer(combined);
+        }
+        else {
+            setCollectedAnswers(updated);
+            setCurrentIndex(currentIndex + 1);
+            setInput('');
+            setOtherMode(false);
+        }
+    };
+    const handleSubmit = (value) => {
+        const trimmed = value.trim();
+        if (trimmed === 's' || trimmed === '/skip') {
+            onSkip();
+            return;
+        }
+        if (!trimmed)
+            return;
+        advance(trimmed);
+    };
+    // Single-keypress capture for the numbered-options view
+    useInput((ch) => {
+        if (!showOptions)
+            return;
+        if (ch === 's') {
+            onSkip();
+            return;
+        }
+        const n = parseInt(ch, 10);
+        if (isNaN(n))
+            return;
+        if (n >= 1 && n <= options.length) {
+            advance(options[n - 1]);
+        }
+        else if (n === otherIndex) {
+            setOtherMode(true);
+        }
+    }, { isActive: showOptions });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginBottom: 1, children: [_jsxs(Box, { marginBottom: 1, justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "yellow", children: " Clarification needed " }), _jsxs(Text, { color: colors.muted, children: [" ", currentIndex + 1, " / ", questions.length, " "] })] }), collectedAnswers.length > 0 && (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: collectedAnswers.map((ans, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { dimColor: true, children: [questions[i].question.slice(0, 45), "..."] }), _jsx(Text, { color: colors.muted, children: "\u2192" }), _jsx(Text, { color: "green", children: ans })] }, i))) })), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "yellow", children: current.question }) }), showOptions ? (_jsxs(Box, { flexDirection: "column", children: [options.map((opt, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: "cyan", children: [" ", i + 1, " "] }), _jsxs(Text, { children: [" ", opt] })] }, i))), _jsxs(Box, { children: [_jsxs(Text, { color: "cyan", children: [" ", otherIndex, " "] }), _jsx(Text, { dimColor: true, children: " Other (type your own)" })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["press 1-", otherIndex, " \u00B7 's' to skip"] }) })] })) : (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["type 's' to skip \u00B7 ", isLast ? 'Enter to submit' : 'Enter for next question'] }), _jsxs(Box, { borderStyle: "round", borderColor: "green", paddingX: 1, marginTop: 1, children: [_jsx(Text, { bold: true, color: "green", children: " You: " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit, placeholder: otherMode ? 'Your own answer...' : 'Your answer...' })] })] }))] }));
+};