zyn-ai 1.3.0 → 1.3.2

package/LICENSE

@@ -1,15 +1,21 @@
-Zyn Attribution License 1.0
+MIT License
 
-Copyright (c) 2026 Maycol and contributors.
+Copyright (c) 2026 Maycol
 
-Permission is granted to use, copy, modify, and redistribute this software,
-including commercial use, provided that all of the following conditions are met:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-1. You keep this license notice intact.
-2. You keep visible credit to the original project in source form and in any
-   distributed derivative work.
-3. You include the project link below, or a clearly documented replacement if
-   the canonical URL changes.
-4. Modified versions must clearly state that they were changed from the original.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-This software is provided "as is", without warranty of any kind.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -4,11 +4,13 @@
   <img src="http://cdn.soymaycol.icu/files/logo_zyn.png" alt="Zyn logo" width="180" />
 </p>
 
-<p>
+<p align="center">
   <img src="https://img.shields.io/npm/v/zyn-ai?label=npm&color=%23CB3837" alt="NPM Version"/>
-  
+
   <img src="https://img.shields.io/github/v/release/SoyMaycol/Zyn?include_prereleases&sort=semver" alt="Latest Release"/>
-  
+
+  <img src="https://img.shields.io/npm/dt/zyn-ai" alt="Downloads"/>
+
   <img src="https://img.shields.io/github/forks/SoyMaycol/Zyn" alt="Forks"/>
 </p>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyn-ai",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Production-ready AI agent for CLI and web with real tool execution and automation",
   "author": "Maycol",
   "keywords": [

package/src/cli/commands.js

@@ -26,6 +26,7 @@ const SLASH_COMMANDS = [
   { name: 'models', desc: 'list models' },
   { name: 'providers', desc: 'list providers' },
   { name: 'git', desc: 'configure git credentials' },
+  { name: 'persona', desc: 'set response tone/personality' },
   { name: 'lang', desc: 'change language' },
   { name: 'language', desc: 'change language' },
   { name: 'auto', desc: 'auto-approval' },
@@ -196,9 +197,62 @@ async function handleLocalCommand(input, state, deps) {
     return true;
   }
 
+  if (commandName === 'git') {
+    const [sub, ...rest] = args.split(' ').filter(Boolean);
+    if (!sub || sub === 'help') {
+      console.log('Uso: /git list | /git set <provider> <token> [username] | /git remove <provider>');
+      return true;
+    }
+    if (sub === 'list') {
+      const secrets = listGitSecrets();
+      if (!secrets.length) console.log('No hay credenciales git guardadas.');
+      else secrets.forEach(s => console.log(`${s.key}  user:${s.username || '-'}  api:${s.apiBaseUrl || '-'}`));
+      return true;
+    }
+    if (sub === 'set') {
+      const [provider, token, username] = rest;
+      if (!provider || !token) throw new Error('Uso: /git set <provider> <token> [username]');
+      upsertGitSecret(provider, { provider, token, username });
+      console.log(`Credencial guardada para ${provider}`);
+      return true;
+    }
+    if (sub === 'remove') {
+      const [provider] = rest;
+      if (!provider) throw new Error('Uso: /git remove <provider>');
+      const removed = removeGitSecret(provider);
+      console.log(removed ? `Credencial eliminada: ${provider}` : `No existe credencial para ${provider}`);
+      return true;
+    }
+    throw new Error('Subcomando git no reconocido. Usa /git help');
+  }
+
+  if (commandName === 'persona') {
+    const [sub, ...rest] = args.split(' ');
+    if (!sub || sub === 'show') {
+      console.log(state.personaPrompt ? `Persona activa:\n${state.personaPrompt}` : 'Persona por defecto activa.');
+      return true;
+    }
+    if (sub === 'reset' || sub === 'default') {
+      state.personaPrompt = '';
+      await saveState(state);
+      console.log('Persona restaurada al estado por defecto.');
+      return true;
+    }
+    if (sub === 'set') {
+      const text = rest.join(' ').trim();
+      if (!text) throw new Error('Uso: /persona set <descripcion>');
+      state.personaPrompt = text;
+      await saveState(state);
+      console.log('Persona actualizada (solo estilo).');
+      return true;
+    }
+    throw new Error('Uso: /persona show | /persona set <texto> | /persona reset');
+  }
+
   if (commandName === 'new') {
     const nextState = await createNewSessionState(state.rl);
     applyLoadedState(state, nextState);
+    if (typeof state.clearQueuedMessages === 'function') state.clearQueuedMessages();
     global.__zynActiveModel = state.activeModel || DEFAULT_MODEL_KEY;
     printBanner(state);
     console.log(`${t(state.language, 'newSessionCreated')}: ${state.sessionId}`);
@@ -217,6 +271,7 @@ async function handleLocalCommand(input, state, deps) {
     }
 
     applyLoadedState(state, loaded);
+    if (typeof state.clearQueuedMessages === 'function') state.clearQueuedMessages();
     global.__zynActiveModel = state.activeModel || DEFAULT_MODEL_KEY;
     await saveState(state);
     printBanner(state);

package/src/cli/runtime.js

@@ -120,6 +120,7 @@ async function runInteractiveChatClassic(options = {}) {
   let currentAbort = null;
 
   state.getQueuedMessages = () => messageQueue.splice(0);
+  state.clearQueuedMessages = () => { messageQueue.length = 0; };
   state.abortCurrentTurn = () => {
     if (currentAbort && !currentAbort.signal.aborted) {
       currentAbort.abort();

package/src/config.js

@@ -104,6 +104,7 @@ const KEEP_RECENT_MESSAGES = 12;
 const SESSION_ROOT = path.join(DATA_ROOT, 'chat');
 const SESSIONS_DIR = path.join(SESSION_ROOT, 'sessions');
 const CURRENT_SESSION_FILE = path.join(SESSION_ROOT, 'current-session.json');
+const PERSISTENT_CONFIG_FILE = path.join(SESSION_ROOT, 'persistent-config.json');
 const TRANSCRIPTS_DIR = path.join(SESSION_ROOT, 'transcripts');
 const EXPORTS_DIR = path.join(SESSION_ROOT, 'exports');
 const THINK_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
@@ -134,6 +135,7 @@ module.exports = {
   APP_ROOT,
   BUILTIN_MODELS,
   CURRENT_SESSION_FILE,
+  PERSISTENT_CONFIG_FILE,
   DATA_ROOT,
   DEFAULT_LANGUAGE,
   DEFAULT_MODEL_KEY,

package/src/core/agent.js

@@ -37,68 +37,88 @@ async function requestModel(messages, state, ui, options = {}) {
     signal,
   } = options;
 
-  const stopThinking = ui.startThinkingIndicator(state, label);
-  let answerStarted = false;
-  let thinkingStarted = false;
-  const controller = new AbortController();
-  const onExternalAbort = () => controller.abort();
-
-  if (signal) {
-    if (signal.aborted) controller.abort();
-    else signal.addEventListener('abort', onExternalAbort, { once: true });
-  }
-
-  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    if (signal?.aborted) {
+      throw new Error(state.language === 'es' ? 'Agente detenido por el usuario (ESC x2)' : 'Agent stopped by the user (ESC x2)');
+    }
+    const stopThinking = ui.startThinkingIndicator(state, attempt === 0 ? label : `${label} (${state.language === 'es' ? 'reintento' : 'retry'})`);
+    let answerStarted = false;
+    let thinkingStarted = false;
+    let timedOut = false;
+    let timeout = null;
+    const controller = new AbortController();
+    const onExternalAbort = () => controller.abort();
+
+    if (signal) {
+      if (signal.aborted) controller.abort();
+      else signal.addEventListener('abort', onExternalAbort, { once: true });
+    }
+    const refreshTimeout = () => {
+      if (timeout) clearTimeout(timeout);
+      timeout = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, REQUEST_TIMEOUT_MS);
+    };
+    refreshTimeout();
 
-  try {
-    const result = await chat({
-      messages,
-      modelKey: state?.activeModel || DEFAULT_MODEL_KEY,
-      signal: controller.signal,
-      onChunk: (delta, phase) => {
-        if (phase === 'thinking') {
-          if (!thinkingStarted) {
+    try {
+      const result = await chat({
+        messages,
+        modelKey: state?.activeModel || DEFAULT_MODEL_KEY,
+        signal: controller.signal,
+        onChunk: (delta, phase) => {
+          refreshTimeout();
+          if (phase === 'thinking') {
+            if (!thinkingStarted) {
+              stopThinking();
+              ui.beginThinkingStream(state);
+              thinkingStarted = true;
+            }
+            ui.writeThinkingDelta(state, delta);
+            return;
+          }
+          if (thinkingStarted) {
+            ui.endThinkingStream(state);
+            thinkingStarted = false;
+          }
+          if (streamOutput && !answerStarted) {
             stopThinking();
-            ui.beginThinkingStream(state);
-            thinkingStarted = true;
+            ui.beginAssistantStream(state);
+            answerStarted = true;
           }
-          ui.writeThinkingDelta(state, delta);
-          return;
-        }
-
-        if (thinkingStarted) {
-          ui.endThinkingStream(state);
-          thinkingStarted = false;
-        }
-
-        if (streamOutput && !answerStarted) {
-          stopThinking();
-          ui.beginAssistantStream(state);
-          answerStarted = true;
-        }
-
-        if (streamOutput) {
-          ui.writeAssistantDelta(state, delta);
+          if (streamOutput) ui.writeAssistantDelta(state, delta);
+        },
+      });
+      ui.pushAction(state, 'ok', 'Respuesta del modelo recibida');
+      return result.answer ?? '';
+    } catch (err) {
+      const externalAbort = Boolean(signal?.aborted);
+      const aborted = controller.signal.aborted || err?.name === 'AbortError';
+      if (aborted && timedOut && !externalAbort && attempt === 0) {
+        ui.logEvent(state, 'warn', state.language === 'es' ? 'Proveedor lento, reenviando mensaje' : 'Provider stalled, resending message');
+        continue;
+      }
+      if (aborted) {
+        if (externalAbort) {
+          throw new Error(state.language === 'es' ? 'Agente detenido por el usuario (ESC x2)' : 'Agent stopped by the user (ESC x2)');
         }
-      },
-    });
-
-    ui.pushAction(state, 'ok', 'Respuesta del modelo recibida');
-    return result.answer ?? '';
-  } catch (err) {
-    if (controller.signal.aborted || err?.name === 'AbortError') {
-      throw new Error(state.language === 'es' ? 'Agente detenido por el usuario o por tiempo agotado' : 'Agent stopped by the user or timed out');
-    }
-    throw err;
-  } finally {
-    clearTimeout(timeout);
-    if (signal) signal.removeEventListener('abort', onExternalAbort);
-    stopThinking();
-    if (thinkingStarted) ui.endThinkingStream(state);
-    if (streamOutput && answerStarted) {
-      ui.endAssistantStream(state);
+        throw new Error(state.language === 'es' ? 'Tiempo agotado del proveedor' : 'Provider timeout exceeded');
+      }
+      if (!externalAbort && attempt === 0) {
+        ui.logEvent(state, 'warn', state.language === 'es' ? 'Error transitorio, reenviando contexto y skills' : 'Transient error, resending context and skills');
+        continue;
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+      if (signal) signal.removeEventListener('abort', onExternalAbort);
+      stopThinking();
+      if (thinkingStarted) ui.endThinkingStream(state);
+      if (streamOutput && answerStarted) ui.endAssistantStream(state);
     }
   }
+  throw new Error(state.language === 'es' ? 'No se pudo obtener respuesta del proveedor' : 'Could not get provider response');
 }
 
 async function summarizeMessages(state, ui, messages) {
@@ -228,6 +248,7 @@ async function runAgentTurn(input, state, ui, options = {}) {
 
   let lastFingerprint = '';
   let repeatCount = 0;
+  const toolPathUsage = new Map();
   let step = 0;
   const turnLanguage = detectLanguage(input, state.language);
   state.language = turnLanguage;
@@ -389,7 +410,27 @@ async function runAgentTurn(input, state, ui, options = {}) {
       return { content, rendered: false };
     }
 
-    const fingerprint = `${parsed.tool}:${parsed.args?.path || ''}:${(parsed.args?.content || parsed.args?.search || '').length}`;
+    const targetPath = parsed.args?.path || '';
+    const contentSample = typeof parsed.args?.content === 'string'
+      ? parsed.args.content.slice(0, 120)
+      : '';
+    const fingerprint = `${parsed.tool}:${targetPath}:${contentSample}`;
+    if (targetPath) {
+      const key = `${parsed.tool}:${targetPath}`;
+      const nextCount = (toolPathUsage.get(key) || 0) + 1;
+      toolPathUsage.set(key, nextCount);
+      if (nextCount >= 3 && ['write_file', 'append_file', 'replace_in_file'].includes(parsed.tool)) {
+        ui.logEvent(state, 'warn', state.language === 'es' ? 'Posible loop detectado' : 'Possible loop detected', `${parsed.tool} → ${targetPath} x${nextCount}`);
+        turnMessages.push({
+          role: 'user',
+          content: state.language === 'es'
+            ? `ALTO: ya editaste ${targetPath} varias veces en este turno. No repitas ediciones; valida y responde con type=final.`
+            : `STOP: you already edited ${targetPath} multiple times in this turn. Do not repeat edits; verify and answer with type=final.`,
+        });
+        step += 1;
+        continue;
+      }
+    }
     if (fingerprint === lastFingerprint) {
       repeatCount += 1;
       if (repeatCount >= 2) {

package/src/core/prompts.js

@@ -41,6 +41,11 @@ function buildSystemPrompt(cwd, state = {}, options = {}) {
         'Si una tarea dura demasiado, usa run_command con un timeoutMs adecuado y confirma el resultado real.',
         'Para GitHub, GitLab o un Git personalizado usa git_secret_set para guardar credenciales y git_clone_repo o git_api_request para operar sin exponer secretos.',
         'Usa exclusivamente tools registradas en "Tool use". No inventes nombres de tools ni aliases.',
+        'Para tareas empresariales, mantente acotado y determinista: entradas claras, salidas claras, sin razonamiento creativo salvo que el usuario lo pida.',
+        'Cuando aplique, entrega resumen ejecutivo corto + riesgos/banderas rojas + siguiente accion concreta.',
+        'Para proyectos, usa combinaciones de tools según la fase: descubrir (list_dir/search_text), leer (read_file/fetch/webfetch), cambiar (write/replace), validar (run_command), documentar (final).',
+        'No te limites a una sola tool por costumbre; elige la mejor secuencia técnica para el objetivo.',
+        'Si el usuario pide logos, mockups o piezas visuales para un proyecto/frontend, usa create_canvas_image cuando corresponda, junto al resto de tools del flujo.',
       ]
     : [
         'Always respond in English.',
@@ -54,6 +59,11 @@ function buildSystemPrompt(cwd, state = {}, options = {}) {
         'If a task takes long, use run_command with an appropriate timeoutMs and verify the real result.',
         'For GitHub, GitLab, or a custom Git host, use git_secret_set to store credentials and git_clone_repo or git_api_request to operate without exposing secrets.',
         'Use only tools listed under "Tool use". Never invent tool names or aliases.',
+        'For business tasks, stay bounded and deterministic: clear inputs, clear outputs, no creative reasoning unless explicitly requested.',
+        'When relevant, provide a short executive summary + obvious red flags + next concrete action.',
+        'For project work, combine tools by phase: discover (list_dir/search_text), read (read_file/fetch/webfetch), change (write/replace), validate (run_command), then report.',
+        'Do not over-focus on a single tool by habit; choose the best technical sequence for the goal.',
+        'If the user asks for logos, mockups, or visual assets for a project/frontend, use create_canvas_image when appropriate together with the rest of the workflow.',
       ];
 
   const parts = [
@@ -75,6 +85,15 @@ function buildSystemPrompt(cwd, state = {}, options = {}) {
     providerGroups,
   ];
 
+  if (state.personaPrompt && state.personaPrompt.trim()) {
+    parts.push(
+      '',
+      '# Persona style (tone only)',
+      'Apply this only to communication style. Do NOT change tool choice, safety rules, or technical decisions.',
+      state.personaPrompt.trim(),
+    );
+  }
+
   if (state.concuerdo) {
     const activeKey = state.activeModel || DEFAULT_MODEL_KEY;
     const otherKeys = Object.keys(MODELS).filter(k => k !== activeKey);
@@ -180,7 +199,11 @@ const TOOL_ARG_KEYS = {
   append_file: ['path', 'content'],
   replace_in_file: ['path', 'search', 'replace', 'all'],
   fetch_url: ['url', 'selector', 'attribute', 'limit'],
-  web_search: ['query'],
+  fetch: ['url', 'method', 'headers', 'query', 'json', 'data', 'form', 'files', 'timeoutMs'],
+  fetch_http: ['url', 'method', 'headers', 'query', 'json', 'data', 'form', 'files', 'timeoutMs'],
+  webfetch: ['url', 'headers', 'timeoutMs'],
+  scrape_site: ['url', 'selectors', 'limit', 'headers'],
+  web_search: ['query', 'lang', 'limit'],
   web_read: ['url'],
   create_canvas_image: ['width', 'height', 'background', 'elements', 'format', 'outputPath'],
 };

package/src/tools/index.js

@@ -36,7 +36,11 @@ const TOOL_DEFINITIONS = [
   { name: 'append_file', usage: '{ path, content }' },
   { name: 'replace_in_file', usage: '{ path, search, replace, all? }' },
   { name: 'fetch_url', usage: '{ url, selector?, attribute?, limit?, headers? }' },
-  { name: 'web_search', usage: '{ query }' },
+  { name: 'fetch', usage: '{ url, method?, headers?, query?, json?, data?, form?, files?, timeoutMs? }' },
+  { name: 'fetch_http', usage: '{ url, method?, headers?, query?, json?, data?, form?, files?, timeoutMs? }' },
+  { name: 'webfetch', usage: '{ url, headers?, timeoutMs? }' },
+  { name: 'scrape_site', usage: '{ url, selectors, limit?, headers? }' },
+  { name: 'web_search', usage: '{ query, lang?, limit? }' },
   { name: 'web_read', usage: '{ url }' },
   { name: 'create_canvas_image', usage: '{ width, height, background?, elements?, format?, outputPath? }' },
 ];
@@ -97,7 +101,19 @@ function getToolPromptText() {
     '  Con selector + attribute (ej: "href", "src"): extrae atributo.',
     '  limit: max elementos a extraer (default: 20, max: 50).',
     '',
-    'web_search { query }',
+    'fetch_http { url, method?, headers?, query?, json?, data?, form?, files?, timeoutMs? }',
+    '  Cliente HTTP avanzado: soporta headers custom, query params, body JSON/texto, form-data y adjuntar archivos.',
+    '',
+    'fetch { url, method?, headers?, query?, json?, data?, form?, files?, timeoutMs? }',
+    '  Alias profesional recomendado para solicitudes HTTP avanzadas.',
+    '',
+    'webfetch { url, headers?, timeoutMs? }',
+    '  Descarga una pagina web y la convierte a Markdown estructurado (enlaces, botones, imagenes, texto).',
+    '',
+    'scrape_site { url, selectors, limit?, headers? }',
+    '  Scraping avanzado con multiples selectores en una sola llamada.',
+    '',
+    'web_search { query, lang?, limit? }',
     '  Busca en la web via DuckDuckGo. Retorna titulo, URL y snippet de los primeros resultados.',
     '  Si el usuario pide investigar algo, realiza la busqueda en lugar de explicar como hacerlo.',
     '  Ejemplo: {"type":"tool","tool":"web_search","args":{"query":"como usar puppeteer node"}}',
@@ -154,6 +170,14 @@ function describeToolCall(call) {
       const sel = call.args.selector ? ` → ${shortText(call.args.selector, 30)}` : '';
       return `Fetch ${shortText(cleanedUrl, 50)}${sel}`;
     }
+    case 'fetch_http':
+      return `HTTP ${String(call.args.method || 'GET').toUpperCase()} ${shortText(cleanUrl(call.args.url || ''), 50)}`;
+    case 'fetch':
+      return `Fetch ${String(call.args.method || 'GET').toUpperCase()} ${shortText(cleanUrl(call.args.url || ''), 50)}`;
+    case 'webfetch':
+      return `WebFetch ${shortText(cleanUrl(call.args.url || ''), 50)}`;
+    case 'scrape_site':
+      return `Scraping ${shortText(cleanUrl(call.args.url || ''), 50)}`;
     case 'web_search':
       return `Buscando "${shortText(call.args.query || '', 50)}"`;
     case 'web_read': {
@@ -277,6 +301,35 @@ async function askConfirmation(rl, title, detail, paint, state) {
   return answer === 's' || answer === 'si' || answer === 'y' || answer === 'yes';
 }
 
+function isIpHost(hostname = '') {
+  return /^(\d{1,3}\.){3}\d{1,3}$/.test(hostname)
+    || /^\[[0-9a-f:]+\]$/i.test(hostname)
+    || /^[0-9a-f:]+$/i.test(hostname);
+}
+
+async function requireIpConsent(urlValue, state, paint) {
+  let parsed;
+  try {
+    parsed = new URL(urlValue);
+  } catch {
+    return true;
+  }
+  if (!isIpHost(parsed.hostname)) return true;
+
+  if (state?.tuiConfirm) {
+    const answer = await state.tuiConfirm('Permiso obligatorio para IP', `Destino IP detectado: ${urlValue}\nConfirma acceso de red explícitamente.`);
+    return answer === 's' || answer === 'si' || answer === 'y' || answer === 'yes';
+  }
+  if (!state?.rl) return false;
+  console.error('');
+  console.error(`  ${paint('!', 'yellow')} Permiso obligatorio para IP`);
+  console.error(`    ${paint(`Destino IP detectado: ${urlValue}`, 'dim')}`);
+  const answer = (await state.rl.question(`  ${paint('s/N', 'yellow')} ${paint('\u276F', 'yellow')} `))
+    .trim()
+    .toLowerCase();
+  return answer === 's' || answer === 'si' || answer === 'y' || answer === 'yes';
+}
+
 async function listDirTool(args, state) {
   const targetPath = resolveInputPath(args.path ?? '.', state.cwd);
   const entries = await fsp.readdir(targetPath, { withFileTypes: true });
@@ -395,6 +448,7 @@ async function runCommandTool(args, state, paint) {
     return 'Comando cancelado por el usuario.';
   }
 
+
   const result = await runProcess('bash', ['-lc', command], {
     cwd: state.cwd,
     timeoutMs: 120000,
@@ -622,23 +676,37 @@ async function fetchUrlTool(args, state, paint) {
   if (!allowed) {
     return 'Fetch cancelado por el usuario.';
   }
+  if (!(await requireIpConsent(url, state, paint))) {
+    return 'Fetch a IP cancelado por falta de consentimiento explícito.';
+  }
 
   const axios = require('axios');
-  const response = await axios({
-    url,
-    method: 'GET',
-    headers: {
-      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
-      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-      'Accept-Language': 'es-ES,es;q=0.9,en;q=0.8',
-      ...(args.headers || {}),
-    },
-    timeout: 15000,
-    maxContentLength: 512000,
-    maxRedirects: 5,
-    responseType: 'text',
-    validateStatus: () => true,
-  });
+  let response;
+  let lastErr;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      response = await axios({
+        url,
+        method: 'GET',
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+          'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+          'Accept-Language': 'es-ES,es;q=0.9,en;q=0.8',
+          ...(args.headers || {}),
+        },
+        timeout: 15000,
+        maxContentLength: 512000,
+        maxRedirects: 5,
+        responseType: 'text',
+        validateStatus: () => true,
+      });
+      break;
+    } catch (err) {
+      lastErr = err;
+      if (attempt === 0) continue;
+    }
+  }
+  if (!response) throw lastErr || new Error('fetch_url fallo');
 
   const body = typeof response.data === 'string'
     ? response.data
@@ -685,45 +753,219 @@ async function fetchUrlTool(args, state, paint) {
   return truncateText(parts.join('\n'));
 }
 
-async function webSearchTool(args, state, paint) {
-  const query = (args.query || '').trim();
-  if (!query) throw new Error('web_search requiere query');
+async function fetchHttpTool(args, state, paint) {
+  if (!args.url || typeof args.url !== 'string') throw new Error('fetch_http requiere url');
+  const method = String(args.method || 'GET').toUpperCase();
+  const url = cleanUrl(args.url);
+  const detail = `${method} ${url}`;
+  const allowed = await askConfirmation(state.rl, 'HTTP avanzado', detail, paint, state);
+  if (!allowed) return 'Solicitud cancelada.';
+  if (!(await requireIpConsent(url, state, paint))) {
+    return 'Solicitud a IP cancelada por falta de consentimiento explícito.';
+  }
 
-  const allowed = await askConfirmation(
-    state.rl, 'Buscar en la web', query, paint, state,
-  );
-  if (!allowed) return 'Busqueda cancelada.';
+  const headers = { ...(args.headers || {}) };
+  let body;
+  const isCatbox = /catbox\.moe/i.test(url);
+  if (args.json && typeof args.json === 'object') {
+    body = JSON.stringify(args.json);
+    headers['Content-Type'] = headers['Content-Type'] || 'application/json';
+  } else if (args.data !== undefined) {
+    body = String(args.data);
+  } else if (args.form && typeof args.form === 'object') {
+    const formPayload = { ...args.form };
+    if (isCatbox && !formPayload.reqtype) formPayload.reqtype = 'fileupload';
+    const form = new FormData();
+    for (const [k, v] of Object.entries(formPayload)) form.append(k, String(v));
+    if (Array.isArray(args.files)) {
+      for (const file of args.files) {
+        if (!file || !file.path || !file.field) continue;
+        const filePath = resolveInputPath(file.path, state.cwd);
+        const buffer = await fs.promises.readFile(filePath);
+        const blob = new Blob([buffer], { type: file.type || 'application/octet-stream' });
+        const fieldName = isCatbox ? 'fileToUpload' : String(file.field);
+        form.append(fieldName, blob, file.name || path.basename(file.path));
+      }
+    }
+    body = form;
+  } else if (Array.isArray(args.files) && args.files.length > 0) {
+    const form = new FormData();
+    if (isCatbox) form.append('reqtype', 'fileupload');
+    for (const file of args.files) {
+      if (!file || !file.path) continue;
+      const filePath = resolveInputPath(file.path, state.cwd);
+      const buffer = await fs.promises.readFile(filePath);
+      const blob = new Blob([buffer], { type: file.type || 'application/octet-stream' });
+      const fieldName = isCatbox ? 'fileToUpload' : String(file.field || 'file');
+      form.append(fieldName, blob, file.name || path.basename(file.path));
+    }
+    body = form;
+  }
+  if (body instanceof FormData) {
+    delete headers['Content-Type'];
+    delete headers['content-type'];
+  }
+  const finalUrl = new URL(url);
+  if (args.query && typeof args.query === 'object') {
+    for (const [k, v] of Object.entries(args.query)) finalUrl.searchParams.set(k, String(v));
+  }
+  let res;
+  let lastErr;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.max(1000, Number(args.timeoutMs || 20000)));
+    try {
+      res = await fetch(finalUrl.toString(), { method, headers, body, signal: controller.signal });
+      clearTimeout(timeout);
+      break;
+    } catch (err) {
+      clearTimeout(timeout);
+      lastErr = err;
+      if (attempt === 0) continue;
+    }
+  }
+  if (!res) throw lastErr || new Error('fetch fallo');
+  const text = await res.text();
+  return truncateText(`Status: ${res.status}\nContent-Type: ${res.headers.get('content-type') || '-'}\n\n${text}`);
+}
 
+async function scrapeSiteTool(args, state, paint) {
+  if (!args.url || typeof args.url !== 'string') throw new Error('scrape_site requiere url');
+  if (!args.selectors || typeof args.selectors !== 'object') throw new Error('scrape_site requiere selectors objeto');
+  const url = cleanUrl(args.url);
+  const allowed = await askConfirmation(state.rl, 'Scrape site', `GET ${url}`, paint, state);
+  if (!allowed) return 'Scraping cancelado.';
+  if (!(await requireIpConsent(url, state, paint))) return 'Scraping a IP cancelado por falta de consentimiento explícito.';
   const axios = require('axios');
+  const res = await axios({
+    url,
+    method: 'GET',
+    headers: { 'User-Agent': 'Mozilla/5.0', ...(args.headers || {}) },
+    timeout: 15000,
+    responseType: 'text',
+    validateStatus: () => true,
+  });
+  const body = typeof res.data === 'string' ? res.data : String(res.data || '');
   const cheerio = require('cheerio');
-  const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+  const $ = cheerio.load(body);
+  const limit = Math.min(Number(args.limit) || 20, 100);
+  const out = {};
+  for (const [key, spec] of Object.entries(args.selectors)) {
+    const selector = typeof spec === 'string' ? spec : spec?.selector;
+    const attr = typeof spec === 'object' ? spec.attribute : null;
+    if (!selector) continue;
+    const arr = [];
+    $(selector).each((i, el) => {
+      if (i >= limit) return false;
+      const node = $(el);
+      const tag = String(el.tagName || '').toLowerCase();
+      let value = '';
+      if (attr) {
+        value = node.attr(attr) || '';
+      } else if (tag === 'meta') {
+        value = node.attr('content') || '';
+      } else if (tag === 'title') {
+        value = node.text().trim();
+      } else {
+        value = node.text().trim();
+      }
+      if (value) arr.push(value);
+    });
+    out[key] = arr;
+  }
+  return truncateText(JSON.stringify(out, null, 2));
+}
+
+function htmlToMarkdown(html) {
+  const cheerio = require('cheerio');
+  const $ = cheerio.load(html);
+  $('script,style,noscript').remove();
+  const lines = [];
+  const root = $('body').length ? $('body') : $.root();
+  root.find('h1,h2,h3,h4,h5,h6,p,li,pre,code,blockquote,a,img,button').each((_, el) => {
+    const tag = (el.tagName || '').toLowerCase();
+    const node = $(el);
+    const text = node.text().trim().replace(/\s+/g, ' ');
+    if (!text && !['img', 'a'].includes(tag)) return;
+    if (tag.startsWith('h')) lines.push(`${'#'.repeat(Number(tag[1]) || 1)} ${text}`);
+    else if (tag === 'li') lines.push(`- ${text}`);
+    else if (tag === 'a') lines.push(`[${text || 'link'}](${node.attr('href') || ''})`);
+    else if (tag === 'img') lines.push(`![${node.attr('alt') || 'image'}](${node.attr('src') || ''})`);
+    else if (tag === 'button') lines.push(`**[Button]** ${text}`);
+    else if (tag === 'blockquote') lines.push(`> ${text}`);
+    else if (tag === 'pre' || tag === 'code') lines.push(`\`\`\`\n${node.text()}\n\`\`\``);
+    else lines.push(text);
+  });
+  return lines.join('\n\n').trim();
+}
 
+async function webfetchTool(args, state, paint) {
+  const rawUrl = String(args.url || '').trim();
+  if (!rawUrl) throw new Error('webfetch requiere url');
+  const url = cleanUrl(rawUrl);
+  const allowed = await askConfirmation(state.rl, 'WebFetch HTML → Markdown', `GET ${url}`, paint, state);
+  if (!allowed) return 'WebFetch cancelado por el usuario.';
+  if (!(await requireIpConsent(url, state, paint))) {
+    return 'WebFetch a IP cancelado por falta de consentimiento explícito.';
+  }
+  const axios = require('axios');
   const res = await axios({
     url,
     method: 'GET',
     headers: {
-      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
-      'Accept-Language': 'es-ES,es;q=0.9,en;q=0.8',
+      'User-Agent': 'Mozilla/5.0',
+      'Accept': 'text/html,application/xhtml+xml',
+      ...(args.headers || {}),
     },
-    timeout: 15000,
+    timeout: Math.max(1000, Number(args.timeoutMs || 20000)),
     responseType: 'text',
+    validateStatus: () => true,
   });
+  const ct = String(res.headers['content-type'] || '').toLowerCase();
+  if (!ct.includes('text/html')) {
+    throw new Error(`webfetch solo permite HTML. Content-Type recibido: ${ct || 'desconocido'}`);
+  }
+  const html = typeof res.data === 'string' ? res.data : String(res.data || '');
+  const markdown = htmlToMarkdown(html);
+  return truncateText(markdown || '[sin contenido markdown]');
+}
 
-  const $ = cheerio.load(res.data);
-  const results = [];
+async function webSearchTool(args, state, paint) {
+  const query = (args.query || '').trim();
+  if (!query) throw new Error('web_search requiere query');
 
-  $('.result').each((i, el) => {
-    if (i >= 10) return false;
-    const title = $(el).find('.result__a').text().trim();
-    const snippet = $(el).find('.result__snippet').text().trim();
-    const href = $(el).find('.result__url').attr('href')
-      || $(el).find('.result__a').attr('href') || '';
-    if (title) results.push(`${i + 1}. ${title}\n   ${href}\n   ${snippet}`);
-  });
+  const allowed = await askConfirmation(
+    state.rl, 'Buscar en la web', query, paint, state,
+  );
+  if (!allowed) return 'Busqueda cancelada.';
 
-  return results.length > 0
-    ? `Resultados para: ${query}\n\n${results.join('\n\n')}`
-    : 'Sin resultados para esa busqueda.';
+  const cheerio = require('cheerio');
+  const lang = String(args.lang || (state.language === 'es' ? 'es-es' : 'us-en')).toLowerCase();
+  const limit = Math.max(1, Math.min(Number(args.limit) || 5, 20));
+  const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}&kl=${encodeURIComponent(lang)}`;
+  const res = await fetch(url, {
+    headers: {
+      'User-Agent': 'Mozilla/5.0',
+      'Accept-Language': lang.startsWith('es') ? 'es-ES,es;q=0.9,en;q=0.7' : 'en-US,en;q=0.9',
+    },
+  });
+  const html = await res.text();
+  const $ = cheerio.load(html);
+  const results = [];
+  $('.result').each((_, el) => {
+    if (results.length >= limit) return false;
+    const titleEl = $(el).find('.result__a').first();
+    const snippetEl = $(el).find('.result__snippet').first();
+    let href = titleEl.attr('href') || '';
+    const match = href.match(/uddg=([^&]+)/);
+    if (match) href = decodeURIComponent(match[1]);
+    const title = titleEl.text().trim();
+    const snippet = snippetEl.text().trim();
+    if (title && href) results.push(`${results.length + 1}. ${title}\n   ${href}\n   ${snippet}`);
+  });
+  return results.length
+    ? `Resultados para: ${query}\nIdioma: ${lang}\n\n${results.join('\n\n')}`
+    : 'Sin resultados para esa búsqueda.';
 }
 
 async function webReadTool(args, state, paint) {
@@ -741,6 +983,9 @@ async function webReadTool(args, state, paint) {
     state.rl, 'Leer pagina web', url, paint, state,
   );
   if (!allowed) return 'Lectura cancelada.';
+  if (!(await requireIpConsent(url, state, paint))) {
+    return 'Lectura a IP cancelada por falta de consentimiento explícito.';
+  }
 
   const axios = require('axios');
   const res = await axios({
@@ -818,6 +1063,18 @@ async function executeToolCall(call, state, ui) {
     case 'fetch_url':
       result = await fetchUrlTool(call.args, state, ui.paint);
       break;
+    case 'fetch_http':
+      result = await fetchHttpTool(call.args, state, ui.paint);
+      break;
+    case 'fetch':
+      result = await fetchHttpTool(call.args, state, ui.paint);
+      break;
+    case 'webfetch':
+      result = await webfetchTool(call.args, state, ui.paint);
+      break;
+    case 'scrape_site':
+      result = await scrapeSiteTool(call.args, state, ui.paint);
+      break;
     case 'web_search':
       result = await webSearchTool(call.args, state, ui.paint);
       break;
@@ -869,6 +1126,19 @@ function parseDirectAction(input) {
     };
   }
 
+  const createRepoMatch = text.match(/^(?:crea|crear|create)\s+(?:un\s+)?(?:repo|repositorio)\s+(?:en\s+)?github\s+([a-z0-9._-]+)$/i);
+  if (createRepoMatch) {
+    return {
+      tool: 'git_api_request',
+      args: {
+        provider: 'github',
+        method: 'POST',
+        path: '/user/repos',
+        body: { name: createRepoMatch[1] },
+      },
+    };
+  }
+
   const mkdirMatch = text.match(/^(?:crea|crear|haz)\s+(?:la\s+)?(?:carpeta|directorio)\s+([^\s]+)$/i);
   if (mkdirMatch) {
     return {
@@ -1198,13 +1468,19 @@ async function gitSecretListTool(args) {
     return secret.key === provider;
   });
   if (!filtered.length) return 'No hay credenciales Git guardadas.';
+  const maskToken = (token) => {
+    const value = String(token || '');
+    if (!value) return '-';
+    if (value.length <= 8) return `${value.slice(0, 2)}***`;
+    return `${value.slice(0, 4)}...${value.slice(-4)}`;
+  };
   return filtered.map(secret => [
     `${secret.key}`,
     `  username: ${secret.username || '-'}`,
     `  apiBaseUrl: ${secret.apiBaseUrl || '-'}`,
     `  cloneBaseUrl: ${secret.cloneBaseUrl || '-'}`,
     `  authHeader: ${secret.authHeader || '-'}`,
-    `  token: ${secret.token}`,
+    `  tokenMasked: ${maskToken(secret.token)}`,
   ].join('\n')).join('\n\n');
 }
 

package/src/tui/app.mjs

@@ -450,14 +450,18 @@ function EventLine({ kind, title, detail }) {
 }
 
 function UserMessage({ text }) {
+  const rawLines = String(text || '').split('\n');
+  const lines = rawLines.slice(0, 40);
+  const more = rawLines.length - lines.length;
   return h(Box, { paddingLeft: 3, paddingRight: 3, marginTop: 1, marginBottom: 0, flexDirection: 'row' },
     h(Box, { flexDirection: 'column' },
       h(Box, { gap: 1, marginBottom: 0 },
         h(Text, { color: T.accent, bold: true }, '\u29bf'),
         h(Text, { color: T.textDim, bold: true }, uiText('You', 'Tú')),
       ),
-      h(Box, { paddingLeft: 2 },
-        h(Text, { color: T.text, wrap: 'wrap' }, text),
+      h(Box, { paddingLeft: 2, flexDirection: 'column' },
+        ...lines.map((line, i) => h(Text, { key: String(i), color: T.text, wrap: 'wrap' }, line)),
+        more > 0 ? h(Text, { color: T.textGhost }, `... ${more} ${uiText('more lines', 'líneas más')}`) : null,
       ),
     ),
   );
@@ -605,13 +609,14 @@ function StaticItem({ item, width }) {
   }
 }
 
-function InputBar({ onSubmit, processing }) {
+function InputBar({ onSubmit, processing, width = 100 }) {
   const [value, setValue] = useState('');
   const [cursor, setCursor] = useState(0);
   const [histIdx, setHistIdx] = useState(-1);
   const [suggestIdx, setSuggestIdx] = useState(0);
   const historyRef = useRef([]);
   const savedRef = useRef('');
+  const lastPasteMetaRef = useRef(null);
 
   const showSuggestions = value.startsWith('/') && !value.includes(' ') && value.length > 0;
   const suggestions = showSuggestions
@@ -633,7 +638,8 @@ function InputBar({ onSubmit, processing }) {
       setCursor(0);
       setHistIdx(-1);
       setSuggestIdx(0);
-      onSubmit(text);
+      onSubmit(text, lastPasteMetaRef.current);
+      lastPasteMetaRef.current = null;
       return;
     }
 
@@ -731,9 +737,16 @@ function InputBar({ onSubmit, processing }) {
   });
 
   const hasText = value.length > 0;
-  const before = value.slice(0, cursor);
-  const cursorChar = value[cursor] || ' ';
-  const after = value.slice(cursor + 1);
+  const maxInputCols = Math.max(20, (width || 100) - 12);
+  let start = Math.max(0, cursor - Math.floor(maxInputCols * 0.7));
+  if (value.length - start < maxInputCols) {
+    start = Math.max(0, value.length - maxInputCols);
+  }
+  const visibleText = value.slice(start, start + maxInputCols);
+  const cursorInVisible = Math.max(0, Math.min(cursor - start, visibleText.length));
+  const before = visibleText.slice(0, cursorInVisible);
+  const cursorChar = visibleText[cursorInVisible] || ' ';
+  const after = visibleText.slice(cursorInVisible + 1);
 
   const promptColor = processing ? T.amber : T.accent;
   const placeholder = processing ? uiText(' Queued — type and it will run later...', ' En cola — escribe y se procesará después...') : uiText(' Type a message...', ' Escribe un mensaje...');
@@ -801,7 +814,7 @@ function App({ store, state, onSubmit }) {
     ? uiText('Concord · ', 'Concuerdo · ') + Object.values(MODELS).map(m => m.label).join(', ')
     : (MODELS[modelKey]?.label || modelKey).toLowerCase();
 
-  const handleInput = useCallback((text) => {
+  const handleInput = useCallback((text, meta) => {
     if (text === '/exit' || text === '/quit') {
       if (store.processing) {
         store.pendingExit = true;
@@ -811,7 +824,7 @@ function App({ store, state, onSubmit }) {
       exit();
       return;
     }
-    onSubmit(text);
+    onSubmit(text, meta);
   }, [onSubmit, exit, store]);
 
   useInput((input, key) => {
@@ -870,7 +883,7 @@ function App({ store, state, onSubmit }) {
 
   if (showInput) {
     dynamicArea.push(
-      h(InputBar, { key: 'input', onSubmit: handleInput, processing: store.processing })
+      h(InputBar, { key: 'input', onSubmit: handleInput, processing: store.processing, width })
     );
   }
 
@@ -920,6 +933,12 @@ export async function startTUI(options = {}) {
     if (msgs.length) store._emit();
     return msgs;
   };
+  state.clearQueuedMessages = () => {
+    if (store.messageQueue.length) {
+      store.messageQueue = [];
+      store._emit();
+    }
+  };
 
   const modelKey   = state.activeModel || DEFAULT_MODEL_KEY;
   const modelLabel = (MODELS[modelKey]?.label || modelKey).toLowerCase();
@@ -998,11 +1017,13 @@ export async function startTUI(options = {}) {
 
   let appInstance = null;
 
-  const handleSubmit = async (input) => {
-    if (typeof input === 'string' && input.length > MAX_PASTE_PREVIEW) {
+  const handleSubmit = async (input, meta = null) => {
+    const pasteLen = Number(meta?.length || 0);
+    if (pasteLen > 0 || (typeof input === 'string' && input.length > MAX_PASTE_PREVIEW)) {
+      const shown = input.length;
       store.addEvent(
-        'info',
-        `[ ${uiText('Pasted Text', 'Texto pegado')} of ${input.length} ${uiText('Characters', 'Caracteres')} ]`,
+        'warn',
+        `[ Pasted Text of ${shown} Characters ]`,
         input.slice(0, MAX_PASTE_PREVIEW) + '...'
       );
     }

package/src/utils/sessionStorage.js

@@ -8,8 +8,10 @@ const {
   CURRENT_SESSION_FILE,
   DEFAULT_LANGUAGE,
   DEFAULT_MODEL_KEY,
+  PERSISTENT_CONFIG_FILE,
   SESSIONS_DIR,
 } = require('../config');
+const { normalizeLanguage } = require('../i18n');
 const { getTranscriptPath } = require('./transcriptStorage');
 
 function createState(rl = null) {
@@ -28,11 +30,35 @@ function createState(rl = null) {
     liveResponse: null,
     transcriptPath: '',
     autoApprove: false,
+    concuerdo: false,
     activeModel: DEFAULT_MODEL_KEY,
     language: DEFAULT_LANGUAGE,
+    personaPrompt: '',
   };
 }
 
+async function loadPersistentConfig() {
+  const data = await readJson(PERSISTENT_CONFIG_FILE);
+  if (!data || typeof data !== 'object') return {};
+  return {
+    cwd: typeof data.cwd === 'string' && data.cwd.trim() ? data.cwd : undefined,
+    autoApprove: Boolean(data.autoApprove),
+    activeModel: typeof data.activeModel === 'string' && data.activeModel.trim() ? data.activeModel : undefined,
+    language: normalizeLanguage(data.language || DEFAULT_LANGUAGE),
+    concuerdo: Boolean(data.concuerdo),
+  };
+}
+
+async function savePersistentConfig(state) {
+  await writeJson(PERSISTENT_CONFIG_FILE, {
+    cwd: state.cwd || process.cwd(),
+    autoApprove: Boolean(state.autoApprove),
+    activeModel: state.activeModel || DEFAULT_MODEL_KEY,
+    language: state.language || DEFAULT_LANGUAGE,
+    concuerdo: Boolean(state.concuerdo),
+  });
+}
+
 function createSessionId() {
   const stamp = new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14);
   const random = Math.random().toString(36).slice(2, 8);
@@ -88,8 +114,10 @@ function applyLoadedState(state, loaded) {
   state.turnCount = Number(loaded.turnCount ?? 0);
   state.transcriptPath = loaded.transcriptPath || getTranscriptPath(loaded.sessionId);
   state.autoApprove = Boolean(loaded.autoApprove);
+  state.concuerdo = Boolean(loaded.concuerdo);
   state.activeModel = loaded.activeModel || DEFAULT_MODEL_KEY;
   state.language = loaded.language || DEFAULT_LANGUAGE;
+  state.personaPrompt = loaded.personaPrompt || '';
   if (state.actionLog.length > ACTION_LOG_LIMIT) {
     state.actionLog = state.actionLog.slice(-ACTION_LOG_LIMIT);
   }
@@ -114,10 +142,13 @@ async function saveState(state) {
     turnCount: state.turnCount,
     transcriptPath: state.transcriptPath,
     autoApprove: Boolean(state.autoApprove),
+    concuerdo: Boolean(state.concuerdo),
     activeModel: state.activeModel || DEFAULT_MODEL_KEY,
     language: state.language || DEFAULT_LANGUAGE,
+    personaPrompt: state.personaPrompt || '',
   });
   await setCurrentSessionId(state.sessionId);
+  await savePersistentConfig(state);
 }
 
 async function createNewSessionState(rl) {
@@ -169,10 +200,17 @@ async function loadOrCreateSessionState(rl, options = {}) {
     }
   }
 
-  return {
-    state: await createNewSessionState(rl),
-    resumed: false,
-  };
+  const created = await createNewSessionState(rl);
+  const persisted = await loadPersistentConfig();
+  if (persisted && Object.keys(persisted).length > 0) {
+    created.cwd = persisted.cwd || created.cwd;
+    created.autoApprove = Boolean(persisted.autoApprove);
+    created.activeModel = persisted.activeModel || created.activeModel;
+    created.language = persisted.language || created.language;
+    created.concuerdo = Boolean(persisted.concuerdo);
+    await saveState(created);
+  }
+  return { state: created, resumed: false };
 }
 
 async function listSessions() {