vigthoria-cli 1.11.11 → 1.11.17

package/dist/utils/api.d.ts

@@ -237,7 +237,8 @@ export declare class APIClient {
      * on Windows / Node 25+.
      */
     destroy(): void;
-    private getSelfHostedModelsApiUrl;
+    /** Exposed for Balanced 4B agent routing (local inference :8016). */
+    getSelfHostedModelsApiUrl(): string | null;
     login(email: string, password: string): Promise<boolean>;
     loginWithToken(token: string): Promise<boolean>;
     private extractUserProfile;

package/dist/utils/api.js

@@ -12,6 +12,8 @@ import WebSocket from 'ws';
 import { buildSemanticContext } from './context-ranker.js';
 import { getChangedFiles } from './workspace-cache.js';
 import { isSubstantiveAgentAnswer, isToolEvidenceStubAnswer } from './agentRunOutcome.js';
+import { joinV3WorkspacePath, normalizeV3WorkspaceRelativePath } from './v3-workspace-path.js';
+import { buildExecutionHints, isPlannerBuildTask, resolvePlannerAgentTimeoutMs } from './requestIntent.js';
 export const VIGTHORIA_HUB_CREDITS_URL = 'https://hub.vigthoria.io/credits';
 export const VIGTHORIA_SERVER_TEMPORARILY_UNAVAILABLE_MESSAGE = 'Vigthoria Server is temporarily not available. Please try again later. If the issue persists, please contact support.';
 export class CLIError extends Error {
@@ -396,6 +398,7 @@ export class APIClient {
             this.ws = null;
         }
     }
+    /** Exposed for Balanced 4B agent routing (local inference :8016). */
     getSelfHostedModelsApiUrl() {
         const configuredUrl = process.env.VIGTHORIA_SELF_HOSTED_MODELS_API_URL
             || this.config.get('selfHostedModelsApiUrl');
@@ -1446,6 +1449,25 @@ export class APIClient {
         // files are provided inline in localWorkspaceSummary.workspaceFiles.
         const effectiveWorkspacePath = serverWorkspacePath || null;
         const needsHydration = !serverWorkspacePath && !!localWorkspacePath;
+        const agentTaskType = resolvedContext.agentTaskType || 'general';
+        const rawPrompt = resolvedContext.rawPrompt || resolvedContext.prompt || '';
+        const executionHints = (resolvedContext.executionHints && typeof resolvedContext.executionHints === 'object')
+            ? { ...resolvedContext.executionHints }
+            : buildExecutionHints(agentTaskType, rawPrompt, {
+                fastPath: resolvedContext.fastPath,
+            });
+        if (!executionHints.task_kind) {
+            executionHints.task_kind = agentTaskType;
+        }
+        if (!executionHints.classify_from) {
+            executionHints.classify_from = rawPrompt;
+        }
+        if (resolvedContext.workflowType === 'analysis_only' || resolvedContext.workflowType === 'full') {
+            executionHints.workflow_type = resolvedContext.workflowType;
+            if (resolvedContext.workflowType === 'analysis_only') {
+                executionHints.requires_file_changes = false;
+            }
+        }
         const payload = {
             workspace: this.buildPublicWorkspaceDescriptor(resolvedContext.workspace, {
                 localWorkspacePath,
@@ -1453,16 +1475,11 @@ export class APIClient {
             }),
             activeFile: resolvedContext.activeFile || null,
             history: resolvedContext.history || [],
-            agentTaskType: resolvedContext.agentTaskType || 'general',
-            rawPrompt: resolvedContext.rawPrompt || resolvedContext.prompt || '',
+            agentTaskType,
+            workflowType: executionHints.workflow_type,
+            rawPrompt,
             contextualPrompt: resolvedContext.contextualPrompt || '',
-            executionHints: {
-                task_kind: resolvedContext.agentTaskType || 'general',
-                requires_file_changes: resolvedContext.agentTaskType === 'analysis' || resolvedContext.agentTaskType === 'verification'
-                    ? false
-                    : undefined,
-                classify_from: resolvedContext.rawPrompt || resolvedContext.prompt || '',
-            },
+            executionHints,
             model: resolvedModel,
             requestedModel,
             requestedModelResolved: resolvedModel,
@@ -1523,6 +1540,9 @@ export class APIClient {
         let json = JSON.stringify(payload);
         if (json.length <= LIMIT)
             return json;
+        if (!/^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_QUIET_CONTEXT_COMPACTION || ''))) {
+            process.stderr.write(`Workspace context is large - sent a focused summary (${Math.round(LIMIT / 1000)}k limit).\n`);
+        }
         if (process.env.DEBUG || process.env.VIGTHORIA_DEBUG) {
             process.stderr.write(`[context] Payload ${json.length} chars exceeds ${LIMIT} limit, compacting...\n`);
         }
@@ -1651,6 +1671,25 @@ export class APIClient {
         const localWorkspaceRef = localWorkspaceName ? `vigthoria://local-workspace/${localWorkspaceName}` : null;
         const rawBrain = resolvedContext.vigthoriaBrain || resolvedContext.vigthoria_brain || null;
         const dedupedBrain = rawBrain ? this.dedupeBrainPayload(rawBrain) : null;
+        const agentTaskType = resolvedContext.agentTaskType || 'general';
+        const rawPrompt = resolvedContext.rawPrompt || resolvedContext.prompt || '';
+        const executionHints = (resolvedContext.executionHints && typeof resolvedContext.executionHints === 'object')
+            ? { ...resolvedContext.executionHints }
+            : buildExecutionHints(agentTaskType, rawPrompt, {
+                fastPath: resolvedContext.fastPath,
+            });
+        if (!executionHints.task_kind) {
+            executionHints.task_kind = agentTaskType;
+        }
+        if (!executionHints.classify_from) {
+            executionHints.classify_from = rawPrompt;
+        }
+        if (resolvedContext.workflowType === 'analysis_only' || resolvedContext.workflowType === 'full') {
+            executionHints.workflow_type = resolvedContext.workflowType;
+            if (resolvedContext.workflowType === 'analysis_only') {
+                executionHints.requires_file_changes = false;
+            }
+        }
         return JSON.stringify({
             workspace: this.buildPublicWorkspaceDescriptor(resolvedContext.workspace, {
                 localWorkspacePath: targetPath,
@@ -1658,16 +1697,11 @@ export class APIClient {
             }),
             activeFile: resolvedContext.activeFile || null,
             history: resolvedContext.history || [],
-            agentTaskType: resolvedContext.agentTaskType || 'general',
-            rawPrompt: resolvedContext.rawPrompt || resolvedContext.prompt || '',
+            agentTaskType,
+            workflowType: executionHints.workflow_type,
+            rawPrompt,
             contextualPrompt: resolvedContext.contextualPrompt || '',
-            executionHints: {
-                task_kind: resolvedContext.agentTaskType || 'general',
-                requires_file_changes: resolvedContext.agentTaskType === 'analysis' || resolvedContext.agentTaskType === 'verification'
-                    ? false
-                    : undefined,
-                classify_from: resolvedContext.rawPrompt || resolvedContext.prompt || '',
-            },
+            executionHints,
             executionSurface: resolvedContext.executionSurface || 'cli',
             clientSurface: resolvedContext.clientSurface || 'cli',
             localMachineCapable: resolvedContext.localMachineCapable !== false,
@@ -2660,7 +2694,7 @@ menu {
         if (!relativePath && String(rawPath || '.').trim() !== '.') {
             return null;
         }
-        const absolutePath = path.resolve(rootPath, relativePath || '.');
+        const absolutePath = relativePath ? joinV3WorkspacePath(rootPath, relativePath) : path.resolve(rootPath);
         const resolvedRoot = path.resolve(rootPath);
         if (absolutePath !== resolvedRoot && !absolutePath.startsWith(resolvedRoot + path.sep)) {
             return null;
@@ -2864,7 +2898,7 @@ menu {
         if (!relativePath) {
             return false;
         }
-        const absolutePath = path.resolve(rootPath, relativePath);
+        const absolutePath = joinV3WorkspacePath(rootPath, relativePath);
         const resolvedRoot = path.resolve(rootPath);
         if (absolutePath !== resolvedRoot && !absolutePath.startsWith(resolvedRoot + path.sep)) {
             this.logger.warn(`Refusing to write V3 file outside workspace: ${rawPath}`);
@@ -2891,7 +2925,7 @@ menu {
         if (!relativePath) {
             return false;
         }
-        const absolutePath = path.resolve(rootPath, relativePath);
+        const absolutePath = joinV3WorkspacePath(rootPath, relativePath);
         const resolvedRoot = path.resolve(rootPath);
         if (absolutePath !== resolvedRoot && !absolutePath.startsWith(resolvedRoot + path.sep)) {
             this.logger.warn(`Refusing to delete V3 file outside workspace: ${rawPath}`);
@@ -2935,56 +2969,7 @@ menu {
         }
     }
     normalizeAgentWorkspaceRelativePath(rawPath, rootPath) {
-        const input = String(rawPath || '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
-        if (!input) {
-            return '';
-        }
-        const safeRelative = (candidate) => {
-            const stripped = String(candidate || '').replace(/^\/+/, '');
-            if (!stripped || /^[a-zA-Z]:\//.test(stripped)) {
-                return '';
-            }
-            const normalized = path.posix.normalize(stripped);
-            if (!normalized || normalized === '.' || normalized === '..' || normalized.startsWith('../') || path.posix.isAbsolute(normalized)) {
-                return '';
-            }
-            return normalized;
-        };
-        const internalWorkspacePatterns = [
-            /^\/?var\/www\/\.vigthoria\/v3-temp\/vig-remote-[^/]+\/(.+)$/i,
-            /^\.vigthoria\/v3-temp\/vig-remote-[^/]+\/(.+)$/i,
-            /^\/?tmp\/vig-remote(?:-server)?-[^/]+\/(.+)$/i,
-            /^\/?tmp\/vig-fork-[^/]+\/(.+)$/i,
-            /^\/?home\/user\/(.+)$/i,
-            /^\/?root\/(.+)$/i,
-        ];
-        for (const pattern of internalWorkspacePatterns) {
-            const match = input.match(pattern);
-            if (match && match[1]) {
-                return safeRelative(match[1]);
-            }
-        }
-        const normalizedRoot = String(rootPath || '').trim().replace(/\\/g, '/').replace(/\/+$/g, '');
-        if (normalizedRoot) {
-            const rootNoLeadingSlash = normalizedRoot.replace(/^\//, '');
-            const rootBase = path.posix.basename(normalizedRoot);
-            const prefixes = [
-                `${normalizedRoot}/`,
-                `${rootNoLeadingSlash}/`,
-                `${rootBase}/`,
-            ];
-            for (const prefix of prefixes) {
-                if (input.startsWith(prefix)) {
-                    return safeRelative(input.slice(prefix.length));
-                }
-            }
-            const embeddedRoot = `/${rootBase}/`;
-            const embeddedIndex = input.indexOf(embeddedRoot);
-            if (embeddedIndex >= 0) {
-                return safeRelative(input.slice(embeddedIndex + embeddedRoot.length));
-            }
-        }
-        return safeRelative(input);
+        return normalizeV3WorkspaceRelativePath(rawPath, rootPath);
     }
     async ensureAgentFrontendPolish(message = '', context = {}) {
         const rootPath = this.resolveAgentTargetPath(context);
@@ -3542,7 +3527,15 @@ document.addEventListener('DOMContentLoaded', () => {
         this.activeV3StreamedFiles = streamedFiles;
         this.activeV3StreamContext = context;
         context.__v3StreamedFiles = streamedFiles;
-        const idleTimeoutMs = context.agentIdleTimeoutMs || DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS;
+        const idleTimeoutMs = (() => {
+            const base = context.agentIdleTimeoutMs || DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS;
+            if (isPlannerBuildTask(String(context.agentTaskType || ''), String(context.rawPrompt || ''))) {
+                const raw = process.env.VIGTHORIA_AGENT_PLANNER_IDLE_TIMEOUT_MS || '300000';
+                const extended = Number.parseInt(raw, 10);
+                return Math.max(base, Number.isFinite(extended) && extended > 0 ? extended : 300000);
+            }
+            return base;
+        })();
         try {
             while (true) {
                 let chunk;
@@ -3562,6 +3555,9 @@ document.addEventListener('DOMContentLoaded', () => {
                             chunk = result;
                             break;
                         }
+                        if (this.pendingV3ClientToolTasks.size > 0) {
+                            continue;
+                        }
                         if (this.hasAgentWorkspaceOutput(context)) {
                             const stalledError = new Error('V3 agent stream stalled after writing workspace output');
                             stalledError.name = 'AbortError';
@@ -3748,7 +3744,9 @@ document.addEventListener('DOMContentLoaded', () => {
             && context.localMachineCapable !== false;
         const rescueEligibleSaaS = preferLocalV3
             && /(saas|dashboard|analytics|billing|team management|activity feed|login screen)/i.test(message);
-        const timeoutMs = baseTimeoutMs > 0 && rescueEligibleSaaS ? Math.min(baseTimeoutMs, 210000) : baseTimeoutMs;
+        const timeoutMs = rescueEligibleSaaS
+            ? Math.min(resolvePlannerAgentTimeoutMs(baseTimeoutMs, String(executionContext.agentTaskType || ''), String(executionContext.rawPrompt || message || '')), 210000)
+            : resolvePlannerAgentTimeoutMs(baseTimeoutMs, String(executionContext.agentTaskType || ''), String(executionContext.rawPrompt || message || ''));
         const maxAttempts = preferLocalV3 ? 2 : 1;
         let lastErrors = [];
         for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {

package/dist/utils/deckEvents.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Structured events for Vigthoria Workbench (VIGTHORIA_DECK_MODE=1).
+ * Emitted as single lines: @vigthoria-deck:{json}
+ * Workbench strips these from terminal display and updates UI panels.
+ */
+export type DeckEventType = 'agent_start' | 'tool_start' | 'tool_end' | 'report_ready' | 'run_complete' | 'run_summary';
+export interface DeckEvent {
+    type: DeckEventType;
+    ts: number;
+    [key: string]: unknown;
+}
+export declare function isDeckModeEnabled(): boolean;
+export declare function emitDeckEvent(event: Omit<DeckEvent, 'ts'> & {
+    ts?: number;
+}): void;
+export declare function parseDeckLine(line: string): DeckEvent | null;
+export declare function stripDeckLines(text: string): string;

package/dist/utils/deckEvents.js

@@ -0,0 +1,35 @@
+/**
+ * Structured events for Vigthoria Workbench (VIGTHORIA_DECK_MODE=1).
+ * Emitted as single lines: @vigthoria-deck:{json}
+ * Workbench strips these from terminal display and updates UI panels.
+ */
+const DECK_PREFIX = '@vigthoria-deck:';
+export function isDeckModeEnabled() {
+    return /^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_DECK_MODE || ''));
+}
+export function emitDeckEvent(event) {
+    if (!isDeckModeEnabled())
+        return;
+    const payload = {
+        ...event,
+        ts: event.ts ?? Date.now(),
+    };
+    process.stdout.write(`${DECK_PREFIX}${JSON.stringify(payload)}\n`);
+}
+export function parseDeckLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith(DECK_PREFIX))
+        return null;
+    try {
+        return JSON.parse(trimmed.slice(DECK_PREFIX.length));
+    }
+    catch {
+        return null;
+    }
+}
+export function stripDeckLines(text) {
+    return text
+        .split('\n')
+        .filter((line) => !line.trim().startsWith(DECK_PREFIX))
+        .join('\n');
+}

package/dist/utils/fastAgentRouter.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Vigthoria Balanced 4B — fast agent path classifier (~0.7–2s on local inference :8016).
+ * Regex/trivial detection always wins; LLM router refines ambiguous build prompts only.
+ */
+export type AgentRoutePath = 'template-instant' | 'v3-agent' | 'analysis-only';
+export interface BalancedRouterJson {
+    path?: string;
+    task_kind?: string;
+    taskKind?: string;
+    fast_path?: string | null;
+    fastPath?: string | null;
+    confidence?: number;
+    reason?: string;
+}
+export interface BalancedRouterResult {
+    ok: boolean;
+    raw?: string;
+    parsed?: BalancedRouterJson;
+    latencyMs?: number;
+    model?: string;
+    endpoint?: string;
+    error?: string;
+}
+export declare function parseBalancedRouterJson(raw: string): BalancedRouterJson | null;
+/**
+ * Inference bases for Balanced 4B routing only.
+ * Local developer machines must opt in (env) — avoids ~1.5s localhost probe on every Windows turn.
+ */
+export declare function getInferenceRouterBaseUrls(selfHostedUrl: string | null): string[];
+export declare function isFastInferenceRouterAvailable(selfHostedUrl: string | null, timeoutMs?: number): Promise<boolean>;
+export declare function routeWithBalanced4b(prompt: string, selfHostedUrl: string | null, options?: {
+    timeoutMs?: number;
+}): Promise<BalancedRouterResult>;
+export declare function shouldUseBalancedRouter(prompt: string, regexTaskKind?: string): boolean;

package/dist/utils/fastAgentRouter.js

@@ -0,0 +1,171 @@
+/**
+ * Vigthoria Balanced 4B — fast agent path classifier (~0.7–2s on local inference :8016).
+ * Regex/trivial detection always wins; LLM router refines ambiguous build prompts only.
+ */
+const ROUTER_SYSTEM = `You are Vigthoria Agent Router. Reply with ONE JSON object only. No markdown, no HTML, no code fences.
+
+Paths:
+- template-instant: single trivial HTML page (hello world, one popup, simple static site) — use Template Service
+- v3-agent: multi-file builds, games, refactors, complex implementation
+- analysis-only: read-only review/audit/explain, no workspace writes
+
+task_kind: web-build | game-build | implementation | analysis | debugging
+fast_path: "template-instant" or null
+
+Example: {"path":"template-instant","task_kind":"web-build","fast_path":"template-instant","confidence":0.95,"reason":"trivial html popup page"}`;
+const INFERENCE_MODEL_IDS = [
+    'vigthoria-balanced-4b',
+    'vigthoria-v3-balanced-4b',
+];
+function normalizePath(value) {
+    const p = String(value || '').trim().toLowerCase();
+    if (p === 'template-instant' || p === 'template' || p === 'html-template') {
+        return 'template-instant';
+    }
+    if (p === 'analysis-only' || p === 'analysis') {
+        return 'analysis-only';
+    }
+    if (p === 'v3-agent' || p === 'v3' || p === 'agent') {
+        return 'v3-agent';
+    }
+    return null;
+}
+export function parseBalancedRouterJson(raw) {
+    const text = String(raw || '').trim();
+    if (!text)
+        return null;
+    const start = text.indexOf('{');
+    if (start < 0)
+        return null;
+    let depth = 0;
+    for (let i = start; i < text.length; i += 1) {
+        if (text[i] === '{')
+            depth += 1;
+        if (text[i] === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                try {
+                    return JSON.parse(text.slice(start, i + 1));
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Inference bases for Balanced 4B routing only.
+ * Local developer machines must opt in (env) — avoids ~1.5s localhost probe on every Windows turn.
+ */
+export function getInferenceRouterBaseUrls(selfHostedUrl) {
+    const urls = [
+        process.env.VIGTHORIA_INFERENCE_URL,
+        process.env.VIGTHORIA_SELF_HOSTED_MODELS_API_URL,
+        selfHostedUrl,
+    ].filter(Boolean).map((u) => String(u).replace(/\/$/, ''));
+    const allowLocalhost = process.env.VIGTHORIA_ENABLE_LOCAL_INFERENCE_ROUTER === '1'
+        || process.env.VIGTHORIA_AGENT_LLM_ROUTER === '1'
+        || process.platform === 'linux';
+    if (allowLocalhost) {
+        urls.push('http://127.0.0.1:8016');
+    }
+    return [...new Set(urls)];
+}
+let inferenceHealthCache = null;
+export async function isFastInferenceRouterAvailable(selfHostedUrl, timeoutMs = 400) {
+    if (process.env.VIGTHORIA_AGENT_LLM_ROUTER === '0') {
+        return false;
+    }
+    const now = Date.now();
+    if (inferenceHealthCache && now - inferenceHealthCache.checkedAt < 60_000) {
+        return inferenceHealthCache.ok;
+    }
+    for (const base of getInferenceRouterBaseUrls(selfHostedUrl)) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(`${base}/health`, { signal: controller.signal });
+            clearTimeout(timer);
+            if (response.ok) {
+                inferenceHealthCache = { ok: true, checkedAt: now };
+                return true;
+            }
+        }
+        catch {
+            clearTimeout(timer);
+        }
+    }
+    inferenceHealthCache = { ok: false, checkedAt: now };
+    return false;
+}
+export async function routeWithBalanced4b(prompt, selfHostedUrl, options = {}) {
+    const timeoutMs = options.timeoutMs ?? Number.parseInt(process.env.VIGTHORIA_AGENT_ROUTER_TIMEOUT_MS || '8000', 10);
+    const bases = getInferenceRouterBaseUrls(selfHostedUrl);
+    let lastError = 'Inference router unreachable';
+    for (const base of bases) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const started = Date.now();
+        for (const model of INFERENCE_MODEL_IDS) {
+            try {
+                const response = await fetch(`${base}/v1/chat/completions`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        model,
+                        messages: [
+                            { role: 'system', content: ROUTER_SYSTEM },
+                            { role: 'user', content: String(prompt || '').slice(0, 1200) },
+                        ],
+                        max_tokens: 96,
+                        temperature: 0,
+                        stream: false,
+                    }),
+                    signal: controller.signal,
+                });
+                clearTimeout(timer);
+                const payload = await response.json().catch(() => null);
+                if (!response.ok) {
+                    lastError = `HTTP ${response.status} from ${base}`;
+                    continue;
+                }
+                const raw = payload?.choices?.[0]?.message?.content || '';
+                const parsed = parseBalancedRouterJson(raw);
+                if (!parsed) {
+                    lastError = 'Router returned non-JSON';
+                    continue;
+                }
+                return {
+                    ok: true,
+                    raw,
+                    parsed,
+                    latencyMs: Date.now() - started,
+                    model,
+                    endpoint: base,
+                };
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : String(err);
+            }
+        }
+        clearTimeout(timer);
+    }
+    return { ok: false, error: lastError };
+}
+export function shouldUseBalancedRouter(prompt, regexTaskKind = '') {
+    if (process.env.VIGTHORIA_AGENT_LLM_ROUTER === '0') {
+        return false;
+    }
+    const kind = String(regexTaskKind || '').toLowerCase();
+    // Regex already resolved clear build families — LLM must not override (e.g. landing → implementation).
+    if (kind === 'web-build' || kind === 'game-build') {
+        return false;
+    }
+    const text = String(prompt || '').trim();
+    if (text.length > 700 || text.length < 12) {
+        return false;
+    }
+    return true;
+}

package/dist/utils/requestIntent.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared prompt intent detection for CLI routing, V3 hints, and rescue gating.
+ * Keep aligned with V3-Code-Agent/agent.py _classify_request heuristics.
+ */
+/** Strip CLI-appended platform / mode shaping so it cannot flip quality profiles. */
+export declare function stripExecutionShaping(prompt: string): string;
+export declare function hasBuildVerb(prompt: string): boolean;
+export declare function hasArtifactNoun(prompt: string): boolean;
+export declare function hasGameIntent(prompt: string): boolean;
+export declare function isContinueOrRetryPrompt(prompt: string): boolean;
+export declare function hasWebPageIntent(prompt: string): boolean;
+export declare function isTrivialHtmlPageRequest(prompt: string): boolean;
+export declare function hasCloneBuildIntent(prompt: string): boolean;
+export declare function hasExplicitWriteIntent(prompt: string): boolean;
+export declare function taskRequiresWorkspaceChanges(prompt: string): boolean;
+export declare function inferAgentTaskType(prompt: string): string;
+export declare function shouldSkipAnalysisRescue(liveOutcome: {
+    tasksTotal?: number;
+    changedFileCount?: number;
+    requiresWorkspaceChanges?: boolean;
+}): boolean;
+export declare function isPlannerBuildTask(agentTaskType: string, prompt: string): boolean;
+export declare function resolvePlannerAgentTimeoutMs(baseTimeoutMs: number, agentTaskType: string, prompt: string): number;
+/** V3 workflow mode: suppress write path when the user did not ask for file changes. */
+export declare function resolveWorkflowType(agentTaskType: string, prompt: string): 'analysis_only' | 'full';
+export declare function buildExecutionHints(agentTaskType: string, prompt: string, options?: {
+    fastPath?: string;
+}): {
+    task_kind: string;
+    requires_file_changes: boolean | undefined;
+    classify_from: string;
+    workflow_type: 'analysis_only' | 'full';
+    fast_path?: string;
+};