@iaforged/context-code 1.1.7 → 1.2.1

package/dist/src/services/api/errors.js

@@ -93,7 +93,7 @@ export function isMediaSizeErrorMessage(msg) {
         isMediaSizeError(msg.errorDetails));
 }
 export const CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE = 'Credit balance is too low';
-export const INVALID_API_KEY_ERROR_MESSAGE = 'Not logged in · Please run /login';
+export const INVALID_API_KEY_ERROR_MESSAGE = 'No has iniciado sesion · Ejecuta /login';
 export const INVALID_API_KEY_ERROR_MESSAGE_EXTERNAL = 'Invalid API key · Fix external API key';
 export const ORG_DISABLED_ERROR_MESSAGE_ENV_KEY_WITH_OAUTH = 'Your ANTHROPIC_API_KEY belongs to a disabled organization · Unset the environment variable to use your subscription instead';
 export const ORG_DISABLED_ERROR_MESSAGE_ENV_KEY = 'Your ANTHROPIC_API_KEY belongs to a disabled organization · Update or unset the environment variable';

package/dist/src/services/api/openai.js

@@ -11,6 +11,17 @@ import { toolToAPISchema } from '../../utils/api.js';
 import { jsonStringify } from '../../utils/slowOperations.js';
 const OPENAI_EMPTY_CONTENT_MAX_ATTEMPTS = 2;
 const OPENAI_EMPTY_CONTENT_RECOVERY_PROMPT = 'System reminder: your previous response for this turn was empty. Continue the current task without asking the user to repeat themselves. If a tool call is needed, emit the appropriate tool call now. Do not return an empty response.';
+const OPENAI_DEFAULT_MAX_TIMEOUT_RETRIES = 10;
+function getOpenAIMaxTimeoutRetries() {
+    const raw = process.env.CONTEXT_CODE_MAX_RETRIES;
+    if (!raw)
+        return OPENAI_DEFAULT_MAX_TIMEOUT_RETRIES;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return OPENAI_DEFAULT_MAX_TIMEOUT_RETRIES;
+    }
+    return parsed;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -1252,6 +1263,7 @@ async function createChatCompletionResponse({ messages, systemPrompt, tools, sig
             temperature: options.temperatureOverride,
         });
     }
+    const maxTimeoutRetries = getOpenAIMaxTimeoutRetries();
     const sendRequest = async (bearerToken = getOpenAICompatibleAccessToken(provider) ?? '', retryCount = 0) => {
         const url = `${getOpenAIBaseUrl(provider)}/chat/completions`;
         logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] chat.completions request model=${options.model} messages=${chatMessages.length} tools=${chatTools.length} endpoint=${url}${retryCount > 0 ? ` (retry ${retryCount})` : ''}`);
@@ -1294,6 +1306,12 @@ async function createChatCompletionResponse({ messages, systemPrompt, tools, sig
             if (err instanceof Error &&
                 err.name === 'AbortError' &&
                 !signal?.aborted) {
+                if (retryCount < maxTimeoutRetries) {
+                    const backoffMs = 1000 * Math.pow(2, retryCount);
+                    logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] timeout local tras ${timeoutMs}ms, reintentando en ${backoffMs}ms (intento ${retryCount + 1}/${maxTimeoutRetries})`, { level: 'warn' });
+                    await new Promise(resolve => setTimeout(resolve, backoffMs));
+                    return sendRequest(bearerToken, retryCount + 1);
+                }
                 throw new Error(`La solicitud expiró tras ${timeoutMs / 1000}s. El servidor tardó demasiado en responder.`);
             }
             throw err;
