zyn-ai 1.2.1 → 1.3.0

package/README.md

@@ -1,4 +1,4 @@
-# Zyn
+# Zyn Agent
 
 <p align="center">
   <img src="http://cdn.soymaycol.icu/files/logo_zyn.png" alt="Zyn logo" width="180" />

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "zyn-ai",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Production-ready AI agent for CLI and web with real tool execution and automation",
-  "author": "Maycol y Ado",
+  "author": "Maycol",
   "keywords": [
     "ai-agent",
     "cli-ai",
@@ -18,7 +18,8 @@
     "zyn"
   ],
   "bin": {
-    "zyn": "./zyn.js"
+    "zyn": "./zyn.js",
+    "Zyn": "./zyn.js"
   },
   "type": "commonjs",
   "scripts": {
@@ -36,7 +37,8 @@
     "ink": "^6.8.0",
     "keypress": "^0.2.1",
     "react": "^19.0.0",
-    "session-file-store": "^1.5.0"
+    "session-file-store": "^1.5.0",
+    "jimp": "^1.6.1"
   },
   "repository": {
     "type": "git",

package/src/cli/commands.js

@@ -7,6 +7,7 @@ const { listSkills, SKILLS_DIR } = require('../core/skills');
 const { DEFAULT_LANGUAGE, DEFAULT_MODEL_KEY, MODELS, listProvidersFromModels } = require('../config');
 const { languageLabel, normalizeLanguage, t } = require('../i18n');
 const { createNewSessionState, listSessions, loadSessionState, saveState } = require('../utils/sessionStorage');
+const { listGitSecrets, removeGitSecret, upsertGitSecret } = require('../utils/secretStorage');
 const { exportTranscriptText, formatTranscriptPreview } = require('../utils/transcriptStorage');
 const { resolveInputPath } = require('../utils/pathUtils');
 const { printTools } = require('../tools');
@@ -24,6 +25,7 @@ const SLASH_COMMANDS = [
   { name: 'model', desc: 'view/change model' },
   { name: 'models', desc: 'list models' },
   { name: 'providers', desc: 'list providers' },
+  { name: 'git', desc: 'configure git credentials' },
   { name: 'lang', desc: 'change language' },
   { name: 'language', desc: 'change language' },
   { name: 'auto', desc: 'auto-approval' },

package/src/cli/runtime.js

@@ -28,6 +28,7 @@ const {
   loadOrCreateSessionState,
 } = require('../utils/sessionStorage');
 const { appendTranscriptEntry } = require('../utils/transcriptStorage');
+const { t } = require('../i18n');
 
 async function readPromptFromStdin() {
   if (process.stdin.isTTY) {
@@ -175,7 +176,7 @@ async function runInteractiveChatClassic(options = {}) {
       if (!input) continue;
 
       if (input === '/exit' || input === '/quit') {
-        logEvent(state, 'info', 'Hasta luego');
+        logEvent(state, 'info', t(state.language, 'goodbye'));
         break;
       }
 
@@ -202,7 +203,7 @@ async function runInteractiveChatClassic(options = {}) {
       rl.removeListener('line', lineHandler);
 
       if (pendingExit) {
-        logEvent(state, 'info', 'Hasta luego');
+        logEvent(state, 'info', t(state.language, 'goodbye'));
         break;
       }
     }

package/src/config.js

@@ -89,10 +89,10 @@ const MODELS = {
 };
 
 const DEFAULT_MODEL_KEY = process.env.ZYN_DEFAULT_MODEL || 'qwen';
-const DEFAULT_LANGUAGE = normalizeLanguage(process.env.ZYN_DEFAULT_LANG || process.env.ZYN_LANGUAGE || 'en');
+const DEFAULT_LANGUAGE = normalizeLanguage(process.env.ZYN_DEFAULT_LANG || process.env.ZYN_LANGUAGE || process.env.LANG || 'en');
 
-const QWEN_EMAIL = process.env.ZYN_QWEN_EMAIL || process.env.QWEN_EMAIL || 'danielalejandrobasado@gmail.com';
-const QWEN_PASSWORD = process.env.ZYN_QWEN_PASSWORD || process.env.QWEN_PASSWORD || 'zyzz1234';
+const QWEN_EMAIL = process.env.ZYN_QWEN_EMAIL || 'danielalejandrobasado@gmail.com';
+const QWEN_PASSWORD = process.env.ZYN_QWEN_PASSWORD || 'zyzz1234';
 
 const MAX_TOOL_STEPS = Number.POSITIVE_INFINITY;
 const MAX_OUTPUT_CHARS = 12000;

package/src/core/agent.js

@@ -197,6 +197,9 @@ async function runAgentTurn(input, state, ui, options = {}) {
   }
   ui.logEvent(state, 'info', `${state.language === 'es' ? 'Turno' : 'Turn'} ${state.turnCount}`);
 
+  let toolUsedThisTurn = false;
+  let finalWithoutToolRetries = 0;
+
   const directAction = parseDirectAction(input);
   if (directAction) {
     await appendTranscriptEntry(state.sessionId, { type: 'user', content: input });
@@ -227,8 +230,7 @@ async function runAgentTurn(input, state, ui, options = {}) {
   let repeatCount = 0;
   let step = 0;
   const turnLanguage = detectLanguage(input, state.language);
-  let toolUsedThisTurn = false;
-  let finalWithoutToolRetries = 0;
+  state.language = turnLanguage;
 
   while (true) {
     if (signal?.aborted) {

package/src/core/prompts.js

@@ -1,13 +1,14 @@
 const { normalizeText } = require('../utils/text');
 const { buildSkillsPrompt } = require('./skills');
-const { getToolPromptText } = require('../tools');
+const { getToolPromptText, TOOL_DEFINITIONS } = require('../tools');
 const { listProvidersFromModels, MODELS, DEFAULT_MODEL_KEY } = require('../config');
 const { detectLanguage, normalizeLanguage, languageLabel } = require('../i18n');
 
 const KNOWN_TOOLS = new Set([
-  'list_dir', 'read_file', 'search_text', 'glob_files', 'file_info',
-  'run_command', 'make_dir', 'write_file', 'append_file', 'replace_in_file',
-  'fetch_url', 'web_search', 'web_read',
+  ...TOOL_DEFINITIONS.map(tool => tool.name),
+  'task_create', 'task_list', 'task_update', 'task_complete', 'task_delete', 'task_clear',
+  'git_secret_set', 'git_secret_list', 'git_secret_remove',
+  'git_clone_repo', 'git_api_request',
 ]);
 
 
@@ -37,6 +38,9 @@ function buildSystemPrompt(cwd, state = {}, options = {}) {
         'Nunca finjas que hiciste algo si no usaste herramientas o no tienes el resultado real.',
         'Si la tarea requiere comprobar algo, primero intenta una herramienta real y espera el resultado antes de concluir.',
         'No cierres con una conclusion si todavia no has probado nada.',
+        '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.',
       ]
     : [
         'Always respond in English.',
@@ -47,6 +51,9 @@ function buildSystemPrompt(cwd, state = {}, options = {}) {
         'Never pretend you completed an action if you did not actually use tools or obtain a real result.',
         'If the task requires verification, try a real tool first and wait for its result before concluding.',
         'Do not end with a conclusion if you have not tested anything yet.',
+        '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.',
       ];
 
   const parts = [
@@ -175,6 +182,7 @@ const TOOL_ARG_KEYS = {
   fetch_url: ['url', 'selector', 'attribute', 'limit'],
   web_search: ['query'],
   web_read: ['url'],
+  create_canvas_image: ['width', 'height', 'background', 'elements', 'format', 'outputPath'],
 };
 
 const LONG_VALUE_ARG = {

package/src/i18n.js

@@ -47,6 +47,9 @@ const STRINGS = {
     transcriptLabel: 'transcript',
     fromLabel: 'created',
     updatedLabel: 'updated',
+    queuedLabel: 'queued',
+    processingQueuedMessage: 'processing queued message',
+    goodbye: 'Goodbye',
   },
   es: {
     helpTitle: 'Ayuda',
@@ -89,6 +92,9 @@ const STRINGS = {
     transcriptLabel: 'transcript',
     fromLabel: 'desde',
     updatedLabel: 'actualizado',
+    queuedLabel: 'en cola',
+    processingQueuedMessage: 'procesando mensaje en cola',
+    goodbye: 'Hasta luego',
   },
 };
 

package/src/tools/index.js

@@ -7,6 +7,16 @@ const fsp = fs.promises;
 const {
   MAX_FILE_LINES,
 } = require('../config');
+const {
+  buildApiHeaders,
+  buildCloneUrl,
+  getApiBaseUrl,
+  listGitSecrets,
+  normalizeProfileName,
+  removeGitSecret,
+  resolveGitProfile,
+  upsertGitSecret,
+} = require('../utils/secretStorage');
 const { resolveInputPath } = require('../utils/pathUtils');
 const {
   formatLineRange,
@@ -28,7 +38,9 @@ const TOOL_DEFINITIONS = [
   { name: 'fetch_url', usage: '{ url, selector?, attribute?, limit?, headers? }' },
   { name: 'web_search', usage: '{ query }' },
   { name: 'web_read', usage: '{ url }' },
+  { name: 'create_canvas_image', usage: '{ width, height, background?, elements?, format?, outputPath? }' },
 ];
+const REGISTERED_TOOLS = new Set(TOOL_DEFINITIONS.map(tool => tool.name));
 
 function getToolPromptText() {
   return [
@@ -94,6 +106,17 @@ function getToolPromptText() {
     '  Descarga una pagina web y la convierte a texto legible (sin HTML).',
     '  Ideal para leer articulos, documentacion o contenido de paginas.',
     '  Ejemplo: {"type":"tool","tool":"web_read","args":{"url":"https://docs.example.com/guide"}}',
+    '',
+    '## Imagen profesional con Jimp',
+    '',
+    'create_canvas_image { width, height, background?, elements?, format?, outputPath? }',
+    '  Crea imagenes desde cero usando Jimp con composicion por elementos.',
+    '  width/height son obligatorios. background puede ser color HEX (#RRGGBB o #RRGGBBAA).',
+    '  elements permite combinar rect, circle/ellipse, line, text e image.',
+    '  Usa este flujo profesional: definir lienzo -> capas base -> tipografia -> detalles -> exportacion.',
+    '  Ejemplo:',
+    '  {"type":"tool","tool":"create_canvas_image","args":{"width":1200,"height":628,"background":"#0f172a","format":"png","outputPath":"generated/cover.png","elements":[{"type":"rect","x":48,"y":48,"w":1104,"h":532,"radius":24,"fill":"#111827"},{"type":"text","x":96,"y":120,"fontSize":32,"text":"Quarterly Business Report"}]}}',
+    '',
   ].join('\n');
 }
 
@@ -137,6 +160,8 @@ function describeToolCall(call) {
       const readUrl = cleanUrl(call.args.url || '');
       return `Leyendo ${shortText(readUrl, 60)}`;
     }
+    case 'create_canvas_image':
+      return `Creando imagen ${call.args.width || '?'}x${call.args.height || '?'}`;
     default:
       return call.tool;
   }
@@ -751,6 +776,9 @@ async function webReadTool(args, state, paint) {
 }
 
 async function executeToolCall(call, state, ui) {
+  if (!call || typeof call.tool !== 'string' || !REGISTERED_TOOLS.has(call.tool)) {
+    throw new Error(`Herramienta no registrada: ${call?.tool || 'desconocida'}`);
+  }
   ui.logEvent(state, 'tool', describeToolCall(call));
 
   const startTime = Date.now();
@@ -796,6 +824,9 @@ async function executeToolCall(call, state, ui) {
     case 'web_read':
       result = await webReadTool(call.args, state, ui.paint);
       break;
+    case 'create_canvas_image':
+      result = await createCanvasImageTool(call.args, state, ui.paint);
+      break;
     default:
       throw new Error(`Herramienta no soportada: ${call.tool}`);
   }
@@ -819,6 +850,9 @@ function buildOllamaInstallCommand() {
 
 function parseDirectAction(input) {
   const text = input.trim();
+  if (/^(git|npm|node|pnpm|yarn)\s+/.test(text)) {
+    return { tool: 'run_command', args: { command: text } };
+  }
 
   const runMatch = text.match(/^(?:ejecuta|corre)\s+(?:el\s+)?comando\s+([\s\S]+)$/i);
   if (runMatch) {
@@ -1002,3 +1036,245 @@ module.exports = {
   parseDirectAction,
   printTools,
 };
+
+
+function getGitSecretLabel(provider, name = '') {
+  const key = normalizeProfileName(provider);
+  if (key === 'custom') return name ? `custom:${name}` : 'custom';
+  return key;
+}
+
+function parseColor(value, fallback = 0x000000ff) {
+  if (typeof value !== 'string' || !value.trim()) return fallback;
+  const raw = value.trim().replace('#', '');
+  if (/^[0-9a-f]{6}$/i.test(raw)) return Number.parseInt(`${raw}ff`, 16) >>> 0;
+  if (/^[0-9a-f]{8}$/i.test(raw)) return Number.parseInt(raw, 16) >>> 0;
+  return fallback;
+}
+
+function drawRect(image, x, y, w, h, color) {
+  const left = Math.max(0, Math.floor(Number(x) || 0));
+  const top = Math.max(0, Math.floor(Number(y) || 0));
+  const width = Math.max(1, Math.floor(Number(w) || 0));
+  const height = Math.max(1, Math.floor(Number(h) || 0));
+  image.scan(left, top, width, height, function (px, py, idx) {
+    this.bitmap.data.writeUInt32BE(color >>> 0, idx);
+  });
+}
+
+function drawRoundRect(image, x, y, w, h, radius, color) {
+  const left = Math.max(0, Math.floor(Number(x) || 0));
+  const top = Math.max(0, Math.floor(Number(y) || 0));
+  const width = Math.max(1, Math.floor(Number(w) || 0));
+  const height = Math.max(1, Math.floor(Number(h) || 0));
+  const r = Math.max(0, Math.min(Number(radius) || 0, Math.floor(width / 2), Math.floor(height / 2)));
+  if (r <= 0) return drawRect(image, left, top, width, height, color);
+
+  image.scan(left, top, width, height, function (px, py, idx) {
+    const cx = px < left + r ? left + r : px >= left + width - r ? left + width - r - 1 : px;
+    const cy = py < top + r ? top + r : py >= top + height - r ? top + height - r - 1 : py;
+    const dx = px - cx;
+    const dy = py - cy;
+    if ((dx * dx) + (dy * dy) <= r * r) {
+      this.bitmap.data.writeUInt32BE(color >>> 0, idx);
+    }
+  });
+}
+
+function drawLine(image, x1, y1, x2, y2, color) {
+  const sx = Number(x1 || 0);
+  const sy = Number(y1 || 0);
+  const tx = Number(x2 || 0);
+  const ty = Number(y2 || 0);
+  const steps = Math.max(1, Math.ceil(Math.max(Math.abs(tx - sx), Math.abs(ty - sy))));
+  for (let i = 0; i <= steps; i++) {
+    const x = Math.round(sx + ((tx - sx) * i / steps));
+    const y = Math.round(sy + ((ty - sy) * i / steps));
+    if (x >= 0 && y >= 0 && x < image.bitmap.width && y < image.bitmap.height) {
+      image.setPixelColor(color, x, y);
+    }
+  }
+}
+
+async function createCanvasImageTool(args, state, paint) {
+  const { Jimp, loadFont } = require('jimp');
+  const pluginPrintMain = require.resolve('@jimp/plugin-print');
+  const fontsPath = path.join(path.dirname(pluginPrintMain), 'fonts.js');
+  const fonts = require(fontsPath);
+  const width = Math.max(1, Number(args.width || 0));
+  const height = Math.max(1, Number(args.height || 0));
+  if (!width || !height) {
+    throw new Error('create_canvas_image requiere width y height');
+  }
+
+  const format = String(args.format || 'png').toLowerCase();
+  const safeFormat = ['png', 'jpg', 'jpeg', 'webp', 'bmp', 'gif', 'tiff'].includes(format) ? format : 'png';
+  const fileExt = safeFormat === 'jpeg' ? 'jpg' : safeFormat;
+  const outputPath = resolveInputPath(args.outputPath || path.join('generated', `image-${Date.now()}.${fileExt}`), state.cwd);
+
+  const allowed = await askConfirmation(state.rl, 'Crear imagen', `${width}x${height}\nFormato: ${safeFormat}\nSalida: ${outputPath}`, paint, state);
+  if (!allowed) return 'Creacion de imagen cancelada por el usuario.';
+
+  const bg = args.background && typeof args.background === 'object'
+    ? args.background.color || args.background.fill || '#ffffff'
+    : args.background || '#ffffff';
+  const image = new Jimp({ width, height, color: parseColor(bg, 0xffffffff) });
+  const elements = Array.isArray(args.elements) ? args.elements.filter(Boolean) : [];
+
+  for (const element of elements) {
+    if (!element || typeof element !== 'object') continue;
+    const type = String(element.type || 'text').toLowerCase();
+    if (type === 'rect') {
+      const color = parseColor(element.fill || element.color || '#000000', 0x000000ff);
+      if (element.radius) drawRoundRect(image, element.x || 0, element.y || 0, element.w || element.width || 0, element.h || element.height || 0, element.radius || 0, color);
+      else drawRect(image, element.x || 0, element.y || 0, element.w || element.width || 0, element.h || element.height || 0, color);
+      continue;
+    }
+    if (type === 'line') {
+      drawLine(image, element.x1 || 0, element.y1 || 0, element.x2 || 0, element.y2 || 0, parseColor(element.stroke || '#000000', 0x000000ff));
+      continue;
+    }
+    if (type === 'circle' || type === 'ellipse') {
+      const color = parseColor(element.fill || element.color || '#000000', 0x000000ff);
+      const cx = Number(element.x || 0);
+      const cy = Number(element.y || 0);
+      const rx = Math.max(1, Number(element.rx || element.r || element.radius || element.width || 0));
+      const ry = Math.max(1, Number(element.ry || element.r || element.radius || element.height || rx));
+      image.scan(0, 0, image.bitmap.width, image.bitmap.height, function (px, py, idx) {
+        const dx = (px - cx) / rx;
+        const dy = (py - cy) / ry;
+        if ((dx * dx) + (dy * dy) <= 1) {
+          this.bitmap.data.writeUInt32BE(color >>> 0, idx);
+        }
+      });
+      continue;
+    }
+    if (type === 'image') {
+      const src = element.src || element.url || element.path;
+      if (!src) continue;
+      const loaded = await Jimp.read(src.startsWith('http') || src.startsWith('data:') ? src : resolveInputPath(src, state.cwd));
+      const x = Number(element.x || 0);
+      const y = Number(element.y || 0);
+      const w = Math.max(1, Number(element.w || element.width || loaded.bitmap.width));
+      const h = Math.max(1, Number(element.h || element.height || loaded.bitmap.height));
+      const clone = loaded.clone().resize({ w, h });
+      image.composite(clone, x, y);
+      continue;
+    }
+
+    const text = String(element.text || '');
+    if (!text) continue;
+    const size = Math.max(8, Math.min(64, Number(element.fontSize || 32)));
+    const font = await loadFont(
+      size <= 8 ? fonts.SANS_8_BLACK :
+      size <= 16 ? fonts.SANS_16_BLACK :
+      size <= 32 ? fonts.SANS_32_BLACK :
+      fonts.SANS_64_BLACK,
+    );
+    image.print({ font, x: Number(element.x || 0), y: Number(element.y || 0), maxWidth: element.maxWidth ? Number(element.maxWidth) : undefined }, text);
+  }
+
+  await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
+  await image.write(outputPath);
+  return [`Imagen creada: ${outputPath}`, `Formato: ${safeFormat}`, `Tamano: ${width}x${height}`, `Elementos: ${elements.length}`].join('\\n');
+}
+
+
+async function gitSecretSetTool(args) {
+  const provider = normalizeProfileName(args.provider || '');
+  if (!provider) throw new Error('git_secret_set requiere provider');
+  if (!args.token || typeof args.token !== 'string') throw new Error('git_secret_set requiere token');
+  const saved = upsertGitSecret(provider, args);
+  return `Credencial guardada: ${getGitSecretLabel(provider, saved?.name || args.name || '')}`;
+}
+
+async function gitSecretListTool(args) {
+  const provider = normalizeProfileName(args.provider || '');
+  const name = String(args.name || '').trim();
+  const secrets = listGitSecrets();
+  const filtered = secrets.filter(secret => {
+    if (!provider) return true;
+    if (provider === 'custom') return !name || secret.key === `custom:${name}`;
+    return secret.key === provider;
+  });
+  if (!filtered.length) return 'No hay credenciales Git guardadas.';
+  return filtered.map(secret => [
+    `${secret.key}`,
+    `  username: ${secret.username || '-'}`,
+    `  apiBaseUrl: ${secret.apiBaseUrl || '-'}`,
+    `  cloneBaseUrl: ${secret.cloneBaseUrl || '-'}`,
+    `  authHeader: ${secret.authHeader || '-'}`,
+    `  token: ${secret.token}`,
+  ].join('\n')).join('\n\n');
+}
+
+async function gitSecretRemoveTool(args) {
+  const provider = normalizeProfileName(args.provider || '');
+  if (!provider) throw new Error('git_secret_remove requiere provider');
+  const name = String(args.name || '').trim();
+  const removed = removeGitSecret(provider, name);
+  return removed ? `Credencial eliminada: ${getGitSecretLabel(provider, name)}` : 'No encontre esa credencial.';
+}
+
+async function gitCloneRepoTool(args, state, paint) {
+  const repoUrl = String(args.repoUrl || '').trim();
+  if (!repoUrl) throw new Error('git_clone_repo requiere repoUrl');
+  const provider = normalizeProfileName(args.provider || '');
+  const name = String(args.name || '').trim();
+  const profile = provider ? resolveGitProfile(provider, name) : null;
+  const finalUrl = buildCloneUrl(repoUrl, profile || {});
+  const destination = args.destination ? resolveInputPath(args.destination, state.cwd) : '';
+  const timeoutMs = Math.max(1000, Number.isFinite(Number(args.timeoutMs)) ? Number(args.timeoutMs) : 10 * 60 * 1000);
+
+  const allowed = await askConfirmation(state.rl, 'Clonar repositorio', [
+    repoUrl,
+    profile ? `Provider: ${provider}${name ? ` (${name})` : ''}` : 'Provider: direct',
+    destination ? `Destino: ${destination}` : null,
+    `Timeout: ${timeoutMs}ms`,
+  ].filter(Boolean).join('\n'), paint, state);
+  if (!allowed) return 'Clonado cancelado por el usuario.';
+
+  const result = await runProcess('git', ['clone', ...(args.branch ? ['--branch', String(args.branch)] : []), finalUrl, ...(destination ? [destination] : [])], { cwd: state.cwd, timeoutMs });
+  const lines = [`Exit code: ${result.code}`];
+  if (result.timedOut) lines.push('Timeout: el clon fue detenido por tiempo.');
+  if (result.stdout.trim()) lines.push(`STDOUT:\n${result.stdout.trim()}`);
+  if (result.stderr.trim()) lines.push(`STDERR:\n${result.stderr.trim()}`);
+  return lines.join('\n\n');
+}
+
+async function gitApiRequestTool(args, state, paint) {
+  const provider = normalizeProfileName(args.provider || '');
+  if (!provider) throw new Error('git_api_request requiere provider');
+  const pathValue = String(args.path || '').trim();
+  if (!pathValue) throw new Error('git_api_request requiere path');
+  const name = String(args.name || '').trim();
+  const profile = resolveGitProfile(provider, name);
+  if (!profile) throw new Error(`No hay credenciales para ${provider}${provider === 'custom' && name ? `:${name}` : ''}`);
+  const baseUrl = getApiBaseUrl(provider, profile);
+  if (!baseUrl) throw new Error(`No hay apiBaseUrl para ${provider}`);
+  const url = `${baseUrl.replace(/\/+$/, '')}/${pathValue.replace(/^\/+/, '')}`;
+  const timeoutMs = Math.max(1000, Number.isFinite(Number(args.timeoutMs)) ? Number(args.timeoutMs) : 15000);
+  const method = String(args.method || 'GET').toUpperCase();
+  const headers = buildApiHeaders(provider, profile, args.headers && typeof args.headers === 'object' ? args.headers : {});
+
+  const allowed = await askConfirmation(state.rl, 'Git API request', `${method} ${url}\nTimeout: ${timeoutMs}ms`, paint, state);
+  if (!allowed) return 'Request cancelado por el usuario.';
+
+  const axios = require('axios');
+  const response = await axios({
+    url,
+    method,
+    headers: {
+      'User-Agent': 'Zyn/1.0',
+      Accept: 'application/json, text/plain, */*',
+      ...headers,
+    },
+    data: args.body && typeof args.body === 'object' ? args.body : args.body,
+    timeout: timeoutMs,
+    responseType: 'text',
+    validateStatus: () => true,
+  });
+
+  const text = typeof response.data === 'string' ? response.data : JSON.stringify(response.data, null, 2);
+  return `Status: ${response.status}\n\n${text}`;
+}

package/src/tui/app.mjs

@@ -17,9 +17,17 @@ const {
   DEFAULT_MODEL_KEY,
   MODELS,
 } = require('../config');
+const { normalizeLanguage } = require('../i18n');
 
 const h = React.createElement;
+function getTuiLang() {
+  return normalizeLanguage(global.__zynCurrentLanguage || 'en');
+}
+function uiText(en, es) {
+  return getTuiLang() === 'es' ? es : en;
+}
 const MAX_THINKING_LINES = 20;
+const MAX_PASTE_PREVIEW = 200;
 const SPIN_MS = 80;
 
 const SPIN_FRAMES = ['\u280b', '\u2819', '\u2839', '\u2838', '\u283c', '\u2834', '\u2826', '\u2827', '\u2807', '\u280f'];
@@ -372,7 +380,7 @@ function Banner({ model, resumed, width, cwd }) {
     return s + ' '.repeat(Math.max(0, inner - s.length));
   };
 
-  const sessionLabel = resumed ? 'sesion reanudada' : 'sesion nueva';
+  const sessionLabel = resumed ? uiText('session resumed', 'sesion reanudada') : uiText('new session', 'sesion nueva');
   const cwdShort = cwd && cwd.length > inner - 6 ? '...' + cwd.slice(-(inner - 9)) : (cwd || '.');
 
   return h(Box, { flexDirection: 'column', paddingTop: 1, paddingBottom: 0 },
@@ -429,10 +437,15 @@ function EventLine({ kind, title, detail }) {
   };
   const { sym, color } = cfg[kind] || cfg.info;
 
-  return h(Box, { paddingLeft: 5, gap: 1 },
-    h(Text, { color }, sym),
-    h(Text, { color: kind === 'tool' ? T.textDim : T.textMuted }, title),
-    detail ? h(Text, { color: T.textGhost }, detail) : null,
+  const compactTitle = String(title || '').replace(/\s{2,}/g, ' ').trim();
+  const compactDetail = String(detail || '').replace(/\s{2,}/g, ' ').trim();
+
+  return h(Box, { paddingLeft: 3, flexDirection: 'column' },
+    h(Box, { gap: 1 },
+      h(Text, { color }, sym),
+      h(Text, { color: kind === 'tool' ? T.textDim : T.textMuted, wrap: 'wrap' }, compactTitle),
+    ),
+    compactDetail ? h(Box, { paddingLeft: 2 }, h(Text, { color: T.textGhost, wrap: 'wrap' }, compactDetail)) : null,
   );
 }
 
@@ -441,7 +454,7 @@ function UserMessage({ text }) {
     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 }, 'You'),
+        h(Text, { color: T.textDim, bold: true }, uiText('You', 'Tú')),
       ),
       h(Box, { paddingLeft: 2 },
         h(Text, { color: T.text, wrap: 'wrap' }, text),
@@ -465,17 +478,17 @@ function ThinkingBlock({ text, elapsed, live, width }) {
   const pulseChar = live ? SPIN_FRAMES[Math.floor(Date.now() / SPIN_MS) % SPIN_FRAMES.length] : '\u25d0';
 
   const label = live
-    ? pulseChar + '  Pensando...'
-    : '\u25d0  Penso ' + elapsed + 's';
+    ? pulseChar + '  ' + uiText('Thinking...', 'Pensando...')
+    : '\u25d0  ' + uiText('Thought for ', 'Pensó durante ') + elapsed + 's';
 
-  return h(Box, { flexDirection: 'column', paddingLeft: 5, marginTop: 1 },
+  return h(Box, { flexDirection: 'column', paddingLeft: 3, marginTop: 1 },
     h(Text, { color: T.textGhost }, label),
     lines.length > 0
-      ? h(Box, { flexDirection: 'column', paddingLeft: 2 },
+      ? h(Box, { flexDirection: 'column', paddingLeft: 1 },
           ...lines.map((line, i) =>
             h(Text, { key: String(i), color: T.textInvis, wrap: 'wrap' }, line),
           ),
-          more > 0 ? h(Text, { color: T.textGhost }, '\u00b7\u00b7\u00b7 ' + more + ' lineas mas') : null,
+          more > 0 ? h(Text, { color: T.textGhost }, '\u00b7\u00b7\u00b7 ' + more + ' ' + uiText('more lines', 'líneas más')) : null,
         )
       : null,
   );
@@ -534,10 +547,10 @@ function ConfirmBar({ title, detail }) {
       : null,
     h(Box, { marginTop: 0, paddingLeft: 2, gap: 2 },
       h(Text, { color: T.green, bold: true }, '[y]'),
-      h(Text, { color: T.textMuted }, 'permitir'),
+      h(Text, { color: T.textMuted }, uiText('allow', 'permitir')),
       h(Text, { color: T.textInvis }, '\u00b7'),
       h(Text, { color: T.red, bold: true }, '[n]'),
-      h(Text, { color: T.textMuted }, 'denegar'),
+      h(Text, { color: T.textMuted }, uiText('deny', 'denegar')),
     ),
   );
 }
@@ -566,13 +579,13 @@ function StatusBar({ model, processing, width, turnCount }) {
           ? h(Text, { color: T.accentSoft }, SPIN_FRAMES[frame])
           : null,
         turnCount > 0
-          ? h(Text, { color: T.textInvis }, '\u00b7 ' + turnCount + (turnCount === 1 ? ' turno' : ' turnos'))
+          ? h(Text, { color: T.textInvis }, '\u00b7 ' + turnCount + ' ' + uiText(turnCount === 1 ? 'turn' : 'turns', turnCount === 1 ? 'turno' : 'turnos'))
           : null,
       ),
       h(Box, { gap: 1 },
         h(Text, { color: T.textInvis }, '/help'),
         h(Text, { color: T.textInvis }, '\u00b7'),
-        h(Text, { color: T.textInvis }, 'esc salir'),
+        h(Text, { color: T.textInvis }, uiText('esc exit', 'esc salir')),
       ),
     ),
   );
@@ -709,8 +722,10 @@ function InputBar({ onSubmit, processing }) {
     }
 
     if (input && !key.ctrl && !key.meta) {
-      setValue(v => v.slice(0, cursor) + input + v.slice(cursor));
-      setCursor(c => c + input.length);
+      const normalizedInput = input.replace(/\r\n/g, '\n');
+      const safeInput = normalizedInput.includes('\n') ? normalizedInput.replace(/\n/g, ' ') : normalizedInput;
+      setValue(v => v.slice(0, cursor) + safeInput + v.slice(cursor));
+      setCursor(c => c + safeInput.length);
       setSuggestIdx(0);
     }
   });
@@ -721,7 +736,7 @@ function InputBar({ onSubmit, processing }) {
   const after = value.slice(cursor + 1);
 
   const promptColor = processing ? T.amber : T.accent;
-  const placeholder = processing ? ' En cola — escribe y se procesará después...' : ' Escribe un mensaje...';
+  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...');
 
   const inputLine = h(Box, { paddingLeft: 3, paddingRight: 3, paddingTop: 0, paddingBottom: 0, marginTop: 1 },
     h(Text, { color: promptColor }, processing ? '\u{1F4E9} ' : '\u276f '),
@@ -749,7 +764,7 @@ function InputBar({ onSubmit, processing }) {
     inputLine,
     h(Box, { flexDirection: 'column', paddingLeft: 5, marginTop: 0 },
       hasMore && windowStart > 0
-        ? h(Text, { color: T.textInvis }, '  \u2191 mas')
+        ? h(Text, { color: T.textInvis }, '  \u2191 ' + uiText('more', 'más'))
         : null,
       ...visible.map((cmd, i) => {
         const realIdx = windowStart + i;
@@ -766,10 +781,10 @@ function InputBar({ onSubmit, processing }) {
         );
       }),
       hasMore && windowStart + maxVisible < suggestions.length
-        ? h(Text, { color: T.textInvis }, '  \u2193 mas')
+        ? h(Text, { color: T.textInvis }, '  \u2193 ' + uiText('more', 'más'))
         : null,
       h(Box, { paddingTop: 0 },
-        h(Text, { color: T.textInvis }, 'Tab completar \u00b7 \u2191\u2193 navegar'),
+        h(Text, { color: T.textInvis }, uiText('Tab complete · ↑↓ navigate', 'Tab completar · ↑↓ navegar')),
       ),
     ),
   );
@@ -777,19 +792,20 @@ function InputBar({ onSubmit, processing }) {
 
 function App({ store, state, onSubmit }) {
   useStore(store);
+  global.__zynCurrentLanguage = state?.language || 'en';
   const { exit } = useApp();
   const { width } = useDimensions();
 
   const modelKey   = state?.activeModel || DEFAULT_MODEL_KEY;
   const modelLabel = state?.concuerdo
-    ? 'Concuerdo · ' + Object.values(MODELS).map(m => m.label).join(', ')
+    ? uiText('Concord · ', 'Concuerdo · ') + Object.values(MODELS).map(m => m.label).join(', ')
     : (MODELS[modelKey]?.label || modelKey).toLowerCase();
 
   const handleInput = useCallback((text) => {
     if (text === '/exit' || text === '/quit') {
       if (store.processing) {
         store.pendingExit = true;
-        store.addEvent('info', 'saliendo al terminar el turno actual');
+        store.addEvent('info', uiText('exiting after current turn', 'saliendo al terminar el turno actual'));
         return;
       }
       exit();
@@ -809,10 +825,10 @@ function App({ store, state, onSubmit }) {
             state.abortCurrentTurn();
           }
           store.pendingExit = false;
-          store.addEvent('warn', 'agente detenido', 'Interrumpido con ESC x2');
+          store.addEvent('warn', uiText('agent stopped', 'agente detenido'), uiText('Interrupted with ESC x2', 'Interrumpido con ESC x2'));
         } else {
           store.lastEscapeAt = now;
-          store.addEvent('info', 'pulsa ESC otra vez', 'para detener el agente');
+          store.addEvent('info', uiText('press ESC again', 'pulsa ESC otra vez'), uiText('to stop the agent', 'para detener el agente'));
         }
         return;
       }
@@ -914,7 +930,7 @@ export async function startTUI(options = {}) {
   const processInput = async (input) => {
     if (input === '/exit' || input === '/quit') {
       store.pendingExit = true;
-      store.addEvent('info', 'hasta luego');
+      store.addEvent('info', uiText('bye', 'hasta luego'));
       return;
     }
 
@@ -942,9 +958,9 @@ export async function startTUI(options = {}) {
           const clean = lines.filter(l => l.trim()).join('\n');
           if (clean) store.addItem({ type: 'system', text: clean });
         }
-        if (!handled) store.addEvent('warn', 'comando no reconocido', input);
+        if (!handled) store.addEvent('warn', uiText('command not recognized', 'comando no reconocido'), input);
       } catch (err) {
-        store.addEvent('error', 'error', err.message);
+        store.addEvent('error', uiText('error', 'error'), err.message);
       } finally {
         console.log = origLog;
         console.error = origError;
@@ -983,6 +999,13 @@ export async function startTUI(options = {}) {
   let appInstance = null;
 
   const handleSubmit = async (input) => {
+    if (typeof input === 'string' && input.length > MAX_PASTE_PREVIEW) {
+      store.addEvent(
+        'info',
+        `[ ${uiText('Pasted Text', 'Texto pegado')} of ${input.length} ${uiText('Characters', 'Caracteres')} ]`,
+        input.slice(0, MAX_PASTE_PREVIEW) + '...'
+      );
+    }
     if (input.startsWith('/') && store.processing) {
       await processInput(input);
       return;

package/src/utils/secretStorage.js

@@ -0,0 +1,223 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const HOME_DIR = os.homedir() || '/root';
+const DATA_ROOT = path.join(HOME_DIR, '.zyn');
+const GIT_SECRETS_FILE = path.join(DATA_ROOT, 'git-secrets.json');
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function loadGitSecrets() {
+  const raw = readJson(GIT_SECRETS_FILE);
+  if (!raw || typeof raw !== 'object') {
+    return { github: null, gitlab: null, custom: {} };
+  }
+
+  return {
+    github: raw.github || null,
+    gitlab: raw.gitlab || null,
+    custom: raw.custom && typeof raw.custom === 'object' ? raw.custom : {},
+  };
+}
+
+function saveGitSecrets(data) {
+  writeJson(GIT_SECRETS_FILE, {
+    github: data.github || null,
+    gitlab: data.gitlab || null,
+    custom: data.custom && typeof data.custom === 'object' ? data.custom : {},
+    updatedAt: new Date().toISOString(),
+  });
+}
+
+function normalizeProfileName(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function normalizeBaseUrl(value) {
+  return String(value || '').trim().replace(/\/+$/, '');
+}
+
+function sanitizeSecretConfig(input = {}) {
+  const output = {};
+  if (input.token !== undefined) output.token = String(input.token || '').trim();
+  if (input.username !== undefined) output.username = String(input.username || '').trim();
+  if (input.apiBaseUrl !== undefined) output.apiBaseUrl = normalizeBaseUrl(input.apiBaseUrl);
+  if (input.cloneBaseUrl !== undefined) output.cloneBaseUrl = normalizeBaseUrl(input.cloneBaseUrl);
+  if (input.authHeader !== undefined) output.authHeader = String(input.authHeader || '').trim();
+  if (input.name !== undefined) output.name = String(input.name || '').trim();
+  return output;
+}
+
+function upsertGitSecret(provider, input = {}) {
+  const key = normalizeProfileName(provider);
+  const config = sanitizeSecretConfig(input);
+  const store = loadGitSecrets();
+
+  if (key === 'github') {
+    store.github = {
+      ...store.github,
+      ...config,
+      provider: 'github',
+      apiBaseUrl: config.apiBaseUrl || store.github?.apiBaseUrl || 'https://api.github.com',
+      cloneBaseUrl: config.cloneBaseUrl || store.github?.cloneBaseUrl || 'https://github.com',
+      updatedAt: new Date().toISOString(),
+    };
+    saveGitSecrets(store);
+    return store.github;
+  }
+
+  if (key === 'gitlab') {
+    store.gitlab = {
+      ...store.gitlab,
+      ...config,
+      provider: 'gitlab',
+      apiBaseUrl: config.apiBaseUrl || store.gitlab?.apiBaseUrl || 'https://gitlab.com/api/v4',
+      cloneBaseUrl: config.cloneBaseUrl || store.gitlab?.cloneBaseUrl || 'https://gitlab.com',
+      updatedAt: new Date().toISOString(),
+    };
+    saveGitSecrets(store);
+    return store.gitlab;
+  }
+
+  const name = config.name || key || 'custom';
+  store.custom[name] = {
+    ...store.custom[name],
+    ...config,
+    provider: 'custom',
+    name,
+    updatedAt: new Date().toISOString(),
+  };
+  saveGitSecrets(store);
+  return store.custom[name];
+}
+
+function removeGitSecret(provider, name = '') {
+  const key = normalizeProfileName(provider);
+  const store = loadGitSecrets();
+  if (key === 'github') {
+    store.github = null;
+    saveGitSecrets(store);
+    return true;
+  }
+  if (key === 'gitlab') {
+    store.gitlab = null;
+    saveGitSecrets(store);
+    return true;
+  }
+  const customName = String(name || '').trim();
+  if (!customName) return false;
+  if (store.custom[customName]) {
+    delete store.custom[customName];
+    saveGitSecrets(store);
+    return true;
+  }
+  return false;
+}
+
+function listGitSecrets() {
+  const store = loadGitSecrets();
+  const output = [];
+  if (store.github) output.push({ key: 'github', ...store.github, token: '[set]' });
+  if (store.gitlab) output.push({ key: 'gitlab', ...store.gitlab, token: '[set]' });
+  for (const [name, config] of Object.entries(store.custom || {})) {
+    output.push({ key: `custom:${name}`, ...config, token: '[set]' });
+  }
+  return output;
+}
+
+function getGitSecret(provider, name = '') {
+  const key = normalizeProfileName(provider);
+  const store = loadGitSecrets();
+  if (key === 'github') return store.github || null;
+  if (key === 'gitlab') return store.gitlab || null;
+  const customName = String(name || '').trim();
+  if (!customName) return null;
+  return store.custom[customName] || null;
+}
+
+function resolveGitProfile(provider, name = '') {
+  const key = normalizeProfileName(provider);
+  if (key === 'github' || key === 'gitlab') return getGitSecret(key);
+  return getGitSecret('custom', name);
+}
+
+function buildCloneUrl(repoUrl, profile = {}) {
+  const raw = String(repoUrl || '').trim();
+  if (!raw) throw new Error('Missing repo URL');
+  if (!profile?.token) return raw;
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return raw;
+  }
+
+  const host = parsed.hostname.toLowerCase();
+  if (host.includes('github.com')) {
+    parsed.username = 'x-access-token';
+    parsed.password = profile.token;
+    return parsed.toString();
+  }
+
+  if (host.includes('gitlab.com')) {
+    parsed.username = profile.username || 'oauth2';
+    parsed.password = profile.token;
+    return parsed.toString();
+  }
+
+  parsed.username = profile.username || 'oauth2';
+  parsed.password = profile.token;
+  return parsed.toString();
+}
+
+function getApiBaseUrl(provider, profile = {}) {
+  const key = normalizeProfileName(provider);
+  if (profile?.apiBaseUrl) return normalizeBaseUrl(profile.apiBaseUrl);
+  if (key === 'github') return 'https://api.github.com';
+  if (key === 'gitlab') return 'https://gitlab.com/api/v4';
+  return '';
+}
+
+function buildApiHeaders(provider, profile = {}, extraHeaders = {}) {
+  const key = normalizeProfileName(provider);
+  const token = profile?.token || '';
+  const headers = { ...extraHeaders };
+
+  if (token) {
+    if (key === 'gitlab') {
+      headers['PRIVATE-TOKEN'] = token;
+    } else if (profile?.authHeader) {
+      headers[profile.authHeader] = token;
+    } else {
+      headers.Authorization = `Bearer ${token}`;
+    }
+  }
+
+  return headers;
+}
+
+module.exports = {
+  buildApiHeaders,
+  buildCloneUrl,
+  getApiBaseUrl,
+  getGitSecret,
+  listGitSecrets,
+  loadGitSecrets,
+  normalizeProfileName,
+  removeGitSecret,
+  resolveGitProfile,
+  saveGitSecrets,
+  upsertGitSecret,
+};

package/src/utils/taskStorage.js

@@ -0,0 +1,192 @@
+const fs = require('fs');
+const path = require('path');
+const { TASKS_FILE, USER_DATA_ROOT } = require('../config');
+
+const fsp = fs.promises;
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function loadTaskStore() {
+  const raw = readJson(TASKS_FILE);
+  if (!raw || typeof raw !== 'object') {
+    return { version: 1, tasks: [] };
+  }
+  if (Array.isArray(raw)) {
+    return { version: 1, tasks: raw };
+  }
+  return {
+    version: Number(raw.version || 1),
+    tasks: Array.isArray(raw.tasks) ? raw.tasks : [],
+  };
+}
+
+function saveTaskStore(store) {
+  writeJson(TASKS_FILE, {
+    version: 1,
+    tasks: Array.isArray(store.tasks) ? store.tasks : [],
+    updatedAt: new Date().toISOString(),
+  });
+}
+
+function normalizeTaskText(text) {
+  return String(text || '').trim().replace(/\s+/g, ' ');
+}
+
+function makeTaskId() {
+  return `task_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`;
+}
+
+function enrichTask(task) {
+  return {
+    id: task.id,
+    title: normalizeTaskText(task.title),
+    description: normalizeTaskText(task.description || ''),
+    status: task.status || 'todo',
+    priority: task.priority || 'medium',
+    createdAt: task.createdAt || new Date().toISOString(),
+    updatedAt: task.updatedAt || task.createdAt || new Date().toISOString(),
+    dueAt: task.dueAt || null,
+    tags: Array.isArray(task.tags) ? task.tags : [],
+    source: task.source || 'manual',
+    sessionId: task.sessionId || null,
+    notes: normalizeTaskText(task.notes || ''),
+  };
+}
+
+function listTasks(options = {}) {
+  const { status, includeDone = true } = options;
+  const store = loadTaskStore();
+  return store.tasks
+    .map(enrichTask)
+    .filter(task => (includeDone ? true : task.status !== 'done'))
+    .filter(task => (status ? task.status === status : true))
+    .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+function createTask(input = {}) {
+  const store = loadTaskStore();
+  const title = normalizeTaskText(input.title || input.text || input.description);
+  if (!title) {
+    throw new Error('task title requerido');
+  }
+
+  const now = new Date().toISOString();
+  const task = enrichTask({
+    id: makeTaskId(),
+    title,
+    description: input.description || '',
+    status: input.status || 'todo',
+    priority: input.priority || 'medium',
+    createdAt: now,
+    updatedAt: now,
+    dueAt: input.dueAt || null,
+    tags: input.tags || [],
+    source: input.source || 'manual',
+    sessionId: input.sessionId || null,
+    notes: input.notes || '',
+  });
+
+  store.tasks.push(task);
+  saveTaskStore(store);
+  return task;
+}
+
+function findTaskIndex(store, idOrTitle) {
+  const needle = normalizeTaskText(idOrTitle).toLowerCase();
+  if (!needle) return -1;
+  return store.tasks.findIndex(task => {
+    const idMatch = String(task.id || '').toLowerCase() === needle;
+    const titleMatch = String(task.title || '').toLowerCase() === needle;
+    return idMatch || titleMatch;
+  });
+}
+
+function updateTask(idOrTitle, updates = {}) {
+  const store = loadTaskStore();
+  const idx = findTaskIndex(store, idOrTitle);
+  if (idx === -1) {
+    throw new Error(`No existe la tarea: ${idOrTitle}`);
+  }
+
+  const current = store.tasks[idx];
+  const next = enrichTask({
+    ...current,
+    ...updates,
+    title: updates.title ?? current.title,
+    description: updates.description ?? current.description,
+    priority: updates.priority ?? current.priority,
+    status: updates.status ?? current.status,
+    dueAt: updates.dueAt === undefined ? current.dueAt : updates.dueAt,
+    tags: updates.tags ?? current.tags,
+    notes: updates.notes ?? current.notes,
+    updatedAt: new Date().toISOString(),
+  });
+
+  store.tasks[idx] = next;
+  saveTaskStore(store);
+  return next;
+}
+
+function completeTask(idOrTitle, notes = '') {
+  return updateTask(idOrTitle, {
+    status: 'done',
+    notes,
+  });
+}
+
+function deleteTask(idOrTitle) {
+  const store = loadTaskStore();
+  const idx = findTaskIndex(store, idOrTitle);
+  if (idx === -1) {
+    throw new Error(`No existe la tarea: ${idOrTitle}`);
+  }
+  const [removed] = store.tasks.splice(idx, 1);
+  saveTaskStore(store);
+  return enrichTask(removed);
+}
+
+function clearTasks() {
+  saveTaskStore({ tasks: [] });
+}
+
+function formatTask(task) {
+  const state = task.status === 'done' ? '✓' : task.status === 'doing' ? '▶' : '·';
+  const due = task.dueAt ? ` · due ${task.dueAt}` : '';
+  const priority = task.priority ? ` · ${task.priority}` : '';
+  const desc = task.description ? `\n    ${task.description}` : '';
+  const notes = task.notes ? `\n    notas: ${task.notes}` : '';
+  return `${state} ${task.id} :: ${task.title}${priority}${due}${desc}${notes}`;
+}
+
+function summarizeTasks(tasks = listTasks()) {
+  const lines = [`Tasks: ${tasks.length}`];
+  for (const task of tasks.slice(0, 20)) {
+    lines.push(formatTask(task));
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  clearTasks,
+  completeTask,
+  createTask,
+  deleteTask,
+  formatTask,
+  listTasks,
+  loadTaskStore,
+  saveTaskStore,
+  summarizeTasks,
+  updateTask,
+  USER_DATA_ROOT,
+};

package/src/web/webAgent.js

@@ -599,7 +599,7 @@ async function executeTool(tool, args, ctx) {
   }
 }
 
-async function runConcuerdo(primaryContent, primaryKey, modelMessages, onEvent, isAborted) {
+async function runConcuerdo(primaryContent, primaryKey, modelMessages, onEvent, isAborted, language = 'en') {
   const otherKeys = Object.keys(MODELS).filter(k => k !== primaryKey);
   if (!otherKeys.length) return null;
 
@@ -1029,7 +1029,7 @@ async function runWebAgent({ chatData, user, onEvent, isAborted }) {
     // ── Final response ──
     if (parsed.type === 'final') {
       if (group) {
-        const synthResult = await runConcuerdo(parsed.content, modelKey, modelMessages, onEvent, isAborted);
+        const synthResult = await runConcuerdo(parsed.content, modelKey, modelMessages, onEvent, isAborted, language);
         if (synthResult) {
           chatData.messages.push({ role: 'assistant', content: synthResult, ts: Date.now() });
           store.saveChat(chatData);