@danieltmn/tamnora 0.9.3 → 0.9.5

package/harness/packages/server/public/styles.css

@@ -627,6 +627,17 @@ body.resizing * { cursor: col-resize !important; }
   font: 600 12px var(--sans);
 }
 .tool-card > .tool-audio-btn:hover { background: var(--theirs); }
+.tool-card > .tool-shot {
+  display: block;
+  max-width: calc(100% - 28px);
+  max-height: 420px;
+  width: auto;
+  margin: 6px 0 4px 18px;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  cursor: zoom-in;
+  background: #fff;
+}
 
 /* Reproductor único de audio (narración, speak, resumen): visible y detenible. */
 .audio-player {
@@ -1620,3 +1631,40 @@ dialog.modal::backdrop { background: rgba(24, 22, 16, 0.55); backdrop-filter: bl
 .modal-card { display: flex; flex-direction: column; gap: 12px; padding: 20px; }
 .modal-card h3 { margin: 0; font: 700 17px var(--serif); letter-spacing: -0.02em; }
 .row .spacer { flex: 1; }
+
+/* update banner ----------------------------------------------------------- */
+.update-banner {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 8px 16px;
+  background: var(--accent-soft);
+  border-bottom: 1px solid var(--border);
+  color: var(--text);
+  font: 500 13px var(--sans, inherit);
+}
+.update-banner[hidden] { display: none; }
+.update-banner-icon { color: var(--accent); flex: 0 0 auto; }
+.update-banner-text { flex: 1; min-width: 0; }
+.update-banner-actions { display: flex; gap: 8px; flex: 0 0 auto; }
+.update-banner .btn { padding: 4px 12px; font-size: 12px; }
+.brand .ver.has-update { color: var(--accent); cursor: help; }
+.brand .ver.has-update::after { content: " ⬆"; }
+
+/* advisor card ------------------------------------------------------------ */
+.advisor-card {
+  margin: 10px 0;
+  padding: 10px 14px;
+  border-left: 3px solid var(--accent);
+  border-radius: 8px;
+  background: var(--accent-soft);
+}
+.advisor-head { display: flex; align-items: center; gap: 8px; margin-bottom: 4px; }
+.advisor-glyph { color: var(--accent); font-size: 13px; line-height: 1; }
+.advisor-title { font: 600 10px var(--mono); letter-spacing: 0.08em; text-transform: uppercase; color: var(--muted); }
+.advisor-text { color: var(--text); line-height: 1.5; }
+.advisor-code { border-left-color: var(--warn); }
+.advisor-code .advisor-glyph { color: var(--warn); }
+
+.brand .ver.ver-action { cursor: pointer; }
+.brand .ver.ver-action:hover { color: var(--accent); }

package/harness/packages/server/src/lib/advisor.js

@@ -0,0 +1,177 @@
+// Asesor tipo Jarvis: una capa de comentario sobre el run activo. Mira lo que
+// el agente hizo (pedido, respuesta, herramientas y diffs), lo interpreta con
+// una llamada corta al modelo y decide si vale la pena decir algo. NO lee la
+// respuesta del agente: solo agrega alertas de codigo, explicaciones o consejos.
+//
+// La salida es JSON estricto para poder decidir el silencio: si el modelo no
+// tiene nada que aportar, no habla ni deja tarjeta.
+
+import { summarizeToolCall, extractJson } from './core.js';
+
+export const DEFAULT_ADVISOR = {
+  enabled: false,
+  code: true,
+  explain: true,
+  advice: true,
+  notes: '',
+  maxWords: 40,
+};
+
+const KINDS = new Set(['code', 'explain', 'advice']);
+const MAX_PROMPT_CHARS = 8000;
+const MAX_DIFF_CHARS = 2500;
+
+/** Config efectiva: lo guardado en app.json (la casa) sobre los defaults. */
+export function resolveAdvisor(app) {
+  const saved = app?.advisor && typeof app.advisor === 'object' ? app.advisor : {};
+  const maxWords = Number(saved.maxWords);
+  return {
+    enabled: saved.enabled === true,
+    code: saved.code !== false,
+    explain: saved.explain !== false,
+    advice: saved.advice !== false,
+    notes: typeof saved.notes === 'string' ? saved.notes.slice(0, 2000) : '',
+    maxWords: Number.isFinite(maxWords)
+      ? Math.min(Math.max(Math.round(maxWords), 10), 120)
+      : DEFAULT_ADVISOR.maxWords,
+  };
+}
+
+/** Gate barato: sin herramientas ni una respuesta larga no hay nada que mirar. */
+export function advisorShouldRun({ toolCalls = 0, answer = '' } = {}) {
+  return Number(toolCalls) > 0 || String(answer ?? '').length > 200;
+}
+
+function parseArgs(call) {
+  try {
+    return JSON.parse(call?.function?.arguments ?? call?.arguments ?? '{}') ?? {};
+  } catch {
+    return {};
+  }
+}
+
+/** Tool-calls de los mensajes del turno como `nombre: resumen` (deduplicado, acotado). */
+export function collectToolSummary(messages = [], limit = 40) {
+  const out = [];
+  const seen = new Set();
+  for (const message of messages) {
+    if (message.role !== 'assistant') continue;
+    for (const call of message.tool_calls ?? []) {
+      const name = call.function?.name ?? call.name ?? '';
+      if (!name) continue;
+      const line = `${name}: ${summarizeToolCall(name, parseArgs(call))}`;
+      if (seen.has(line)) continue;
+      seen.add(line);
+      out.push(line);
+      if (out.length >= limit) return out;
+    }
+  }
+  return out;
+}
+
+/** Archivos tocados por write/edit con su diff, tal como lo devolvio la tool. */
+export function collectChangedFiles(messages = []) {
+  const calls = new Map();
+  for (const message of messages) {
+    if (message.role !== 'assistant') continue;
+    for (const call of message.tool_calls ?? []) {
+      const name = call.function?.name ?? call.name;
+      if (name !== 'write' && name !== 'edit') continue;
+      const id = call.id ?? call.tool_call_id;
+      if (id) calls.set(id, { name, path: parseArgs(call).path ?? '' });
+    }
+  }
+  const files = [];
+  for (const message of messages) {
+    if (message.role !== 'tool') continue;
+    const call = calls.get(message.tool_call_id);
+    if (!call) continue;
+    const content = typeof message.content === 'string' ? message.content : '';
+    files.push({ path: call.path || 'archivo', diff: content.slice(0, MAX_DIFF_CHARS) });
+  }
+  return files;
+}
+
+function focusLines(options) {
+  const lines = [];
+  if (options.code) lines.push('- alertar de un problema real en el codigo (bug, riesgo, secreto expuesto, inconsistencia)');
+  if (options.explain) lines.push('- explicar un proceso o decision que quedo poco clara');
+  if (options.advice) lines.push('- dar un consejo concreto y accionable');
+  if (!lines.length) lines.push('- aportar algo util que el agente no haya dicho');
+  return lines.join('\n');
+}
+
+/** System + user para la consulta al asesor (expuestos para test). */
+export function buildAdvisorPrompt({ userInput = '', answer = '', toolSummary = [], changedFiles = [], options = {} } = {}) {
+  const maxWords = options.maxWords ?? DEFAULT_ADVISOR.maxWords;
+  const system =
+    'Sos el asesor personal del usuario dentro de Tamnora, al estilo de Jarvis.\n' +
+    'Recibis lo que el agente hizo en el ultimo turno: el pedido del usuario, su respuesta\n' +
+    'final, las herramientas que uso y los diffs de los archivos que toco.\n\n' +
+    'Tu trabajo NO es resumir ni repetir la respuesta del agente: el usuario ya la esta\n' +
+    'viendo. Solo aportas algo que el agente no dijo. Enfocate en:\n' +
+    `${focusLines(options)}\n\n` +
+    'Hablale al usuario en segunda persona, breve (' +
+    `${maxWords} palabras como maximo), en espanol, sin markdown ni listas. Si no hay nada\n` +
+    'que valga la pena decir, no hables.\n' +
+    (options.notes ? `\nInstrucciones del usuario: ${options.notes}\n` : '') +
+    '\nResponde SOLO con JSON: {"speak": true|false, "kind": "code|explain|advice", "text": "..."}';
+
+  const parts = [`PEDIDO DEL USUARIO:\n${userInput || '(sin texto)'}`];
+  parts.push(`RESPUESTA FINAL DEL AGENTE:\n${answer || '(sin respuesta)'}`);
+  if (toolSummary.length) parts.push(`HERRAMIENTAS USADAS:\n${toolSummary.map((t) => `- ${t}`).join('\n')}`);
+  if (changedFiles.length) {
+    const files = changedFiles.map((f) => `### ${f.path}\n${f.diff}`).join('\n\n');
+    parts.push(`ARCHIVOS MODIFICADOS (diffs):\n${files}`);
+  }
+
+  return { system, user: parts.join('\n\n').slice(0, MAX_PROMPT_CHARS) };
+}
+
+function truncateWords(text, maxWords) {
+  const words = String(text ?? '').replace(/\s+/g, ' ').trim().split(' ').filter(Boolean);
+  if (words.length <= maxWords) return words.join(' ');
+  return `${words.slice(0, maxWords).join(' ')}…`;
+}
+
+/**
+ * Consulta unica al modelo (mismo patron que el juez de eval). Devuelve
+ * `{ speak, kind, text }` o `null` si no se pudo interpretar. Nunca tira: un
+ * asesor roto no debe romper el run.
+ */
+export async function consultAdvisor({
+  provider,
+  config,
+  model,
+  signal,
+  userInput,
+  answer,
+  messages = [],
+  options = {},
+} = {}) {
+  const todo = collectToolSummary(messages);
+  const changedFiles = collectChangedFiles(messages);
+  const { system, user } = buildAdvisorPrompt({ userInput, answer, toolSummary: todo, changedFiles, options });
+  const maxWords = options.maxWords ?? DEFAULT_ADVISOR.maxWords;
+
+  try {
+    const result = await provider.streamChat(config, {
+      model,
+      messages: [
+        { role: 'system', content: system },
+        { role: 'user', content: user },
+      ],
+      tools: [],
+      signal,
+      onEvent: () => {},
+    });
+    const { value, error } = extractJson(result?.content ?? '');
+    if (error || !value || typeof value !== 'object') return null;
+    const kind = KINDS.has(value.kind) ? value.kind : 'advice';
+    const text = truncateWords(value.text, maxWords);
+    if (value.speak !== true || !text) return { speak: false, kind, text: '' };
+    return { speak: true, kind, text };
+  } catch {
+    return null;
+  }
+}

package/harness/packages/server/src/lib/agentRun.js

@@ -6,10 +6,10 @@ import { summarizeToolCall, previewToolResult } from './core.js';
 
 const FAILED_RE = /^Error|^Permiso denegado/i;
 
-/** Payload estandar de un tool_result para eventos SSE: preview + failed. */
+/** Payload estandar de un tool_result para eventos SSE: preview + failed (+ meta). */
 export function toolResultPayload(event) {
   const { preview, truncated } = previewToolResult(event.name, event.result);
-  return { preview, truncated, failed: FAILED_RE.test(String(event.result)) };
+  return { preview, truncated, failed: FAILED_RE.test(String(event.result)), meta: event.meta };
 }
 
 export function toolCallPayload(event) {
@@ -71,7 +71,8 @@ export async function composeAgentMessages({ ctx, cwd, mode, history = [], userM
     { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
     ...(goal ? [{ role: 'system', content: `Objetivo de la sesión: ${goal}` }] : []),
     ...(summary ? [{ role: 'system', content: `Resumen de la conversación anterior:\n${summary}` }] : []),
-    ...history,
+    // El asesor no contamina el contexto del modelo: es una capa de comentario.
+    ...history.filter((message) => message.name !== 'advisor'),
     userMessage,
   ];
 }

package/harness/packages/server/src/lib/channels/telegram.js

@@ -4,8 +4,18 @@
 // proyecto (una carpeta de la raiz configurada en la consola).
 
 import path from 'node:path';
+import { readFile } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
-import { runAgent, createTools, resolveMode, listProviderModels, PROVIDER_META, sintetizar, MAX_TEXTO } from '../core.js';
+import {
+  runAgent,
+  createTools,
+  resolveMode,
+  listProviderModels,
+  PROVIDER_META,
+  sintetizar,
+  MAX_TEXTO,
+  screenshotsDir,
+} from '../core.js';
 import { resolveExistingDir, listSubdirs } from '../workspace.js';
 import {
   combineToolset,
@@ -42,6 +52,72 @@ const HELP = [
   'Podés mandar texto, imágenes o notas de voz.',
 ].join('\n');
 
+function humanSize(bytes) {
+  const n = Number(bytes) || 0;
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+function oneLine(value, max = 400) {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 1).trimEnd()}…` : text;
+}
+
+/**
+ * Explica en una frase qué va a hacer el agente si se aprueba el permiso, en
+ * vez de volcar el JSON crudo (que para `write` mostraba medio archivo).
+ */
+export function describePermission(name, args = {}) {
+  const a = args && typeof args === 'object' ? args : {};
+  switch (name) {
+    case 'bash':
+      return { action: 'ejecutar un comando en el proyecto', detail: oneLine(a.command, 700) };
+    case 'write':
+      return {
+        action: `escribir el archivo ${a.path ?? '(sin ruta)'}`,
+        detail: a.content ? `Contenido: ${humanSize(Buffer.byteLength(String(a.content)))}` : '',
+      };
+    case 'edit':
+      return {
+        action: `editar el archivo ${a.path ?? '(sin ruta)'}`,
+        detail: a.oldString ? `Reemplaza: "${oneLine(a.oldString, 100)}"` : '',
+      };
+    case 'git_commit':
+      return { action: 'hacer un commit', detail: oneLine(a.message, 200) };
+    case 'screenshot':
+      return { action: 'sacar una captura de la página', detail: oneLine(a.url, 200) };
+    case 'console_errors':
+      return { action: 'revisar la consola de una página', detail: oneLine(a.url, 200) };
+    case 'fetch_url':
+      return { action: 'consultar una URL', detail: oneLine(a.url, 200) };
+    case 'read':
+      return { action: `leer ${oneLine(a.path, 120) || 'un archivo'}`, detail: '' };
+    default:
+      return { action: `usar la herramienta "${name}"`, detail: oneLine(JSON.stringify(a), 200) };
+  }
+}
+
+function permissionMessage(project, name, args) {
+  const { action, detail } = describePermission(name, args);
+  const lines = [`⚠ [${project}] Permiso: el agente quiere ${action}.`];
+  if (detail) lines.push('', detail);
+  lines.push('', '¿Qué hacemos?');
+  return lines.join('\n');
+}
+
+function permissionKeyboard(askId) {
+  return {
+    inline_keyboard: [
+      [
+        { text: 'Permitir', callback_data: `perm:${askId}:allow` },
+        { text: 'Permitir todo', callback_data: `perm:${askId}:all` },
+      ],
+      [{ text: 'Denegar', callback_data: `perm:${askId}:deny` }],
+    ],
+  };
+}
+
 async function tg(token, method, payload) {
   const res = await fetch(`${API}/bot${token}/${method}`, {
     method: 'POST',
@@ -144,6 +220,7 @@ export function startTelegramChannel(
   const modelChoices = new Map();
   const projectChoices = new Map();
   const pendingInputs = new Map();
+  const askSessions = new Map(); // askId -> sessionId, para "Permitir todo"
   let running = true;
   let offset = 0;
 
@@ -194,6 +271,32 @@ export function startTelegramChannel(
     }
   }
 
+  /** Manda una imagen (una captura del tool `screenshot`). */
+  async function enviarFoto(chatId, buffer, caption) {
+    try {
+      const form = new FormData();
+      form.append('chat_id', chatId);
+      if (caption) form.append('caption', String(caption).slice(0, 1000));
+      form.append('photo', new Blob([buffer], { type: 'image/png' }), 'captura.png');
+      await tgForm(token, 'sendPhoto', form);
+    } catch (error) {
+      log(`telegram: foto falló: ${error?.message ?? error}`);
+    }
+  }
+
+  /** Entrega una captura guardada en la casa (por nombre, sin path traversal). */
+  async function enviarCaptura(chatId, name, caption) {
+    const safe = String(name ?? '');
+    if (!/^[a-z0-9][a-z0-9-]*\.png$/i.test(safe)) return;
+    let buffer;
+    try {
+      buffer = await readFile(path.join(screenshotsDir(), safe));
+    } catch {
+      return;
+    }
+    await enviarFoto(chatId, buffer, caption);
+  }
+
   // --- proyectos ------------------------------------------------------------
 
   /** Carpeta raíz para elegir proyecto: la predeterminada de la consola o el cwd. */
@@ -351,19 +454,15 @@ export function startTelegramChannel(
     }
 
     const onAsk = async (name, args) => {
+      // "Permitir todo" activa el auto-approve de la sesion (compartido con la
+      // consola): a partir de ahi no se vuelve a preguntar.
+      if (ctx.isAutoApprove?.(sessionId)) return true;
       const askId = randomUUID();
-      const preview = JSON.stringify(args ?? {}).slice(0, 300);
-      await send(chatId, `⚠ [${projectLabel(session)}] Permiso para ${name}\n${preview}`, {
-        reply_markup: {
-          inline_keyboard: [
-            [
-              { text: 'Permitir', callback_data: `perm:${askId}:allow` },
-              { text: 'Denegar', callback_data: `perm:${askId}:deny` },
-            ],
-          ],
-        },
+      askSessions.set(askId, sessionId);
+      await send(chatId, permissionMessage(projectLabel(session), name, args), {
+        reply_markup: permissionKeyboard(askId),
       });
-      return ctx.approvals.ask(askId);
+      return ctx.approvals.ask(askId, { sessionId, name, args });
     };
 
     const local = createTools({
@@ -419,6 +518,9 @@ export function startTelegramChannel(
             }
           } else if (event.type === 'tool_result') {
             activity = `${event.name} ✓`;
+            if (event.name === 'screenshot' && event.meta?.screenshot?.name) {
+              enviarCaptura(chatId, event.meta.screenshot.name, event.meta.screenshot.url);
+            }
           } else {
             return;
           }
@@ -656,8 +758,12 @@ export function startTelegramChannel(
     let toast = '';
 
     if (kind === 'perm') {
-      ctx.approvals.decide(a, b === 'allow');
-      toast = b === 'allow' ? 'Permitido' : 'Denegado';
+      const all = b === 'all';
+      ctx.approvals.decide(a, b === 'allow' || all);
+      const sessionId = askSessions.get(a);
+      if (sessionId) askSessions.delete(a);
+      if (all && sessionId) ctx.setAutoApprove?.(sessionId, true);
+      toast = all ? 'Permitidos todos' : b === 'allow' ? 'Permitido' : 'Denegado';
     } else if (kind === 'proj') {
       if (a === 'root') {
         await selectProject(chatId, projectRoot());
@@ -755,7 +861,7 @@ export function startTelegramChannel(
     notify(sessionId, event) {
       if (ownSessions.has(sessionId)) return;
 
-      // La tool `speak` entrega audio en vivo a un chat vinculado.
+      // Las tools `speak` y `screenshot` entregan en vivo a un chat vinculado.
       if (event.type === 'tool_call') {
         if (event.data?.name !== 'speak') return;
         const linked = ctx.store.getSetting(reverseKey(sessionId));
@@ -767,6 +873,12 @@ export function startTelegramChannel(
         }
         return;
       }
+      if (event.type === 'tool_result' && event.data?.name === 'screenshot') {
+        const linked = ctx.store.getSetting(reverseKey(sessionId));
+        const shot = event.data?.meta?.screenshot;
+        if (linked && shot?.name) enviarCaptura(linked, shot.name, shot.url);
+        return;
+      }
 
       const targets = notifyTargets(sessionId);
       if (!targets.length) return;
@@ -785,17 +897,10 @@ export function startTelegramChannel(
       } else if (event.type === 'permission' && notifyConfig.permission) {
         const askId = event.data?.askId;
         if (!askId) return;
+        if (event.data?.sessionId) askSessions.set(askId, event.data.sessionId);
+        const text = permissionMessage(project, event.data?.name ?? 'una tool', event.data?.args);
         for (const chatId of targets) {
-          send(chatId, `[${project}] ⚠ Permiso para ${event.data?.name ?? 'una tool'}`, {
-            reply_markup: {
-              inline_keyboard: [
-                [
-                  { text: 'Permitir', callback_data: `perm:${askId}:allow` },
-                  { text: 'Denegar', callback_data: `perm:${askId}:deny` },
-                ],
-              ],
-            },
-          }).catch(() => {});
+          send(chatId, text, { reply_markup: permissionKeyboard(askId) }).catch(() => {});
         }
       }
     },

package/harness/packages/server/src/lib/ttsSettings.js

@@ -8,14 +8,14 @@ export const DEFAULT_TTS = {
   enabled: false,
   voice: VOZ_POR_DEFECTO,
   rate: '+0%',
-  announce: { start: true, tools: true, end: true },
+  announce: { start: true, tools: true, end: true, advice: true, answer: false },
 };
 
 /** Merge de defaults + lo guardado (con `announce` aplanado a booleans). */
 export function resolveTts(app) {
   const saved = app?.tts && typeof app.tts === 'object' ? app.tts : {};
   const announce = { ...DEFAULT_TTS.announce, ...(saved.announce ?? {}) };
-  for (const key of ['start', 'tools', 'end']) announce[key] = announce[key] === true;
+  for (const key of ['start', 'tools', 'end', 'advice', 'answer']) announce[key] = announce[key] === true;
   return {
     ...DEFAULT_TTS,
     ...saved,

package/harness/packages/server/src/lib/update.js

@@ -0,0 +1,82 @@
+// Chequeo de version nueva contra el registro npm. Cacheado a proposito: el
+// banner de la consola pregunta seguido y no queremos pegarle a npm en cada
+// request. Un fallo de red no rompe: se devuelve `updateAvailable:false`.
+
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import {
+  ROOT_PACKAGE_NAME,
+  readPackageVersion,
+  compareVersions,
+  fetchLatestVersion,
+  packageRoot,
+  homeDir,
+} from './core.js';
+
+const CACHE_MS = 10 * 60 * 1000;
+
+let cache = { at: 0, latest: '' };
+
+/** Limpia la cache (tests). */
+export function clearUpdateCache() {
+  cache = { at: 0, latest: '' };
+}
+
+/**
+ * @returns {{current:string, latest:string, updateAvailable:boolean, checkedAt:string|null, error?:string}}
+ */
+export async function checkUpdate({ force = false, current = readPackageVersion(), fetchImpl } = {}) {
+  const now = Date.now();
+  const fresh = cache.latest && now - cache.at < CACHE_MS;
+  if (!force && fresh) {
+    return {
+      current,
+      latest: cache.latest,
+      updateAvailable: compareVersions(cache.latest, current) > 0,
+      checkedAt: new Date(cache.at).toISOString(),
+    };
+  }
+
+  try {
+    const latest = await fetchLatestVersion({ pkg: ROOT_PACKAGE_NAME, ...(fetchImpl ? { fetchImpl } : {}) });
+    cache = { at: now, latest };
+    return {
+      current,
+      latest,
+      updateAvailable: compareVersions(latest, current) > 0,
+      checkedAt: new Date(now).toISOString(),
+    };
+  } catch (error) {
+    return {
+      current,
+      latest: '',
+      updateAvailable: false,
+      checkedAt: null,
+      error: String(error?.message ?? error),
+    };
+  }
+}
+
+/**
+ * Lanza el script detached que espera la muerte de este server, instala la
+ * version nueva y lo vuelve a levantar. Devolver rapido es el punto: el server
+ * tiene que soltar los archivos (Windows) antes de que npm los reemplace.
+ */
+export function spawnSelfUpdate({ pid = process.pid, port, host, cwd, target, home } = {}) {
+  const root = packageRoot();
+  if (!root) return { ok: false, error: 'no encontre el paquete del harness' };
+  const script = path.join(root, 'harness', 'scripts', 'self-update.mjs');
+  const args = [script, '--pid', String(pid)];
+  if (port) args.push('--port', String(port));
+  if (host) args.push('--host', String(host));
+  if (cwd) args.push('--cwd', String(cwd));
+  if (target) args.push('--target', String(target));
+  args.push('--home', home || homeDir());
+  try {
+    const child = spawn(process.execPath, args, { detached: true, stdio: 'ignore', windowsHide: true });
+    child.unref();
+    return { ok: true, pid: child.pid };
+  } catch (error) {
+    return { ok: false, error: String(error?.message ?? error) };
+  }
+}

package/harness/packages/server/src/routes/advisor.js

@@ -0,0 +1,76 @@
+// Ajustes del asesor (app.json -> advisor) y una prueba manual que corre una
+// consulta real para ver que devuelve el modelo.
+
+import { resolveAdvisor, consultAdvisor } from '../lib/advisor.js';
+import { readApp, writeApp } from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+
+export function registerAdvisor(route, ctx) {
+  route('GET', '/api/advisor/settings', ({ res }) => {
+    sendJson(res, 200, resolveAdvisor(ctx.app));
+  });
+
+  route('PUT', '/api/advisor/settings', async ({ req, res }) => {
+    const body = await readJson(req);
+    const app = readApp();
+    const current = resolveAdvisor(ctx.app);
+    const next = { ...current };
+    if ('enabled' in body) next.enabled = body.enabled === true;
+    if ('code' in body) next.code = body.code !== false;
+    if ('explain' in body) next.explain = body.explain !== false;
+    if ('advice' in body) next.advice = body.advice !== false;
+    if ('notes' in body) next.notes = String(body.notes ?? '').slice(0, 2000);
+    if ('maxWords' in body) {
+      const value = Number(body.maxWords);
+      next.maxWords = Number.isFinite(value)
+        ? Math.min(Math.max(Math.round(value), 10), 120)
+        : current.maxWords;
+    }
+    app.advisor = next;
+    writeApp(app);
+    ctx.app = app;
+    sendJson(res, 200, resolveAdvisor(app));
+  });
+
+  route('POST', '/api/advisor/test', async ({ res }) => {
+    const options = resolveAdvisor(ctx.app);
+    const providerId = ctx.effectiveProviderId();
+    const model = ctx.effectiveModel();
+    if (!model) return sendError(res, 400, 'Elegí un proveedor y un modelo primero.');
+    const { provider, config } = ctx.resolveProvider({
+      ...ctx.providerSettings(providerId),
+      apiKey: ctx.apiKeyFor(providerId),
+    });
+    // Turno de ejemplo con una edicion: alcanza para ver si el asesor aporta algo.
+    const messages = [
+      {
+        role: 'assistant',
+        content: '',
+        tool_calls: [
+          {
+            id: 'test-1',
+            type: 'function',
+            function: { name: 'edit', arguments: JSON.stringify({ path: 'src/auth.js' }) },
+          },
+        ],
+      },
+      {
+        role: 'tool',
+        tool_call_id: 'test-1',
+        name: 'edit',
+        content: 'Editado src/auth.js\n- const token = "secreto123"\n+ const token = process.env.TOKEN',
+      },
+    ];
+    const advice = await consultAdvisor({
+      provider,
+      config,
+      model,
+      userInput: 'Revisá el manejo del token de sesión.',
+      answer: 'Listo, ajusté el archivo.',
+      messages,
+      options,
+    });
+    if (!advice) return sendError(res, 502, 'El asesor no devolvió una respuesta interpretable.');
+    sendJson(res, 200, advice);
+  });
+}