@@ -1702,7 +1720,8 @@ async function createOpenAIResponse(params) {
     if (options.effortValue) {
         body.reasoning = { effort: options.effortValue };
     }
-    const sendRequest = async (token) => {
+    const maxTimeoutRetries = getOpenAIMaxTimeoutRetries();
+    const sendRequest = async (token, retryCount = 0) => {
         const requestBody = isCodexOAuth ? { ...body, stream: true } : body;
         let url;
         let headers;
@@ -1725,30 +1744,59 @@ async function createOpenAIResponse(params) {
                 'Content-Type': 'application/json',
             };
         }
-        const response = await fetch(url, {
-            method: 'POST',
-            headers,
-            body: jsonStringify(requestBody),
-            signal,
-        });
-        const data = await readOpenAIResponseBody(response);
-        if (response.status === 401) {
-            const refreshedToken = await maybeRecoverOpenAICompatible401(token, provider);
-            if (refreshedToken) {
-                return sendRequest(refreshedToken);
+        const timeoutMs = 120000;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        const onAbort = () => controller.abort();
+        signal?.addEventListener('abort', onAbort);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: jsonStringify(requestBody),
+                signal: controller.signal,
+            });
+            const data = await readOpenAIResponseBody(response);
+            if (response.status === 504 && retryCount < 1) {
+                logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] responses 504 Gateway Timeout, reintentando...`, { level: 'warn' });
+                return sendRequest(token, retryCount + 1);
+            }
+            if (response.status === 401) {
+                const refreshedToken = await maybeRecoverOpenAICompatible401(token, provider);
+                if (refreshedToken) {
+                    return sendRequest(refreshedToken, retryCount);
+                }
+            }
+            if (!response.ok) {
+                logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] responses error status=${response.status} model=${options.model} endpoint=${url} oauth=${isCodexOAuth} body=${(data.raw_error_text ?? '').replace(/\s+/g, ' ').slice(0, 500)}`, { level: 'error' });
+                throw new Error(buildOpenAIErrorMessage({
+                    status: response.status,
+                    statusText: response.statusText,
+                    url,
+                    model: String(options.model),
+                    data,
+                }));
             }
+            return data;
         }
