@iaforged/context-code 1.2.12 → 1.3.6

package/dist/src/hooks/useTextInput.js

@@ -1,3 +1,4 @@
+import { useRef, useState } from 'react';
 import { isInputModeCharacter } from '../components/PromptInput/inputModes.js';
 import { useNotifications } from '../context/notifications.js';
 import stripAnsi from 'strip-ansi';
@@ -8,7 +9,7 @@ import { env } from '../utils/env.js';
 import { isFullscreenEnvEnabled } from '../utils/fullscreen.js';
 import { isModifierPressed, prewarmModifiers } from '../utils/modifiers.js';
 import { useDoublePress } from './useDoublePress.js';
-const NOOP_HANDLER = () => { };
+const NOOP_HANDLER = (_c, _i) => { };
 function insertPlainText(cursor, input) {
     const text = stripAnsi(input)
         // eslint-disable-next-line custom-rules/no-lookbehind-regex -- .replace(re, str) on 1-2 char keystrokes: no-match returns same string (Object.is), regex never runs
@@ -21,8 +22,8 @@ function insertPlainText(cursor, input) {
 }
 function mapInput(input_map) {
     const map = new Map(input_map);
-    return function (input) {
-        return (map.get(input) ?? NOOP_HANDLER)(input);
+    return function (cursor, input) {
+        return (map.get(input) ?? NOOP_HANDLER)(cursor, input);
     };
 }
 export function useTextInput({ value: originalValue, onChange, onSubmit, onExit, onExitMessage, onHistoryUp, onHistoryDown, onHistoryReset, onClearInput, mask = '', multiline = false, cursorChar, invert, columns, onImagePaste: _onImagePaste, disableCursorMovementForUpDownKeys = false, disableEscapeDoublePress = false, maxVisibleLines, externalOffset, onOffsetChange, inputFilter, inlineGhostText, dim, }) {
@@ -32,12 +33,25 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
     }
     const offset = externalOffset;
     const setOffset = onOffsetChange;
+    // Maintain synchronous internal state to prevent character loss during rapid typing.
+    // React re-renders can be slower than keystrokes in a complex TUI.
+    const lastProcessedValueRef = useRef(originalValue);
+    const lastProcessedOffsetRef = useRef(externalOffset);
+    // Sync internal state with props when they change externally (history, undo, etc.)
+    const [lastPropValue, setLastPropValue] = useState(originalValue);
+    const [lastPropOffset, setLastPropOffset] = useState(externalOffset);
+    if (originalValue !== lastPropValue || externalOffset !== lastPropOffset) {
+        lastProcessedValueRef.current = originalValue;
+        lastProcessedOffsetRef.current = externalOffset;
+        setLastPropValue(originalValue);
+        setLastPropOffset(externalOffset);
+    }
     const cursor = Cursor.fromText(originalValue, columns, offset);
     const { addNotification, removeNotification } = useNotifications();
-    const handleCtrlC = useDoublePress(show => {
+    const handleCtrlC = useDoublePress((show, _cursor) => {
         onExitMessage?.(show, 'Ctrl-C');
-    }, () => onExit?.(), () => {
-        if (originalValue) {
+    }, (_cursor) => onExit?.(), (cursor) => {
+        if (cursor.text) {
             onChange('');
             setOffset(0);
             onHistoryReset?.();
@@ -47,8 +61,8 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
     // It's a text-level double-press escape for clearing input, not an action-level keybinding.
     // Double-press Esc clears the input and saves to history - this is text editing behavior,
     // not dialog dismissal, and needs the double-press safety mechanism.
-    const handleEscape = useDoublePress((show) => {
-        if (!originalValue || !show) {
+    const handleEscape = useDoublePress((show, cursor) => {
+        if (!cursor.text || !show) {
             return;
         }
         addNotification({
@@ -57,57 +71,57 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
             priority: 'immediate',
             timeoutMs: 1000,
         });
-    }, () => {
+    }, (_show, cursor) => {
         // Remove the "Esc again to clear" notification immediately
         removeNotification('escape-again-to-clear');
         onClearInput?.();
-        if (originalValue) {
+        if (cursor.text) {
             // Track double-escape usage for feature discovery
             // Save to history before clearing
-            if (originalValue.trim() !== '') {
-                addToHistory(originalValue);
+            if (cursor.text.trim() !== '') {
+                addToHistory(cursor.text);
             }
             onChange('');
             setOffset(0);
             onHistoryReset?.();
         }
     });
-    const handleEmptyCtrlD = useDoublePress(show => {
-        if (originalValue !== '') {
+    const handleEmptyCtrlD = useDoublePress((show, cursor) => {
+        if (cursor.text !== '') {
             return;
         }
         onExitMessage?.(show, 'Ctrl-D');
-    }, () => {
-        if (originalValue !== '') {
+    }, (_show, cursor) => {
+        if (cursor.text !== '') {
             return;
         }
         onExit?.();
     });
-    function handleCtrlD() {
+    function handleCtrlD(cursor) {
         if (cursor.text === '') {
             // When input is empty, handle double-press
-            handleEmptyCtrlD();
+            handleEmptyCtrlD(cursor);
             return cursor;
         }
         // When input is not empty, delete forward like iPython
         return cursor.del();
     }
-    function killToLineEnd() {
+    function killToLineEnd(cursor) {
         const { cursor: newCursor, killed } = cursor.deleteToLineEnd();
         pushToKillRing(killed, 'append');
         return newCursor;
     }
-    function killToLineStart() {
+    function killToLineStart(cursor) {
         const { cursor: newCursor, killed } = cursor.deleteToLineStart();
         pushToKillRing(killed, 'prepend');
         return newCursor;
     }
-    function killWordBefore() {
+    function killWordBefore(cursor) {
         const { cursor: newCursor, killed } = cursor.deleteWordBefore();
         pushToKillRing(killed, 'prepend');
         return newCursor;
     }
-    function yank() {
+    function yank(cursor) {
         const text = getLastKill();
         if (text.length > 0) {
             const startOffset = cursor.offset;
@@ -117,7 +131,7 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         }
         return cursor;
     }
-    function handleYankPop() {
+    function handleYankPop(cursor) {
         const popResult = yankPop();
         if (!popResult) {
             return cursor;
@@ -132,27 +146,27 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         return Cursor.fromText(newText, columns, newOffset);
     }
     const handleCtrl = mapInput([
-        ['a', () => cursor.startOfLine()],
-        ['b', () => cursor.left()],
-        ['c', handleCtrlC],
-        ['d', handleCtrlD],
-        ['e', () => cursor.endOfLine()],
-        ['f', () => cursor.right()],
-        ['h', () => cursor.deleteTokenBefore() ?? cursor.backspace()],
-        ['k', killToLineEnd],
-        ['n', () => downOrHistoryDown()],
-        ['p', () => upOrHistoryUp()],
-        ['u', killToLineStart],
-        ['w', killWordBefore],
-        ['y', yank],
+        ['a', cursor => cursor.startOfLine()],
+        ['b', cursor => cursor.left()],
+        ['c', (cursor, _input) => handleCtrlC(cursor)],
+        ['d', (cursor, _input) => handleCtrlD(cursor)],
+        ['e', cursor => cursor.endOfLine()],
+        ['f', cursor => cursor.right()],
+        ['h', cursor => cursor.deleteTokenBefore() ?? cursor.backspace()],
+        ['k', (cursor, _input) => killToLineEnd(cursor)],
+        ['n', (cursor, _input) => downOrHistoryDown(cursor)],
+        ['p', (cursor, _input) => upOrHistoryUp(cursor)],
+        ['u', (cursor, _input) => killToLineStart(cursor)],
+        ['w', (cursor, _input) => killWordBefore(cursor)],
+        ['y', (cursor, _input) => yank(cursor)],
     ]);
     const handleMeta = mapInput([
-        ['b', () => cursor.prevWord()],
-        ['f', () => cursor.nextWord()],
-        ['d', () => cursor.deleteWordAfter()],
-        ['y', handleYankPop],
+        ['b', cursor => cursor.prevWord()],
+        ['f', cursor => cursor.nextWord()],
+        ['d', cursor => cursor.deleteWordAfter()],
+        ['y', (cursor, _input) => handleYankPop(cursor)],
     ]);
-    function handleEnter(key) {
+    function handleEnter(cursor, key) {
         if (multiline &&
             cursor.offset > 0 &&
             cursor.text[cursor.offset - 1] === '\\') {
@@ -169,9 +183,9 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         if (env.terminal === 'Apple_Terminal' && isModifierPressed('shift')) {
             return cursor.insert('\n');
         }
-        onSubmit?.(originalValue);
+        onSubmit?.(cursor.text);
     }
-    function upOrHistoryUp() {
+    function upOrHistoryUp(cursor) {
         if (disableCursorMovementForUpDownKeys) {
             onHistoryUp?.();
             return cursor;
@@ -193,7 +207,7 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         onHistoryUp?.();
         return cursor;
     }
-    function downOrHistoryDown() {
+    function downOrHistoryDown(cursor) {
         if (disableCursorMovementForUpDownKeys) {
             onHistoryDown?.();
             return cursor;
@@ -218,7 +232,7 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
     function mapKey(key) {
         switch (true) {
             case key.escape:
-                return () => {
+                return (cursor) => {
                     // Skip when a keybinding context (e.g. Autocomplete) owns escape.
                     // useKeybindings can't shield us via stopImmediatePropagation —
                     // BaseTextInput's useInput registers first (child effects fire
@@ -226,38 +240,40 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
                     // time the keybinding's handler stops propagation.
                     if (disableEscapeDoublePress)
                         return cursor;
-                    handleEscape();
+                    handleEscape(cursor);
                     // Return the current cursor unchanged - handleEscape manages state internally
                     return cursor;
                 };
             case key.leftArrow && (key.ctrl || key.meta || key.fn):
-                return () => cursor.prevWord();
+                return (cursor) => cursor.prevWord();
             case key.rightArrow && (key.ctrl || key.meta || key.fn):
-                return () => cursor.nextWord();
+                return (cursor) => cursor.nextWord();
             case key.backspace:
                 return key.meta || key.ctrl
-                    ? killWordBefore
-                    : () => cursor.deleteTokenBefore() ?? cursor.backspace();
+                    ? (cursor) => killWordBefore(cursor)
+                    : (cursor) => cursor.deleteTokenBefore() ?? cursor.backspace();
             case key.delete:
-                return key.meta ? killToLineEnd : () => cursor.del();
+                return key.meta
+                    ? (cursor) => killToLineEnd(cursor)
+                    : (cursor) => cursor.del();
             case key.ctrl:
                 return handleCtrl;
             case key.home:
-                return () => cursor.startOfLine();
+                return (cursor) => cursor.startOfLine();
             case key.end:
-                return () => cursor.endOfLine();
+                return (cursor) => cursor.endOfLine();
             case key.pageDown:
                 // In fullscreen mode, PgUp/PgDn scroll the message viewport instead
                 // of moving the cursor — no-op here, ScrollKeybindingHandler handles it.
                 if (isFullscreenEnvEnabled()) {
                     return NOOP_HANDLER;
                 }
-                return () => cursor.endOfLine();
+                return (cursor) => cursor.endOfLine();
             case key.pageUp:
                 if (isFullscreenEnvEnabled()) {
                     return NOOP_HANDLER;
                 }
-                return () => cursor.startOfLine();
+                return (cursor) => cursor.startOfLine();
             case key.wheelUp:
             case key.wheelDown:
                 // Mouse wheel events only exist when fullscreen mouse tracking is on.
@@ -266,21 +282,21 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
                 return NOOP_HANDLER;
             case key.return:
                 // Must come before key.meta so Option+Return inserts newline
-                return () => handleEnter(key);
+                return (cursor) => handleEnter(cursor, key);
             case key.meta:
                 return handleMeta;
             case key.tab:
-                return () => cursor;
+                return (cursor) => cursor;
             case key.upArrow && !key.shift:
-                return upOrHistoryUp;
+                return (cursor) => upOrHistoryUp(cursor);
             case key.downArrow && !key.shift:
-                return downOrHistoryDown;
+                return (cursor) => downOrHistoryDown(cursor);
             case key.leftArrow:
-                return () => cursor.left();
+                return (cursor) => cursor.left();
             case key.rightArrow:
-                return () => cursor.right();
+                return (cursor) => cursor.right();
             default: {
-                return function (input) {
+                return function (cursor, input) {
                     switch (true) {
                         // Home key
                         case input === '\x1b[H' || input === '\x1b[1~':
@@ -327,30 +343,34 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         if (filteredInput === '' && input !== '') {
             return;
         }
+        // Get the current synchronous state
+        const currentCursor = Cursor.fromText(lastProcessedValueRef.current, columns, lastProcessedOffsetRef.current);
         // In SSH/tmux or slow terminals, raw DEL characters can be coalesced with
         // printable input. Process the chunk sequentially so DEL only removes the
         // preceding character and the rest of the packet still gets inserted.
         if (!key.backspace && !key.delete && filteredInput.includes('\x7f')) {
-            let currentCursor = cursor;
+            let activeCursor = currentCursor;
             let segmentStart = 0;
             for (let i = 0; i < filteredInput.length; i++) {
                 if (filteredInput[i] !== '\x7f') {
                     continue;
                 }
                 if (segmentStart < i) {
-                    currentCursor = insertPlainText(currentCursor, filteredInput.slice(segmentStart, i));
+                    activeCursor = insertPlainText(activeCursor, filteredInput.slice(segmentStart, i));
                 }
-                currentCursor = currentCursor.backspace();
+                activeCursor = activeCursor.backspace();
                 segmentStart = i + 1;
             }
             if (segmentStart < filteredInput.length) {
-                currentCursor = insertPlainText(currentCursor, filteredInput.slice(segmentStart));
+                activeCursor = insertPlainText(activeCursor, filteredInput.slice(segmentStart));
             }
-            if (!cursor.equals(currentCursor)) {
-                if (cursor.text !== currentCursor.text) {
-                    onChange(currentCursor.text);
+            if (!currentCursor.equals(activeCursor)) {
+                if (currentCursor.text !== activeCursor.text) {
+                    lastProcessedValueRef.current = activeCursor.text;
+                    onChange(activeCursor.text);
                 }
-                setOffset(currentCursor.offset);
+                lastProcessedOffsetRef.current = activeCursor.offset;
+                setOffset(activeCursor.offset);
             }
             resetKillAccumulation();
             resetYankState();
@@ -364,12 +384,14 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         if (!isYankKey(key, filteredInput)) {
             resetYankState();
         }
-        const nextCursor = mapKey(key)(filteredInput);
+        const nextCursor = mapKey(key)(currentCursor, filteredInput);
         if (nextCursor) {
-            if (!cursor.equals(nextCursor)) {
-                if (cursor.text !== nextCursor.text) {
+            if (!currentCursor.equals(nextCursor)) {
+                if (currentCursor.text !== nextCursor.text) {
+                    lastProcessedValueRef.current = nextCursor.text;
                     onChange(nextCursor.text);
                 }
+                lastProcessedOffsetRef.current = nextCursor.offset;
                 setOffset(nextCursor.offset);
             }
             // SSH-coalesced Enter: on slow links, "o" + Enter can arrive as one

package/dist/src/ink/reconciler.js

@@ -21,13 +21,13 @@ if (process.env.NODE_ENV === 'development') {
     catch (error) {
         if (error.code === 'ERR_MODULE_NOT_FOUND') {
             // biome-ignore lint/suspicious/noConsole: intentional warning
-            console.warn(`
-The environment variable DEV is set to true, so Ink tried to import \`react-devtools-core\`,
-but this failed as it was not installed. Debugging with React Devtools requires it.
-
-To install use this command:
-
-$ npm install --save-dev react-devtools-core
+            console.warn(`
+The environment variable DEV is set to true, so Ink tried to import \`react-devtools-core\`,
+but this failed as it was not installed. Debugging with React Devtools requires it.
+
+To install use this command:
+
+$ npm install --save-dev react-devtools-core
 				`.trim() + '\n');
         }
         else {

package/dist/src/main.js

@@ -3972,11 +3972,11 @@ async function run() {
             await errorHandler(number);
         });
         // context export
-        program.command('export').description('[SÓLO-ANT] Exportar una conversación a un archivo de texto.').usage('<origen> <archivoSalida>').argument('<origen>', 'ID de sesión, índice de registro (0, 1, 2...), o ruta a un archivo de registro .json/.jsonl').argument('<archivoSalida>', 'Ruta del archivo de salida para el texto exportado').addHelpText('after', `
-Ejemplos:
-  $ context export 0 conversacion.txt                Exportar conversación en el índice de registro 0
-  $ context export <uuid> conversacion.txt           Exportar conversación por ID de sesión
-  $ context export entrada.json salida.txt           Renderizar archivo de registro JSON a texto
+        program.command('export').description('[SÓLO-ANT] Exportar una conversación a un archivo de texto.').usage('<origen> <archivoSalida>').argument('<origen>', 'ID de sesión, índice de registro (0, 1, 2...), o ruta a un archivo de registro .json/.jsonl').argument('<archivoSalida>', 'Ruta del archivo de salida para el texto exportado').addHelpText('after', `
+Ejemplos:
+  $ context export 0 conversacion.txt                Exportar conversación en el índice de registro 0
+  $ context export <uuid> conversacion.txt           Exportar conversación por ID de sesión
+  $ context export entrada.json salida.txt           Renderizar archivo de registro JSON a texto
   $ context export <uuid>.jsonl salida.txt           Renderizar archivo de sesión JSONL a texto`).action(async (source, outputFile) => {
             const { exportHandler } = await import('./cli/handlers/ant.js');
             await exportHandler(source, outputFile);

package/dist/src/memdir/findRelevantMemories.js

@@ -7,12 +7,12 @@ import { getDefaultSonnetModel } from '../utils/model/model.js';
 import { sideQuery } from '../utils/sideQuery.js';
 import { jsonParse } from '../utils/slowOperations.js';
 import { formatMemoryManifest, scanMemoryFiles, } from './memoryScan.js';
-const SELECT_MEMORIES_SYSTEM_PROMPT = `You are selecting memories that will be useful to Context Code as it processes a user's query. You will be given the user's query and a list of available memory files with their filenames and descriptions.
-
-Return a list of filenames for the memories that will clearly be useful to Context Code as it processes the user's query (up to 5). Only include memories that you are certain will be helpful based on their name and description.
-- If you are unsure if a memory will be useful in processing the user's query, then do not include it in your list. Be selective and discerning.
-- If there are no memories in the list that would clearly be useful, feel free to return an empty list.
-- If a list of recently-used tools is provided, do not select memories that are usage reference or API documentation for those tools (Context Code is already exercising them). DO still select memories containing warnings, gotchas, or known issues about those tools — active use is exactly when those matter.
+const SELECT_MEMORIES_SYSTEM_PROMPT = `You are selecting memories that will be useful to Context Code as it processes a user's query. You will be given the user's query and a list of available memory files with their filenames and descriptions.
+
+Return a list of filenames for the memories that will clearly be useful to Context Code as it processes the user's query (up to 5). Only include memories that you are certain will be helpful based on their name and description.
+- If you are unsure if a memory will be useful in processing the user's query, then do not include it in your list. Be selective and discerning.
+- If there are no memories in the list that would clearly be useful, feel free to return an empty list.
+- If a list of recently-used tools is provided, do not select memories that are usage reference or API documentation for those tools (Context Code is already exercising them). DO still select memories containing warnings, gotchas, or known issues about those tools — active use is exactly when those matter.
 `;
 /**
  * Find memory files relevant to a query by scanning memory file headers

package/dist/src/query.js

@@ -987,6 +987,84 @@ async function* queryLoop(params, consumedCommandUuids) {
                     state = next;
                     continue;
                 }
+                // /objetivo — evaluador session-scoped. Si hay objetivo activo, pregunta
+                // al mismo modelo del agente si la condición se ha cumplido. Si no, se
+                // inyecta un mensaje meta con la razón y vuelve al loop. Sin límite de
+                // turnos: el usuario corta con `/objetivo clear` o Ctrl+C.
+                const appStateForObjetivo = toolUseContext.getAppState();
+                const objetivoActivo = appStateForObjetivo.objetivo;
+                if (objetivoActivo &&
+                    querySource.startsWith('repl_main_thread') &&
+                    !toolUseContext.agentId) {
+                    // Incrementar contador de turnos para la UI antes de evaluar.
+                    toolUseContext.setAppState(prev => ({
+                        ...prev,
+                        objetivo: prev.objetivo
+                            ? { ...prev.objetivo, turnos: prev.objetivo.turnos + 1 }
+                            : prev.objetivo,
+                    }));
+                    const [{ evaluarObjetivo }, { formatearDuracion: fmtDuracion }] = await Promise.all([
+                        import('./services/objetivo/evaluator.js'),
+                        import('./services/objetivo/types.js'),
+                    ]);
+                    const evaluacion = await evaluarObjetivo(objetivoActivo.meta, messagesForQuery, assistantMessages, toolUseContext.abortController.signal);
+                    const turnoActual = objetivoActivo.turnos + 1;
+                    const tiempoTranscurrido = fmtDuracion(Date.now() - objetivoActivo.iniciadoEn);
+                    if (evaluacion?.cumplido) {
+                        // Restaurar el modo de permisos previo si /objetivo lo había cambiado
+                        // a bypassPermissions al fijar la meta.
+                        const { applyPermissionUpdate: applyPermUpd } = await import('./utils/permissions/PermissionUpdate.js');
+                        toolUseContext.setAppState(prev => {
+                            const next = { ...prev, objetivo: undefined };
+                            const modoPrevio = prev.objetivo?.modoPermisoPrevio;
+                            if (modoPrevio !== undefined &&
+                                modoPrevio !== prev.toolPermissionContext.mode) {
+                                next.toolPermissionContext = applyPermUpd(prev.toolPermissionContext, { type: 'setMode', mode: modoPrevio, destination: 'session' });
+                            }
+                            return next;
+                        });
+                        yield createSystemMessage(`◎ Objetivo cumplido en ${tiempoTranscurrido} (${turnoActual} ${turnoActual === 1 ? 'turno' : 'turnos'}) — ${evaluacion.razon}`);
+                    }
+                    else if (evaluacion && !evaluacion.cumplido) {
+                        toolUseContext.setAppState(prev => ({
+                            ...prev,
+                            objetivo: prev.objetivo
+                                ? { ...prev.objetivo, ultimaRazon: evaluacion.razon }
+                                : prev.objetivo,
+                        }));
+                        // Mensaje visible para el usuario: indica que /objetivo está corriendo
+                        // autónomamente, qué turno va, cuánto lleva y qué falta según el
+                        // evaluador. Sin esto el chat se ve idéntico a una conversación
+                        // normal y el usuario no sabe si el agente sigue trabajando solo.
+                        yield createSystemMessage(`◎ Continuando hacia el objetivo (turno ${turnoActual} · ${tiempoTranscurrido}) — Aún falta: ${evaluacion.razon}`);
+                        const continuacion = createUserMessage({
+                            content: `OBJETIVO ACTIVO (turno ${turnoActual}): "${objetivoActivo.meta}"\n\n` +
+                                `El evaluador automático revisó el turno anterior y dice que aún falta:\n` +
+                                `${evaluacion.razon}\n\n` +
+                                `Recordatorio de reglas:\n` +
+                                `- NO describas pasos en texto. EJECUTA herramientas (Read/Glob/Grep/Bash/Edit/Write) AHORA mismo en este turno.\n` +
+                                `- Cada turno debe contener al menos UNA llamada a herramienta hasta cumplir el objetivo.\n` +
+                                `- Si algo falla, sigue ejecutando herramientas para diagnosticar y arreglar.\n` +
+                                `- Cuando creas que está cumplido, dilo claramente con evidencia concreta (rutas, comandos, salidas).\n\n` +
+                                `Continúa ahora ejecutando la siguiente herramienta necesaria.`,
+                            isMeta: true,
+                        });
+                        state = {
+                            messages: [...messagesForQuery, ...assistantMessages, continuacion],
+                            toolUseContext,
+                            autoCompactTracking: tracking,
+                            maxOutputTokensRecoveryCount: 0,
+                            hasAttemptedReactiveCompact: false,
+                            maxOutputTokensOverride: undefined,
+                            pendingToolUseSummary: undefined,
+                            stopHookActive: undefined,
+                            turnCount,
+                            transition: { reason: 'objetivo_continuation' },
+                        };
+                        continue;
+                    }
+                    // evaluacion === null (red/parse falló): cae al completed normal.
+                }
                 if (feature('TOKEN_BUDGET')) {
                     const decision = checkTokenBudget(budgetTracker, toolUseContext.agentId, getCurrentTurnTokenBudget(), getTurnOutputTokens());
                     if (decision.action === 'continue') {

package/dist/src/screens/REPL.js

@@ -394,6 +394,10 @@ function TranscriptSearchBar({ jumpRef, count, current, onClose, onCancel, setHi
         // skip these cells (same exclusion as gutters). You can't text-
         // select the bar either; it's transient chrome, fine.
         noSelect: true, children: [_jsx(Text, { children: "/" }), _jsx(Text, { children: query.slice(0, off) }), _jsx(Text, { inverse: true, children: cursorChar }), off < query.length && _jsx(Text, { children: query.slice(off + 1) }), _jsx(Box, { flexGrow: 1 }), indexStatus === 'building' ? _jsx(Text, { dimColor: true, children: "indexando\u2026 " }) : indexStatus ? _jsxs(Text, { dimColor: true, children: ["indexado en ", indexStatus.ms, "ms "] }) : count === 0 && query ? _jsx(Text, { color: "error", children: "sin coincidencias " }) : count > 0 ?
+                // Engine-counted (indexOf on extractSearchText). May drift from
+                // render-count for ghost/phantom messages — badge is a rough
+                // location hint. scanElement gives exact per-message positions
+                // but counting ALL would cost ~1-3ms × matched-messages.
                 _jsxs(Text, { dimColor: true, children: [current, "/", count, '  '] }) : null] });
 }
 const TITLE_ANIMATION_FRAMES = ['⠂', '⠐'];
@@ -4034,6 +4038,10 @@ export function REPL({ commands: initialCommands, debug, initialTools, initialMe
         const transcriptMessagesElement = _jsx(Messages, { messages: transcriptMessages, tools: tools, commands: commands, verbose: true, toolJSX: null, toolUseConfirmQueue: [], inProgressToolUseIDs: inProgressToolUseIDs, isMessageSelectorVisible: false, conversationId: conversationId, screen: screen, agentDefinitions: agentDefinitions, streamingToolUses: transcriptStreamingToolUses, showAllInTranscript: showAllInTranscript, onOpenRateLimitOptions: handleOpenRateLimitOptions, isLoading: isLoading, hidePastThinking: true, streamingThinking: streamingThinking, scrollRef: transcriptScrollRef, jumpRef: jumpRef, onSearchMatchesChange: onSearchMatchesChange, scanElement: scanElement, setPositions: setPositions, disableRenderCap: dumpMode });
         const transcriptToolJSX = toolJSX && _jsx(Box, { flexDirection: "column", width: "100%", children: toolJSX.jsx });
         const transcriptReturn = _jsxs(KeybindingSetup, { children: [_jsx(AnimatedTerminalTitle, { isAnimating: titleIsAnimating, title: terminalTitle, disabled: titleDisabled, noPrefix: showStatusInTerminalTab }), _jsx(GlobalKeybindingHandlers, { ...globalKeybindingProps }), _jsx(VoiceKeybindingHandler, { voiceHandleKeyEvent: voice.handleKeyEvent, stripTrailing: voice.stripTrailing, resetAnchor: voice.resetAnchor, isActive: !toolJSX?.isLocalJSXCommand }), _jsx(CommandKeybindingHandlers, { onSubmit: onSubmit, isActive: !toolJSX?.isLocalJSXCommand }), transcriptScrollRef ?
+                    // ScrollKeybindingHandler must mount before CancelRequestHandler so
+                    // ctrl+c-with-selection copies instead of cancelling the active task.
+                    // Its raw useInput handler only stops propagation when a selection
+                    // exists — without one, ctrl+c falls through to CancelRequestHandler.
                     _jsx(ScrollKeybindingHandler, { scrollRef: scrollRef, 
                         // Yield wheel/ctrl+u/d to UltraplanChoiceDialog's own scroll
                         // handler while the modal is showing.
@@ -4408,6 +4416,7 @@ export function REPL({ commands: initialCommands, debug, initialTools, initialMe
                                             } }) : null, mrRender(), !toolJSX?.shouldHidePromptInput && !focusedInputDialog && !isExiting && !disabled && !cursor && _jsxs(_Fragment, { children: [autoRunIssueReason && _jsx(AutoRunIssueNotification, { onRun: handleAutoRunIssue, onCancel: handleCancelAutoRunIssue, reason: getAutoRunIssueReasonText(autoRunIssueReason) }), postCompactSurvey.state !== 'closed' ? _jsx(FeedbackSurvey, { state: postCompactSurvey.state, lastResponse: postCompactSurvey.lastResponse, handleSelect: postCompactSurvey.handleSelect, inputValue: inputValue, setInputValue: setInputValue, onRequestFeedback: handleSurveyRequestFeedback }) : memorySurvey.state !== 'closed' ? _jsx(FeedbackSurvey, { state: memorySurvey.state, lastResponse: memorySurvey.lastResponse, handleSelect: memorySurvey.handleSelect, handleTranscriptSelect: memorySurvey.handleTranscriptSelect, inputValue: inputValue, setInputValue: setInputValue, onRequestFeedback: handleSurveyRequestFeedback, message: "How well did Claude use its memory? (optional)" }) : _jsx(FeedbackSurvey, { state: feedbackSurvey.state, lastResponse: feedbackSurvey.lastResponse, handleSelect: feedbackSurvey.handleSelect, handleTranscriptSelect: feedbackSurvey.handleTranscriptSelect, inputValue: inputValue, setInputValue: setInputValue, onRequestFeedback: didAutoRunIssueRef.current ? undefined : handleSurveyRequestFeedback }), frustrationDetection.state !== 'closed' && _jsx(FeedbackSurvey, { state: frustrationDetection.state, lastResponse: null, handleSelect: () => { }, handleTranscriptSelect: frustrationDetection.handleTranscriptSelect, inputValue: inputValue, setInputValue: setInputValue }), "external" === 'ant' && skillImprovementSurvey.suggestion && _jsx(SkillImprovementSurvey, { isOpen: skillImprovementSurvey.isOpen, skillName: skillImprovementSurvey.suggestion.skillName, updates: skillImprovementSurvey.suggestion.updates, handleSelect: skillImprovementSurvey.handleSelect, inputValue: inputValue, setInputValue: setInputValue }), showIssueFlagBanner && _jsx(IssueFlagBanner, {}), _jsx(PromptInput, { debug: debug, ideSelection: ideSelection, hasSuppressedDialogs: !!hasSuppressedDialogs, isLocalJSXCommandActive: isShowingLocalJSXCommand, getToolUseContext: getToolUseContext, toolPermissionContext: toolPermissionContext, setToolPermissionContext: setToolPermissionContext, apiKeyStatus: apiKeyStatus, commands: commands, agents: agentDefinitions.activeAgents, isLoading: isLoading, onExit: handleExit, verbose: verbose, messages: messages, onAutoUpdaterResult: setAutoUpdaterResult, autoUpdaterResult: autoUpdaterResult, input: inputValue, onInputChange: setInputValue, mode: inputMode, onModeChange: setInputMode, stashedPrompt: stashedPrompt, setStashedPrompt: setStashedPrompt, submitCount: submitCount, onShowMessageSelector: handleShowMessageSelector, onMessageActionsEnter: 
                                                     // Works during isLoading — edit cancels first; uuid selection survives appends.
                                                     feature('MESSAGE_ACTIONS') && isFullscreenEnvEnabled() && !disableMessageActions ? enterMessageActions : undefined, mcpClients: mcpClients, pastedContents: pastedContents, setPastedContents: setPastedContents, vimMode: vimMode, setVimMode: setVimMode, showBashesDialog: showBashesDialog, setShowBashesDialog: setShowBashesDialog, onSubmit: onSubmit, onAgentSubmit: onAgentSubmit, isSearchingHistory: isSearchingHistory, setIsSearchingHistory: setIsSearchingHistory, helpOpen: isHelpOpen, setHelpOpen: setIsHelpOpen, insertTextRef: insertTextRef, voiceInterimRange: voice.interimRange }), _jsx(SessionBackgroundHint, { onBackgroundSession: handleBackgroundSession, isLoading: isLoading })] }), cursor &&
+                                            // inputValue is REPL state; typed text survives the round-trip.
                                             _jsx(MessageActionsBar, { cursor: cursor }), focusedInputDialog === 'message-selector' && _jsx(MessageSelector, { messages: messages, preselectedMessage: messageSelectorPreselect, onPreRestore: onCancel, onRestoreCode: async (message) => {
                                                 await fileHistoryRewind((updater) => {
                                                     setAppState(prev => ({

package/dist/src/services/AgentSummary/agentSummary.js

@@ -21,16 +21,16 @@ function buildSummaryPrompt(previousSummary) {
     const prevLine = previousSummary
         ? `\nPrevious: "${previousSummary}" — say something NEW.\n`
         : '';
-    return `Describe your most recent action in 3-5 words using present tense (-ing). Name the file or function, not the branch. Do not use tools.
-${prevLine}
-Good: "Reading runAgent.ts"
-Good: "Fixing null check in validate.ts"
-Good: "Running auth module tests"
-Good: "Adding retry logic to fetchUser"
-
-Bad (past tense): "Analyzed the branch diff"
-Bad (too vague): "Investigating the issue"
-Bad (too long): "Reviewing full branch diff and AgentTool.tsx integration"
+    return `Describe your most recent action in 3-5 words using present tense (-ing). Name the file or function, not the branch. Do not use tools.
+${prevLine}
+Good: "Reading runAgent.ts"
+Good: "Fixing null check in validate.ts"
+Good: "Running auth module tests"
+Good: "Adding retry logic to fetchUser"
+
+Bad (past tense): "Analyzed the branch diff"
+Bad (too vague): "Investigating the issue"
+Bad (too long): "Reviewing full branch diff and AgentTool.tsx integration"
 Bad (branch name): "Analyzed adam/background-summary branch diff"`;
 }
 export function startAgentSummarization(taskId, agentId, cacheSafeParams, setAppState) {