-        if (!response.ok) {
-            logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] responses error status=${response.status} model=${options.model} endpoint=${url} oauth=${isCodexOAuth} body=${(data.raw_error_text ?? '').replace(/\s+/g, ' ').slice(0, 500)}`, { level: 'error' });
-            throw new Error(buildOpenAIErrorMessage({
-                status: response.status,
-                statusText: response.statusText,
-                url,
-                model: String(options.model),
-                data,
-            }));
+        catch (err) {
+            if (err instanceof Error &&
+                err.name === 'AbortError' &&
+                !signal?.aborted) {
+                if (retryCount < maxTimeoutRetries) {
+                    const backoffMs = 1000 * Math.pow(2, retryCount);
+                    logForDebugging(`[${getOpenAICompatibleProviderLabel(provider)}] responses timeout local tras ${timeoutMs}ms, reintentando en ${backoffMs}ms (intento ${retryCount + 1}/${maxTimeoutRetries})`, { level: 'warn' });
+                    await new Promise(resolve => setTimeout(resolve, backoffMs));
+                    return sendRequest(token, retryCount + 1);
+                }
+                throw new Error(`La solicitud expiró tras ${timeoutMs / 1000}s. El servidor tardó demasiado en responder.`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+            signal?.removeEventListener('abort', onAbort);
         }
-        return data;
     };
     return sendRequest(bearerToken);
 }

package/dist/src/services/api/withRetry.js

@@ -564,8 +564,9 @@ function shouldRetry(error) {
     return false;
 }
 export function getDefaultMaxRetries() {
-    if (process.env.CLAUDE_CODE_MAX_RETRIES) {
-        return parseInt(process.env.CLAUDE_CODE_MAX_RETRIES, 10);
+    const maxRetriesEnv = process.env.CONTEXT_CODE_MAX_RETRIES;
+    if (maxRetriesEnv) {
+        return parseInt(maxRetriesEnv, 10);
     }
     return DEFAULT_MAX_RETRIES;
 }

package/dist/src/skills/loadSkillsDir.js

@@ -407,6 +407,7 @@ export const getSkillDirCommands = memoize(async (cwd) => {
     const userSkillsDir = join(getClaudeConfigHomeDir(), 'skills');
     const managedSkillsDir = join(getManagedFilePath(), '.context', 'skills');
     const projectSkillsDirs = getProjectDirsUpToHome('skills', cwd, '.context');
+    const legacyProjectSkillsDirs = getProjectDirsUpToHome('skills', cwd, '.claude');
     logForDebugging(`Loading skills from: managed=${managedSkillsDir}, user=${userSkillsDir}, project=[${projectSkillsDirs.join(', ')}]`);
     // Load from additional directories (--add-dir)
     const additionalDirs = getAdditionalDirectoriesForClaudeMd();

package/dist/src/tools/AgentTool/UI.js

@@ -276,18 +276,18 @@ export function renderToolResultMessage(data, progressMessagesForMessage, { tool
     // public schema. Narrow via the internal discriminant.
     const internal = data;
     if (internal.status === 'remote_launched') {
-        return _jsx(Box, { flexDirection: "column", children: _jsx(MessageResponse, { height: 1, children: _jsxs(Text, { children: ["Remote agent launched", ' ', _jsxs(Text, { dimColor: true, children: ["\u00B7 ", internal.taskId, " \u00B7 ", internal.sessionUrl] })] }) }) });
+        return _jsx(Box, { flexDirection: "column", children: _jsx(MessageResponse, { height: 1, children: _jsxs(Text, { children: ["Agente remoto iniciado", ' ', _jsxs(Text, { dimColor: true, children: ["\u00B7 ", internal.taskId, " \u00B7 ", internal.sessionUrl] })] }) }) });
     }
     if (data.status === 'async_launched') {
         const { prompt } = data;
-        return _jsxs(Box, { flexDirection: "column", children: [_jsx(MessageResponse, { height: 1, children: _jsxs(Text, { children: ["Backgrounded agent", !isTranscriptMode && _jsxs(Text, { dimColor: true, children: [' (', _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "\u2193", action: "manage" }), prompt && _jsx(ConfigurableShortcutHint, { action: "app:toggleTranscript", context: "Global", fallback: "ctrl+o", description: "expand" })] }), ')'] })] }) }), isTranscriptMode && prompt && _jsx(MessageResponse, { children: _jsx(AgentPromptDisplay, { prompt: prompt, theme: theme }) })] });
+        return _jsxs(Box, { flexDirection: "column", children: [_jsx(MessageResponse, { height: 1, children: _jsxs(Text, { children: ["Agente en segundo plano", !isTranscriptMode && _jsxs(Text, { dimColor: true, children: [' (', _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "\u2193", action: "manage" }), prompt && _jsx(ConfigurableShortcutHint, { action: "app:toggleTranscript", context: "Global", fallback: "ctrl+o", description: "expand" })] }), ')'] })] }) }), isTranscriptMode && prompt && _jsx(MessageResponse, { children: _jsx(AgentPromptDisplay, { prompt: prompt, theme: theme }) })] });
     }
     if (data.status !== 'completed') {
         return null;
     }
     const { agentId, totalDurationMs, totalToolUseCount, totalTokens, usage, content, prompt } = data;
-    const result = [totalToolUseCount === 1 ? '1 tool use' : `${totalToolUseCount} tool uses`, formatNumber(totalTokens) + ' tokens', formatDuration(totalDurationMs)];
-    const completionMessage = `Done (${result.join(' · ')})`;
+    const result = [totalToolUseCount === 1 ? '1 herramienta usada' : `${totalToolUseCount} herramientas usadas`, formatNumber(totalTokens) + ' tokens', formatDuration(totalDurationMs)];
+    const completionMessage = `Listo (${result.join(' · ')})`;
     const finalAssistantMessage = createAssistantMessage({
         content: completionMessage,
         usage: {
@@ -319,7 +319,7 @@ export function renderToolUseTag(input) {
     }
     return _jsx(_Fragment, { children: tags });
 }
-const INITIALIZING_TEXT = 'Initializing…';
+const INITIALIZING_TEXT = 'Inicializando…';
 export function renderToolUseProgressMessage(progressMessages, { tools, verbose, terminalSize, inProgressToolCallCount, isTranscriptMode = false }) {
     if (!progressMessages.length) {
         return _jsx(MessageResponse, { height: 1, children: _jsx(Text, { dimColor: true, children: INITIALIZING_TEXT }) });
@@ -349,7 +349,7 @@ export function renderToolUseProgressMessage(progressMessages, { tools, verbose,
     };
     if (shouldUseCondensedMode) {
         const { toolUseCount, tokens } = getProgressStats();
-        return _jsx(MessageResponse, { height: 1, children: _jsxs(Text, { dimColor: true, children: ["In progress\u2026 \u00B7 ", _jsx(Text, { bold: true, children: toolUseCount }), " tool", ' ', toolUseCount === 1 ? 'use' : 'uses', tokens && ` · ${formatNumber(tokens)} tokens`, " \u00B7", ' ', _jsx(ConfigurableShortcutHint, { action: "app:toggleTranscript", context: "Global", fallback: "ctrl+o", description: "expand", parens: true })] }) });
+        return _jsx(MessageResponse, { height: 1, children: _jsxs(Text, { dimColor: true, children: ["En progreso\u2026 \u00B7 ", _jsx(Text, { bold: true, children: toolUseCount }), " herramienta", ' ', toolUseCount === 1 ? 'usada' : 'usadas', tokens && ` · ${formatNumber(tokens)} tokens`, " \u00B7", ' ', _jsx(ConfigurableShortcutHint, { action: "app:toggleTranscript", context: "Global", fallback: "ctrl+o", description: "expand", parens: true })] }) });
     }
     // Process messages to group consecutive search/read operations into summaries (ants only)
     // isAgentRunning=true since this is the progress view while the agent is still running
@@ -392,7 +392,7 @@ export function renderToolUseProgressMessage(progressMessages, { tools, verbose,
                             // doesn't leave a blank line. Tool call headers are single-line
                             // anyway so truncation isn't needed.
                             return _jsx(MessageComponent, { message: processed.message.data.message, lookups: subagentLookups, addMargin: false, tools: tools, commands: [], verbose: verbose, inProgressToolUseIDs: collapsedInProgressIDs, progressMessagesForMessage: [], shouldAnimate: false, shouldShowDot: false, style: "condensed", isTranscriptMode: false, isStatic: true }, processed.message.uuid);
-                        })] }), hiddenToolUseCount > 0 && _jsxs(Text, { dimColor: true, children: ["+", hiddenToolUseCount, " more tool", ' ', hiddenToolUseCount === 1 ? 'use' : 'uses', " ", _jsx(CtrlOToExpand, {})] })] }) });
+                        })] }), hiddenToolUseCount > 0 && _jsxs(Text, { dimColor: true, children: ["+", hiddenToolUseCount, " herramienta", hiddenToolUseCount === 1 ? '' : 's', " m\u00E1s ", _jsx(CtrlOToExpand, {})] })] }) });
 }
 export function renderToolUseRejectedMessage(_input, { progressMessagesForMessage, tools, verbose, isTranscriptMode }) {
     // Get agentId from progress messages if available (agent was running before rejection)
@@ -490,7 +490,7 @@ export function renderGroupedAgentToolUse(toolUses, options) {
     const commonType = allSameType && agentStats[0]?.agentType !== 'Agent' ? agentStats[0]?.agentType : null;
     // Check if all resolved agents are async (background)
     const allAsync = agentStats.every(stat => stat.isAsync);
-    return _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(ToolUseLoader, { shouldAnimate: shouldAnimate && anyUnresolved, isUnresolved: anyUnresolved, isError: anyError }), _jsxs(Text, { children: [allComplete ? allAsync ? _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: toolUses.length }), " background agents launched", ' ', _jsx(Text, { dimColor: true, children: _jsx(KeyboardShortcutHint, { shortcut: "\u2193", action: "manage", parens: true }) })] }) : _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: toolUses.length }), ' ', commonType ? `${commonType} agents` : 'agents', " finished"] }) : _jsxs(_Fragment, { children: ["Running ", _jsx(Text, { bold: true, children: toolUses.length }), ' ', commonType ? `${commonType} agents` : 'agents', "\u2026"] }), ' '] }), !allAsync && _jsx(CtrlOToExpand, {})] }), agentStats.map((stat, index) => _jsx(AgentProgressLine, { agentType: stat.agentType, description: stat.description, descriptionColor: stat.descriptionColor, taskDescription: stat.taskDescription, toolUseCount: stat.toolUseCount, tokens: stat.tokens, color: stat.color, isLast: index === agentStats.length - 1, isResolved: stat.isResolved, isError: stat.isError, isAsync: stat.isAsync, shouldAnimate: shouldAnimate, lastToolInfo: stat.lastToolInfo, hideType: allSameType, name: stat.name }, stat.id))] });
+    return _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(ToolUseLoader, { shouldAnimate: shouldAnimate && anyUnresolved, isUnresolved: anyUnresolved, isError: anyError }), _jsxs(Text, { children: [allComplete ? allAsync ? _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: toolUses.length }), " agentes en segundo plano iniciados", ' ', _jsx(Text, { dimColor: true, children: _jsx(KeyboardShortcutHint, { shortcut: "\u2193", action: "manage", parens: true }) })] }) : _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: toolUses.length }), ' ', commonType ? `${commonType} agentes` : 'agentes', " finalizados"] }) : _jsxs(_Fragment, { children: ["Ejecutando ", _jsx(Text, { bold: true, children: toolUses.length }), ' ', commonType ? `${commonType} agentes` : 'agentes', "\u2026"] }), ' '] }), !allAsync && _jsx(CtrlOToExpand, {})] }), agentStats.map((stat, index) => _jsx(AgentProgressLine, { agentType: stat.agentType, description: stat.description, descriptionColor: stat.descriptionColor, taskDescription: stat.taskDescription, toolUseCount: stat.toolUseCount, tokens: stat.tokens, color: stat.color, isLast: index === agentStats.length - 1, isResolved: stat.isResolved, isError: stat.isError, isAsync: stat.isAsync, shouldAnimate: shouldAnimate, lastToolInfo: stat.lastToolInfo, hideType: allSameType, name: stat.name }, stat.id))] });
 }
 export function userFacingName(input) {
     if (input?.subagent_type && input.subagent_type !== GENERAL_PURPOSE_AGENT.agentType) {

package/dist/src/tools/AgentTool/loadAgentsDir.js

@@ -23,6 +23,7 @@ import { AGENT_COLORS, setAgentColor, } from './agentColorManager.js';
 import { loadAgentMemoryPrompt } from './agentMemory.js';
 import { checkAgentMemorySnapshot, initializeFromSnapshot, } from './agentMemorySnapshot.js';
 import { getBuiltInAgents } from './builtInAgents.js';
+import { loadProviderBackedAgentDefinitions } from './providerAgents.js';
 // Zod schema for agent MCP server specs
 const AgentMcpServerSpecSchema = lazySchema(() => z.union([
     z.string(), // Reference by name
@@ -182,22 +183,26 @@ export const getAgentDefinitionsWithOverrides = memoize(async (cwd) => {
             return agent;
         })
             .filter(agent => agent !== null);
-        // Kick off plugin agent loading concurrently with memory snapshot init —
-        // loadPluginAgents is memoized and takes no args, so it's independent.
-        // Join both so neither becomes a floating promise if the other throws.
+        // Kick off plugin/provider agent loading concurrently with memory snapshot init.
+        // Both loaders are independent and we join to avoid floating promises.
         let pluginAgentsPromise = loadPluginAgents();
+        let providerAgentsPromise = loadProviderBackedAgentDefinitions();
         if (feature('AGENT_MEMORY_SNAPSHOT') && isAutoMemoryEnabled()) {
-            const [pluginAgents_] = await Promise.all([
+            const [pluginAgents_, providerAgents_] = await Promise.all([
                 pluginAgentsPromise,
+                providerAgentsPromise,
                 initializeAgentMemorySnapshots(customAgents),
             ]);
             pluginAgentsPromise = Promise.resolve(pluginAgents_);
+            providerAgentsPromise = Promise.resolve(providerAgents_);
         }
         const pluginAgents = await pluginAgentsPromise;
+        const providerAgents = await providerAgentsPromise;
         const builtInAgents = getBuiltInAgents();
         const allAgentsList = [
             ...builtInAgents,
             ...pluginAgents,
+            ...providerAgents,
             ...customAgents,
         ];
         const activeAgents = getActiveAgentsFromList(allAgentsList);

package/dist/src/tools/AgentTool/providerAgents.js

@@ -0,0 +1,71 @@
+import { getProviderProfile } from '../../utils/model/providerProfiles.js';
+import { getVisibleProvider } from '../../utils/model/providerCatalog.js';
+import { getProviderWorkspaceById, listProviderAgents, } from '../../utils/orchestration/store/index.js';
+const PROVIDER_AGENT_PREFIX = 'provider';
+function sanitizeSegment(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function toAgentType(provider, name) {
+    const providerSegment = sanitizeSegment(provider) || 'provider';
+    const nameSegment = sanitizeSegment(name) || 'agent';
+    return `${PROVIDER_AGENT_PREFIX}-${providerSegment}-${nameSegment}`;
+}
+function toWhenToUse(params) {
+    const providerLabel = getVisibleProvider(params.provider).label;
+    const role = params.roleKind?.trim() || 'worker';
+    const orchestrator = params.isOrchestrator ? 'si' : 'no';
+    return `Agente del proveedor ${providerLabel}. Rol: ${role}. Orquestador: ${orchestrator}.`;
+}
+function toSystemPrompt(params) {
+    const providerLabel = getVisibleProvider(params.provider).label;
+    const role = params.roleKind?.trim() || 'worker';
+    const userPrompt = params.systemPrompt?.trim();
+    const base = [
+        `Eres un agente especializado para el proveedor ${providerLabel}.`,
+        `Rol operativo: ${role}.`,
+        'Responde de forma concreta, ejecuta tareas completas y reporta resultados verificables.',
+    ].join('\n');
+    return userPrompt ? `${base}\n\n${userPrompt}` : base;
+}
+export async function loadProviderBackedAgentDefinitions() {
+    const records = await listProviderAgents({ isEnabled: true });
+    const providerAgents = [];
+    for (const record of records) {
+        const workspace = await getProviderWorkspaceById(record.workspaceId);
+        if (!workspace) {
+            continue;
+        }
+        const provider = workspace.provider;
+        const profile = getProviderProfile(record.profileId);
+        const profileLabel = profile ? `${profile.provider}/${profile.name}` : null;
+        providerAgents.push({
+            agentType: toAgentType(provider, record.name),
+            filename: record.name,
+            baseDir: 'provider-agents',
+            source: 'projectSettings',
+            whenToUse: toWhenToUse({
+                provider,
+                roleKind: record.roleKind,
+                isOrchestrator: record.isOrchestrator,
+            }),
+            provider,
+            ...(record.modelOverride ? { model: record.modelOverride } : {}),
+            getSystemPrompt: () => [
+                toSystemPrompt({
+                    provider,
+                    roleKind: record.roleKind,
+                    systemPrompt: record.systemPrompt,
+                }),
+                profileLabel ? `Perfil asociado: ${profileLabel}.` : null,
+                `Nombre del agente: ${record.name}.`,
+            ]
+                .filter(Boolean)
+                .join('\n'),
+        });
+    }
+    return providerAgents;
+}

package/dist/src/tools/BashTool/bashSecurity.js

@@ -1796,7 +1796,7 @@ function validateCommentQuoteDesync(context) {
                 });
                 return {
                     behavior: 'ask',
-                    message: 'Command contains quote characters inside a # comment which can desync quote tracking',
+                    message: 'El comando contiene comillas dentro de un comentario con #, lo que puede desincronizar el analisis de comillas',
                 };
             }
             // Skip to end of line (rest is comment)

package/dist/src/utils/handlePromptSubmit.js

@@ -16,7 +16,7 @@ function exit() {
     gracefulShutdownSync(0);
 }
 export async function handlePromptSubmit(params) {
-    const { helpers, queryGuard, isExternalLoading = false, commands, onInputChange, setPastedContents, setToolJSX, getToolUseContext, messages, mainLoopModel, ideSelection, setUserInputOnProcessing, setAbortController, onQuery, setAppState, onBeforeQuery, canUseTool, queuedCommands, uuid, skipSlashCommands, } = params;
+    const { helpers, queryGuard, isExternalLoading = false, commands, onInputChange, setPastedContents, setToolJSX, getToolUseContext, messages, mainLoopModel, ideSelection, setUserInputOnProcessing, setAbortController, onQuery, setAppState, onBeforeQuery, canUseTool, queuedCommands, uuid, skipSlashCommands, onJumpToMessage, } = params;
     const { setCursorOffset, clearBuffer, resetHistory } = helpers;
     // Queue processor path: commands are pre-validated and ready to execute.
     // Skip all input validation, reference parsing, and queuing logic.
@@ -40,6 +40,7 @@ export async function handlePromptSubmit(params) {
             resetHistory,
             canUseTool,
             onInputChange,
+            onJumpToMessage: params.onJumpToMessage,
         });
         return;
     }
@@ -131,6 +132,9 @@ export async function handlePromptSubmit(params) {
                         onInputChange(options.nextInput);
                     }
                 }
+                if (options?.jumpToMessageId) {
+                    params.onJumpToMessage?.(options.jumpToMessageId);
+                }
             };
             const impl = await immediateCommand.load();
             const jsx = await impl.call(onDone, context, commandArgs);
@@ -210,6 +214,7 @@ export async function handlePromptSubmit(params) {
         resetHistory,
         canUseTool,
         onInputChange,
+        onJumpToMessage: params.onJumpToMessage,
     });
 }
 /**
@@ -220,7 +225,7 @@ export async function handlePromptSubmit(params) {
  * get `skipAttachments` to avoid duplicating turn-level context.
  */
 async function executeUserInput(params) {
-    const { messages, mainLoopModel, ideSelection, querySource, queryGuard, setToolJSX, getToolUseContext, setUserInputOnProcessing, setAbortController, onQuery, setAppState, onBeforeQuery, resetHistory, canUseTool, queuedCommands, } = params;
+    const { messages, mainLoopModel, ideSelection, querySource, queryGuard, setToolJSX, getToolUseContext, setUserInputOnProcessing, setAbortController, onQuery, setAppState, onBeforeQuery, resetHistory, canUseTool, queuedCommands, onJumpToMessage, } = params;
     // Note: paste references are already processed before calling this function
     // (either in handlePromptSubmit before queuing, or before initial execution).
     // Always create a fresh abort controller — queryGuard guarantees no concurrent
@@ -250,6 +255,7 @@ async function executeUserInput(params) {
         let effort;
         let nextInput;
         let submitNextInput;
+        let jumpToMessageId;
         // Iterate all commands uniformly. First command gets attachments +
         // ideSelection + pastedContents, rest skip attachments to avoid
         // duplicating turn-level context (IDE selection, todos, diffs).
@@ -320,6 +326,7 @@ async function executeUserInput(params) {
                     effort = result.effort;
                     nextInput = result.nextInput;
                     submitNextInput = result.submitNextInput;
+                    jumpToMessageId = result.jumpToMessageId;
                 }
             }
             queryCheckpoint('query_process_user_input_end');
@@ -380,6 +387,9 @@ async function executeUserInput(params) {
                     params.onInputChange(nextInput);
                 }
             }
+            if (jumpToMessageId) {
+                onJumpToMessage?.(jumpToMessageId);
+            }
         }); // end runWithWorkload — ALS context naturally scoped, no finally needed
     }
     finally {

package/dist/src/utils/processUserInput/processSlashCommand.js

@@ -344,7 +344,7 @@ export async function processSlashCommand(inputString, precedingInputBlocks, ima
         };
     }
     // Track slash command usage for feature discovery
-    const { messages: newMessages, shouldQuery: messageShouldQuery, allowedTools, model, effort, command: returnedCommand, resultText, nextInput, submitNextInput } = await getMessagesForSlashCommand(commandName, parsedArgs, setToolJSX, context, precedingInputBlocks, imageContentBlocks, isAlreadyProcessing, canUseTool, uuid);
+    const { messages: newMessages, shouldQuery: messageShouldQuery, allowedTools, model, effort, command: returnedCommand, resultText, nextInput, submitNextInput, jumpToMessageId } = await getMessagesForSlashCommand(commandName, parsedArgs, setToolJSX, context, precedingInputBlocks, imageContentBlocks, isAlreadyProcessing, canUseTool, uuid);
     // Local slash commands that skip messages
     if (newMessages.length === 0) {
         const eventData = {
@@ -390,7 +390,8 @@ export async function processSlashCommand(inputString, precedingInputBlocks, ima
             shouldQuery: false,
             model,
             nextInput,
-            submitNextInput
+            submitNextInput,
+            jumpToMessageId
         };
     }
     // For invalid commands, preserve both the user message and error
@@ -455,7 +456,8 @@ export async function processSlashCommand(inputString, precedingInputBlocks, ima
         effort,
         resultText,
         nextInput,
-        submitNextInput
+        submitNextInput,
+        jumpToMessageId
     };
 }
 async function getMessagesForSlashCommand(commandName, args, setToolJSX, context, precedingInputBlocks, imageContentBlocks, _isAlreadyProcessing, canUseTool, uuid) {
@@ -507,7 +509,8 @@ async function getMessagesForSlashCommand(commandName, args, setToolJSX, context
                                     shouldQuery: false,
                                     command,
                                     nextInput: options?.nextInput,
-                                    submitNextInput: options?.submitNextInput
+                                    submitNextInput: options?.submitNextInput,
+                                    jumpToMessageId: options?.jumpToMessageId
                                 });
                                 return;
                             }
@@ -541,7 +544,8 @@ async function getMessagesForSlashCommand(commandName, args, setToolJSX, context
                                 shouldQuery: options?.shouldQuery ?? false,
                                 command,
                                 nextInput: options?.nextInput,
-                                submitNextInput: options?.submitNextInput
+                                submitNextInput: options?.submitNextInput,
+                                jumpToMessageId: options?.jumpToMessageId
                             });
                         };
                         void command.load().then(mod => mod.call(onDone, {

package/dist/src/utils/sembleMcp/common.js

@@ -0,0 +1,5 @@
+/**
+ * Constants for the Semble MCP server.
+ */
+export const SEMBLE_MCP_SERVER_NAME = 'semble';
+export const SEMBLE_MCP_TOOLS = ['search', 'find_related'];

package/dist/src/utils/sembleMcp/setup.js

@@ -0,0 +1,119 @@
+import { spawnSync } from 'child_process';
+import envPaths from 'env-paths';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { buildMcpToolName } from '../../services/mcp/mcpStringUtils.js';
+import { whichSync } from '../which.js';
+import { SEMBLE_MCP_SERVER_NAME, SEMBLE_MCP_TOOLS } from './common.js';
+const paths = envPaths('claude-cli');
+const SEMBLE_PACKAGE_SPEC = 'semble[mcp]';
+const SEMBLE_BOOTSTRAP_VERSION = 1;
+const SEMBLE_BOOTSTRAP_MARKER = join(paths.cache, 'semble-bootstrap.json');
+const MANAGED_UV_DIR = join(paths.data, 'uv');
+const MANAGED_UV_PATH = join(MANAGED_UV_DIR, process.platform === 'win32' ? 'uv.exe' : 'uv');
+function readBootstrapState() {
+    if (!existsSync(SEMBLE_BOOTSTRAP_MARKER)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(SEMBLE_BOOTSTRAP_MARKER, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeBootstrapState() {
+    mkdirSync(dirname(SEMBLE_BOOTSTRAP_MARKER), { recursive: true });
+    writeFileSync(SEMBLE_BOOTSTRAP_MARKER, JSON.stringify({
+        version: SEMBLE_BOOTSTRAP_VERSION,
+        packageSpec: SEMBLE_PACKAGE_SPEC,
+    }, null, 2), 'utf8');
+}
+function runChecked(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.status !== 0) {
+        const stderr = result.stderr?.trim() || result.stdout?.trim() || 'unknown error';
+        throw new Error(`${command} ${args.join(' ')} failed: ${stderr}`);
+    }
+}
+function installManagedUv() {
+    mkdirSync(MANAGED_UV_DIR, { recursive: true });
+    if (process.platform === 'win32') {
+        const powershellPath = whichSync('powershell') ?? whichSync('pwsh');
+        if (!powershellPath) {
+            throw new Error('PowerShell is required to install uv automatically on Windows');
+        }
+        runChecked(powershellPath, [
+            '-ExecutionPolicy',
+            'ByPass',
+            '-Command',
+            `$env:UV_INSTALL_DIR='${MANAGED_UV_DIR.replace(/'/g, "''")}'; $env:UV_NO_MODIFY_PATH='1'; irm https://astral.sh/uv/install.ps1 | iex`,
+        ], process.cwd());
+    }
+    else {
+        const hasCurl = whichSync('curl');
+        const hasWget = whichSync('wget');
+        if (!hasCurl && !hasWget) {
+            throw new Error('curl or wget is required to install uv automatically');
+        }
+        const installer = hasCurl
+            ? `curl -LsSf https://astral.sh/uv/install.sh | env UV_INSTALL_DIR="${MANAGED_UV_DIR}" UV_NO_MODIFY_PATH=1 sh`
+            : `wget -qO- https://astral.sh/uv/install.sh | env UV_INSTALL_DIR="${MANAGED_UV_DIR}" UV_NO_MODIFY_PATH=1 sh`;
+        runChecked('sh', ['-c', installer], process.cwd());
+    }
+    if (!existsSync(MANAGED_UV_PATH)) {
+        throw new Error(`uv installation finished but binary was not found at ${MANAGED_UV_PATH}`);
+    }
+    return MANAGED_UV_PATH;
+}
+function ensureUvAvailable() {
+    return (whichSync('uv') ??
+        (existsSync(MANAGED_UV_PATH) ? MANAGED_UV_PATH : installManagedUv()));
+}
+function ensureSembleBootstrap(uvPath, cwd) {
+    const current = readBootstrapState();
+    if (current?.version === SEMBLE_BOOTSTRAP_VERSION &&
+        current.packageSpec === SEMBLE_PACKAGE_SPEC) {
+        return;
+    }
+    // Persist the tool environment so the MCP does not depend on a disposable cache.
+    runChecked(uvPath, ['tool', 'install', SEMBLE_PACKAGE_SPEC], cwd);
+    // Warm the cache once so Model2Vec downloads the local embedding model eagerly.
+    runChecked(uvPath, [
+        'tool',
+        'run',
+        '--from',
+        SEMBLE_PACKAGE_SPEC,
+        'semble',
+        'search',
+        'bootstrap',
+        cwd,
+        '--top-k',
+        '1',
+    ], cwd);
+    writeBootstrapState();
+}
+/**
+ * Setup the Semble MCP server as a dynamic stdio server.
+ * The server bootstraps its runtime dependencies automatically on first use.
+ */
+export function setupSembleMCP() {
+    const allowedTools = SEMBLE_MCP_TOOLS.map(tool => buildMcpToolName(SEMBLE_MCP_SERVER_NAME, tool));
+    const uvPath = ensureUvAvailable();
+    ensureSembleBootstrap(uvPath, process.cwd());
+    return {
+        mcpConfig: {
+            [SEMBLE_MCP_SERVER_NAME]: {
+                type: 'stdio',
+                command: uvPath,
+                args: ['tool', 'run', '--from', SEMBLE_PACKAGE_SPEC, 'semble'],
+                scope: 'dynamic',
+            },
+        },
+        allowedTools,
+    };
+}