@danieltmn/tamnora 0.25.1 → 0.26.0

package/harness/packages/server/public/voice.js

@@ -6,11 +6,9 @@ import {
   setStatus,
   trModelEl,
   trProviderEl,
-  vozAnnAdviceEl,
   vozAnnAnswerEl,
   vozAnnEndEl,
   vozAnnStartEl,
-  vozAnnSummaryEl,
   vozAnnToolsEl,
   vozEnabledEl,
   vozFfmpegEl,
@@ -573,7 +571,7 @@ export const voz = {
     voice: 'es-AR-ElenaNeural',
     rate: '+0%',
     pitch: '+0Hz',
-    announce: { start: true, tools: true, end: true, advice: true, answer: false, summary: false },
+    announce: { start: true, tools: true, end: true, answer: false },
   },
 };
 
@@ -772,11 +770,9 @@ export function narrar(event, data, turn) {
   const { enabled, announce } = voz.settings;
   if (!enabled && !handsFreeOn) return;
   // Manos libres: conversacion, sin narracion de arranque/herramientas; lee la
-  // respuesta final (y el asesor) aunque la narracion este apagada en Ajustes.
+  // respuesta final aunque la narracion este apagada en Ajustes.
   if (handsFreeOn) {
-    if (event === 'advice') {
-      if (data?.say) hablar(data.say, { label: 'asesor', maxAgeMs: 0, force: true });
-    } else if (event === 'done') {
+    if (event === 'done') {
       const spoken = speechText(data?.content);
       if (spoken) hablar(spoken, { label: 'respuesta', maxAgeMs: 0, force: true });
       else if (data?.say) hablar(data.say, { maxAgeMs: 0, force: true });
@@ -788,15 +784,9 @@ export function narrar(event, data, turn) {
   if (!enabled) return;
   if (event === 'start' && announce.start) hablar(data?.say);
   else if (event === 'tool_call' && announce.tools) hablar(data?.say);
-  // El asesor y la respuesta final son el cierre del turno: si quedan en cola
-  // detras de un audio largo, igual hay que leerlos (sin vencimiento).
-  else if (event === 'advice') {
-    if (data?.kind === 'summary') {
-      if (announce.summary) hablar(data?.say, { label: 'resumen', maxAgeMs: 0 });
-    } else if (announce.advice) {
-      hablar(data?.say, { label: 'asesor', maxAgeMs: 0 });
-    }
-  } else if (event === 'done' && announce.answer) {
+  // La respuesta final es el cierre del turno: si queda en cola detras de un
+  // audio largo, igual hay que leerla (sin vencimiento).
+  else if (event === 'done' && announce.answer) {
     // Lee la respuesta final limpia; si era solo codigo, cae al cierre.
     const spoken = speechText(data?.content);
     if (spoken) hablar(spoken, { label: 'respuesta', maxAgeMs: 0 });
@@ -828,9 +818,7 @@ export async function aplicarVoz(data) {
       start: data.announce?.start !== false,
       tools: data.announce?.tools !== false,
       end: data.announce?.end !== false,
-      advice: data.announce?.advice !== false,
       answer: data.announce?.answer === true,
-      summary: data.announce?.summary === true,
     },
   };
   if (vozEnabledEl) vozEnabledEl.checked = voz.settings.enabled;
@@ -850,8 +838,6 @@ export async function aplicarVoz(data) {
   if (vozAnnStartEl) vozAnnStartEl.checked = voz.settings.announce.start;
   if (vozAnnToolsEl) vozAnnToolsEl.checked = voz.settings.announce.tools;
   if (vozAnnEndEl) vozAnnEndEl.checked = voz.settings.announce.end;
-  if (vozAnnAdviceEl) vozAnnAdviceEl.checked = voz.settings.announce.advice;
-  if (vozAnnSummaryEl) vozAnnSummaryEl.checked = voz.settings.announce.summary;
   if (vozAnnAnswerEl) vozAnnAnswerEl.checked = voz.settings.announce.answer;
   const estado = $('#voz-status');
   if (estado) {
@@ -877,9 +863,7 @@ export async function submitVoz() {
       start: vozAnnStartEl?.checked !== false,
       tools: vozAnnToolsEl?.checked !== false,
       end: vozAnnEndEl?.checked !== false,
-      advice: vozAnnAdviceEl?.checked !== false,
       answer: vozAnnAnswerEl?.checked === true,
-      summary: vozAnnSummaryEl?.checked === true,
     },
   };
   const data = await api('/api/tts/settings', { method: 'PUT', body }).catch((e) => ({ error: e.message }));

package/harness/packages/server/src/auth.js

@@ -1,6 +1,5 @@
 import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
 import { sendError } from './lib/http.js';
-import { tunnelState } from './lib/core.js';
 import { isLoopback } from './lib/workspace.js';
 
 /**
@@ -38,26 +37,16 @@ export function parseCookies(header) {
   return out;
 }
 
-// Detras del tunel el server recibe desde loopback: solo ahi confiamos en
-// X-Forwarded-Proto para marcar la cookie Secure. Como el cliente del tunel
-// corre en la misma maquina, un request por el tunel es indistinguible de uno
-// local por direccion: usamos el Host (localhost/127.0.0.1 = local) y el
-// estado del bridge para no mandar la cookie sin Secure por el tunel.
-function isLocalHost(req) {
-  const host = String(req.headers.host || '').split(':')[0].toLowerCase();
-  return !host || host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '[::1]';
-}
-
+// Detras del bridge de tailscale el server recibe desde loopback: solo ahi
+// confiamos en X-Forwarded-Proto para marcar la cookie Secure. La URL del
+// tailnet es HTTPS aunque el salto interno sea http.
 function isSecure(req) {
   if (req.socket && req.socket.encrypted) return true;
   const remote = req.socket && req.socket.remoteAddress;
   const loopback = !remote || isLoopback(remote);
   if (!loopback) return false;
   const proto = String(req.headers['x-forwarded-proto'] || '').split(',')[0].trim().toLowerCase();
-  if (proto === 'https') return true;
-  // Peticion por el tunel (host publico + bridge activo): la URL publica es
-  // HTTPS, la cookie no tiene que poder viajar por la variante http.
-  return Boolean(tunnelState()) && !isLocalHost(req);
+  return proto === 'https';
 }
 
 function serializeCookie(value, req, maxAge) {

package/harness/packages/server/src/cli.js

@@ -52,7 +52,7 @@ export async function serveCommand(argv) {
 function printHelp() {
   console.log(`Uso: tamnora serve [opciones]
 
-Levanta la consola del harness (chat + evaluación) en localhost.
+Levanta la consola del harness (chat) en localhost.
 
 Opciones:
   --port <n>       Puerto (default: 4517)

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

@@ -1,32 +1,21 @@
 import path from 'node:path';
-import { rm } from 'node:fs/promises';
+import { homeDir, loadAgents, mergeAgents, buildAgentsIndex, writeAgentFile } from './core.js';
 import {
-  homeDir,
-  loadAgents,
-  mergeAgents,
-  buildAgentsIndex,
-  writeAgentFile,
-} from './core.js';
+  DEFINITION_ID_PATTERN,
+  allDefinitions,
+  disabledDefinitionIds,
+  removeDefinition,
+  setDefinitionEnabled,
+} from './definitions.js';
 
-export const AGENT_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
-
-/** Agent roots, lowest priority first: casa agents, then the workspace's. */
-export function agentRoots(cwd) {
-  return [path.join(homeDir(), 'agents'), path.join(cwd, '.tamnora', 'agents')];
-}
+export const AGENT_ID_PATTERN = DEFINITION_ID_PATTERN;
 
 export function allAgents(cwd) {
-  const home = path.join(homeDir(), 'agents');
-  return mergeAgents(agentRoots(cwd).map((root) => loadAgents(root).map((a) => ({ ...a, root, home: root === home }))));
-}
-
-function disabledIds(store) {
-  const raw = store.getSetting('disabledAgents');
-  return new Set(Array.isArray(raw) ? raw.map(String) : []);
+  return allDefinitions(cwd, { kind: 'agents', load: loadAgents, merge: mergeAgents });
 }
 
 export function agentsView(ctx) {
-  const disabled = disabledIds(ctx.store);
+  const disabled = disabledDefinitionIds(ctx.store, 'agents');
   return allAgents(ctx.cwd).map((agent) => ({
     id: agent.id,
     name: agent.name || agent.id,
@@ -48,7 +37,7 @@ export function findAgent(ctx, id) {
 }
 
 export function enabledAgents(ctx) {
-  const disabled = disabledIds(ctx.store);
+  const disabled = disabledDefinitionIds(ctx.store, 'agents');
   return allAgents(ctx.cwd).filter((agent) => !disabled.has(agent.id));
 }
 
@@ -63,12 +52,9 @@ export async function writeAgent(id, data) {
 }
 
 export async function removeAgent(id) {
-  await rm(path.join(homeDir(), 'agents', String(id)), { recursive: true, force: true });
+  await removeDefinition('agents', id);
 }
 
 export function setAgentEnabled(store, id, enabled) {
-  const current = new Set(Array.isArray(store.getSetting('disabledAgents')) ? store.getSetting('disabledAgents') : []);
-  if (enabled) current.delete(id);
-  else current.add(id);
-  store.setSetting('disabledAgents', [...current]);
+  setDefinitionEnabled(store, 'agents', id, enabled);
 }

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

@@ -1,27 +1,9 @@
 // Apariencia de la consola (app.json -> appearance): tema, tipografía y tamaño.
 // Los ids deben coincidir con public/appearance.js; acá solo se valida y acota.
 
-export const THEME_IDS = [
-  'paper',
-  'dark',
-  'midnight',
-  'nord',
-  'dracula',
-  'solarized',
-  'solarized-dark',
-  'bosque',
-  'vino',
-  'arena',
-  'hielo',
-  'vercel',
-  'dark-plus',
-  'github',
-  'github-dark',
-  'mocha',
-  'ebano',
-];
+export const THEME_IDS = ['paper', 'github', 'dark', 'mocha'];
 
-export const FONT_IDS = ['clasico', 'sistema', 'plex', 'inter', 'jetbrains', 'fira', 'source'];
+export const FONT_IDS = ['clasico', 'sistema'];
 
 export const DEFAULT_APPEARANCE = { theme: 'paper', font: 'clasico', chatFont: 14.5, scale: 1 };
 
@@ -31,8 +13,7 @@ const MIN_SCALE = 0.8;
 const MAX_SCALE = 1.3;
 
 export function resolveThemeId(id) {
-  const legacy = id === 'light' ? 'paper' : id;
-  return THEME_IDS.includes(legacy) ? legacy : DEFAULT_APPEARANCE.theme;
+  return THEME_IDS.includes(id) ? id : DEFAULT_APPEARANCE.theme;
 }
 
 export function resolveFontId(id) {

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

@@ -179,7 +179,7 @@ export async function handleCommand(T, chatId, text) {
     T.controllers.get(String(chatId))?.abort();
     return send(T, chatId, 'Cancelando.');
   }
-  if (cmd === 'estricto' || cmd === 'strict') {
+  if (cmd === 'estricto') {
     const current = T.ctx.store.getSetting('strictScope') === true;
     const value = arg ? /^(on|si|sí|1|true)$/i.test(arg) : !current;
     T.ctx.store.setSetting('strictScope', value);

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

@@ -0,0 +1,40 @@
+// Registro comun de definiciones en markdown (skills y subagentes): raices
+// casa + workspace, merge con prioridad al workspace y estado on/off en un
+// setting (`disabledSkills` / `disabledAgents`).
+
+import path from 'node:path';
+import { rm } from 'node:fs/promises';
+import { homeDir } from './core.js';
+
+export const DEFINITION_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
+
+/** Raices, de menor a mayor prioridad: casa y despues workspace. */
+export function definitionRoots(cwd, kind) {
+  return [path.join(homeDir(), kind), path.join(cwd, '.tamnora', kind)];
+}
+
+/** Carga y mergea las definiciones, marcando `root` y si viven en la casa. */
+export function allDefinitions(cwd, { kind, load, merge }) {
+  const home = path.join(homeDir(), kind);
+  return merge(definitionRoots(cwd, kind).map((root) => load(root).map((item) => ({ ...item, root, home: root === home }))));
+}
+
+function disabledKey(kind) {
+  return `disabled${kind[0].toUpperCase()}${kind.slice(1)}`;
+}
+
+export function disabledDefinitionIds(store, kind) {
+  const raw = store.getSetting(disabledKey(kind));
+  return new Set(Array.isArray(raw) ? raw.map(String) : []);
+}
+
+export function setDefinitionEnabled(store, kind, id, enabled) {
+  const current = disabledDefinitionIds(store, kind);
+  if (enabled) current.delete(id);
+  else current.add(id);
+  store.setSetting(disabledKey(kind), [...current]);
+}
+
+export function removeDefinition(kind, id) {
+  return rm(path.join(homeDir(), kind, String(id)), { recursive: true, force: true });
+}

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

@@ -1,26 +1,22 @@
 import path from 'node:path';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { homeDir, loadSkills, mergeSkills, buildSkillsPrompt, buildSkillsIndex } from './core.js';
+import {
+  DEFINITION_ID_PATTERN,
+  allDefinitions,
+  disabledDefinitionIds,
+  removeDefinition,
+  setDefinitionEnabled,
+} from './definitions.js';
 
-export const SKILL_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
-
-/** Skill roots, lowest priority first: casa skills, then the workspace's. */
-export function skillRoots(cwd) {
-  return [path.join(homeDir(), 'skills'), path.join(cwd, '.tamnora', 'skills')];
-}
+export const SKILL_ID_PATTERN = DEFINITION_ID_PATTERN;
 
 export function allSkills(cwd) {
-  const home = path.join(homeDir(), 'skills');
-  return mergeSkills(skillRoots(cwd).map((root) => loadSkills(root).map((s) => ({ ...s, root, home: root === home }))));
-}
-
-function disabledIds(store) {
-  const raw = store.getSetting('disabledSkills');
-  return new Set(Array.isArray(raw) ? raw.map(String) : []);
+  return allDefinitions(cwd, { kind: 'skills', load: loadSkills, merge: mergeSkills });
 }
 
 export function skillsView(ctx) {
-  const disabled = disabledIds(ctx.store);
+  const disabled = disabledDefinitionIds(ctx.store, 'skills');
   return allSkills(ctx.cwd).map((s) => ({
     id: s.id,
     name: s.name || s.id,
@@ -36,7 +32,7 @@ export function findSkill(ctx, id) {
 }
 
 export function enabledSkills(ctx) {
-  const disabled = disabledIds(ctx.store);
+  const disabled = disabledDefinitionIds(ctx.store, 'skills');
   return allSkills(ctx.cwd)
     .filter((s) => !disabled.has(s.id))
     .map((s) => ({ id: s.id, name: s.name || s.id, description: s.description, when: s.when, body: s.body }));
@@ -82,12 +78,9 @@ export async function writeSkill(id, { name, description, when, body }) {
 }
 
 export async function removeSkill(id) {
-  await rm(path.join(homeDir(), 'skills', id), { recursive: true, force: true });
+  await removeDefinition('skills', id);
 }
 
 export function setSkillEnabled(store, id, enabled) {
-  const current = new Set(Array.isArray(store.getSetting('disabledSkills')) ? store.getSetting('disabledSkills') : []);
-  if (enabled) current.delete(id);
-  else current.add(id);
-  store.setSetting('disabledSkills', [...current]);
+  setDefinitionEnabled(store, 'skills', id, enabled);
 }

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

@@ -9,14 +9,14 @@ export const DEFAULT_TTS = {
   voice: VOZ_POR_DEFECTO,
   rate: '+0%',
   pitch: '+0Hz',
-  announce: { start: true, tools: true, end: true, advice: true, answer: false, summary: false },
+  announce: { start: true, tools: true, end: 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', 'advice', 'answer', 'summary']) announce[key] = announce[key] === true;
+  for (const key of ['start', 'tools', 'end', 'answer']) announce[key] = announce[key] === true;
   return {
     ...DEFAULT_TTS,
     ...saved,

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

@@ -3,7 +3,7 @@ import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
 import { sendError } from './http.js';
-import { tunnelState, realpathDeep } from './core.js';
+import { realpathDeep } from './core.js';
 
 /** True for 127.x / ::1 / ::ffff:127.x addresses. */
 export function isLoopback(address) {
@@ -13,19 +13,17 @@ export function isLoopback(address) {
 
 /**
  * "Local de verdad": el par TCP es loopback (remoteAddress, no localAddress:
- * esa es la direccion donde bindea el server, siempre 127.0.0.1) y no hay un
- * tunel publico activo. Con el tunel abierto las peticiones remotas TAMBIEN
- * llegan desde loopback (el cliente del tunel corre en la misma maquina), asi
- * que la ausencia de tunel es parte del check.
+ * esa es la direccion donde bindea el server, siempre 127.0.0.1). El bridge de
+ * tailscale tambien entra por loopback, asi que sigue siendo local.
  */
 export function localOk(req) {
-  return isLoopback(req?.socket?.remoteAddress) && !tunnelState();
+  return isLoopback(req?.socket?.remoteAddress);
 }
 
 /** `localOk` o 403. Devuelve true si la request puede seguir. */
 export function requireLocal(req, res, mensaje = 'Solo disponible en conexiones locales.') {
   if (localOk(req)) return true;
-  sendError(res, 403, tunnelState() ? `${mensaje} Hay un túnel público activo.` : mensaje);
+  sendError(res, 403, mensaje);
   return false;
 }
 
@@ -35,7 +33,7 @@ export function requireLocal(req, res, mensaje = 'Solo disponible en conexiones
 // victima contra 127.0.0.1 no puede ejecutar nada.
 // ---------------------------------------------------------------------------
 
-const TRUSTED_HOST_SUFFIXES = ['.ts.net', '.tunnelmole.net', '.localhost'];
+const TRUSTED_HOST_SUFFIXES = ['.ts.net', '.localhost'];
 
 /** Hostname (sin puerto, sin brackets de IPv6) del header `Host`. */
 export function hostNameOf(hostHeader) {
@@ -60,9 +58,9 @@ function normalizeHost(host) {
 
 /**
  * Guarda DNS-rebinding: el `Host` debe ser un nombre que controlamos — una IP
- * literal, localhost, el hostname de la maquina, un dominio de tailscale o del
- * tunel, o una lista explicita (`config.server.allowedHosts`). Una pagina que
- * rebindee su dominio hacia 127.0.0.1 llega con `Host: <su dominio>` y cae aca.
+ * literal, localhost, el hostname de la maquina, un dominio de tailscale, o una
+ * lista explicita (`config.server.allowedHosts`). Una pagina que rebindee su
+ * dominio hacia 127.0.0.1 llega con `Host: <su dominio>` y cae aca.
  */
 export function trustedHost(req, allowed = []) {
   const host = hostNameOf(req?.headers?.host);

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

@@ -20,7 +20,6 @@ import {
   toolResultPayload,
 } from '../lib/agentRun.js';
 import { fraseInicio, fraseFin, fraseError, createFiltroTools } from '../lib/announcer.js';
-import { resolveAdvisor, advisorShouldRun, consultAdvisor } from '../lib/advisor.js';
 import { maybeAutoCompact } from '../lib/compact.js';
 import { createRulesInjector } from '../lib/rules.js';
 import { createCheckpointer } from '../lib/checkpoints.js';
@@ -419,48 +418,6 @@ export function registerChat(route, ctx) {
             durationMs,
             say: fraseFin({ stopReason: result.stopReason, rounds: result.rounds, toolCalls, durationMs }),
           });
-
-        // El asesor va despues del `done` pero antes del `finally`, asi el run
-        // sigue vivo y el evento llega/persiste. Puede quedarse callado.
-        const advisorOptions = resolveAdvisor(ctx.app);
-        if (
-          result.stopReason !== 'aborted' &&
-          advisorOptions.enabled &&
-          advisorShouldRun({ toolCalls, answer: result.content })
-        ) {
-          // El asesor puede tener proveedor/modelo propios; si no, usa los activos.
-          let advisorProvider = provider;
-          let advisorConfig = config;
-          let advisorModel = model;
-          if (advisorOptions.provider || advisorOptions.model) {
-            const resolved = resolveProviderFor(ctx, advisorOptions.provider || providerId);
-            advisorProvider = resolved.provider;
-            advisorConfig = resolved.config;
-            advisorModel = advisorOptions.model || model;
-          }
-          const advice = await consultAdvisor({
-            provider: advisorProvider,
-            config: advisorConfig,
-            model: advisorModel,
-            signal: ctx.runs.signal(sessionId),
-            userInput: input,
-            answer: result.content,
-            messages: newMessages,
-            options: advisorOptions,
-          });
-          // Un solo mensaje (estilo Jarvis): el asesor arranca con el resumen y
-          // sigue con la alerta/consejo en el mismo texto. Una sola locucion.
-          if (advice?.speak) {
-            ctx.store.addMessage(sessionId, {
-              role: 'assistant',
-              name: 'advisor',
-              content: advice.text,
-              mode: advice.kind,
-            });
-            ctx.runs.emit(sessionId, 'advice', { text: advice.text, kind: advice.kind, say: advice.text });
-            ctx.hooks?.dispatch({ type: 'advice', sessionId, text: advice.text, kind: advice.kind });
-          }
-        }
       } catch (error) {
         partials.flush();
         if (error?.name === 'AbortError') ctx.runs.emit(sessionId, 'aborted', { say: fraseFin({ stopReason: 'aborted' }) });

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

@@ -3,11 +3,10 @@ import { readJson, sendJson, sendError } from '../lib/http.js';
 import { requireLocal, localOk } from '../lib/workspace.js';
 
 /**
- * Preview de un dev server para acceso remoto. Con `tailscale` publica el puerto
- * en el tailnet (`tailscale serve --https=8443`, privado); con `tunnelmole` abre
- * un tunel publico. El estado vive en memoria y se expone en `GET /api/preview`
- * para que el cliente lo recupere tras una recarga. Devuelve `{ close }` para
- * liberar el tunel al apagar.
+ * Preview de un dev server para acceso remoto: publica el puerto en el tailnet
+ * (`tailscale serve --https=8443`, privado). El estado vive en memoria y se
+ * expone en `GET /api/preview` para que el cliente lo recupere tras una recarga.
+ * Devuelve `{ close }` para liberar el tunel al apagar.
  */
 export function registerPreview(route, ctx) {
   let tunnel = null;
@@ -49,23 +48,7 @@ export function registerPreview(route, ctx) {
     try {
       started = await startTunnel(port, provider, { preview: true, httpsPort });
     } catch (error) {
-      // El fallback a tunnelmole es un tunel PUBLICO: solo con consentimiento
-      // explicito (`allowPublic` o `preview.fallback: true`). Quien pidio un
-      // tunel privado no puede quedar expuesto sin saberlo.
-      const allowPublic = body.allowPublic === true || preview.fallback === true;
-      if (provider !== 'tunnelmole' && allowPublic) {
-        try {
-          started = await startTunnel(port, 'tunnelmole');
-        } catch (fallbackError) {
-          return sendError(res, 502, `No se pudo abrir el túnel: ${fallbackError.message}`);
-        }
-      } else {
-        return sendError(
-          res,
-          502,
-          `No se pudo abrir el túnel: ${error.message}. Si querés exponerlo con tunnelmole (público), reintentá con ese proveedor.`
-        );
-      }
+      return sendError(res, 502, `No se pudo abrir el túnel: ${error.message}`);
     }
     tunnel = { url: started.url, port, provider: started.provider, stop: started.stop };
     sendJson(res, 200, { tunnel: view(tunnel) });

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

@@ -1,4 +1,4 @@
-import { detectProcs, killPort, portInfo } from '../lib/core.js';
+import { loadProjectProcs, killPort, portInfo } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 import { requireLocal, resolveDirOr400 } from '../lib/workspace.js';
 
@@ -11,7 +11,7 @@ export function registerProcs(route, ctx) {
     if (!ctx.procsEnabled) return sendJson(res, 200, { cwd: ctx.cwd, chips: [] });
     const dir = resolveDirOr400(res, query.get('cwd'), ctx.cwd);
     if (!dir) return;
-    const chips = detectProcs(dir).map((chip) => ({ ...chip, allowed: ctx.procs.allows(chip.command) }));
+    const chips = loadProjectProcs(dir).map((chip) => ({ ...chip, allowed: ctx.procs.allows(chip.command) }));
     sendJson(res, 200, { cwd: dir, chips });
   });
 
@@ -53,8 +53,6 @@ export function registerProcs(route, ctx) {
     }
   }
 
-  route('POST', '/api/procs/kill', killPortHandler);
-
   route('POST', '/api/ports/kill', killPortHandler);
 
   route('GET', '/api/ports/:port', async ({ req, res, params }) => {

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

@@ -40,7 +40,7 @@ export function registerTts(route, ctx) {
     if ('pitch' in body) next.pitch = sanearPitch(body.pitch, actual.pitch);
     if (body.announce && typeof body.announce === 'object') {
       const announce = { ...actual.announce };
-      for (const key of ['start', 'tools', 'end', 'advice', 'answer', 'summary']) {
+      for (const key of ['start', 'tools', 'end', 'answer']) {
         if (key in body.announce) announce[key] = body.announce[key] === true;
       }
       next.announce = announce;

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

@@ -52,7 +52,6 @@ import { registerTts } from './routes/tts.js';
 import { registerTranscribe } from './routes/transcribe.js';
 import { registerUpdate } from './routes/update.js';
 import { registerReload } from './routes/reload.js';
-import { registerAdvisor } from './routes/advisor.js';
 import { registerProcs } from './routes/procs.js';
 import { registerShell } from './routes/shell.js';
 import { registerPreview } from './routes/preview.js';
@@ -60,7 +59,6 @@ import { registerChat } from './routes/chat.js';
 import { registerEvents } from './routes/events.js';
 import { registerState } from './routes/state.js';
 import { registerPresence } from './routes/presence.js';
-import { registerEval } from './routes/eval.js';
 import { registerSchedules } from './routes/schedules.js';
 import { createScheduler } from './lib/scheduler.js';
 import { createHookRunner } from './lib/hooks.js';
@@ -99,7 +97,7 @@ export async function createTamnoraServer({
   const config = await loadConfig(cwd);
   const app = readApp();
   const authEnabled = Boolean(app.user && app.user.password);
-  const store = new Store(dbPath ?? databasePath(cwd));
+  const store = new Store(dbPath ?? databasePath());
   const approvals = createApprovalBroker({ timeoutMs: config.approvalTimeoutMs });
   const questions = createQuestionBroker({ timeoutMs: config.questionTimeoutMs });
   const presence = createPresence();
@@ -338,7 +336,6 @@ export async function createTamnoraServer({
   registerProfile(route, ctx);
   registerTts(route, ctx);
   registerTranscribe(route, ctx);
-  registerAdvisor(route, ctx);
   registerUpdate(route, ctx);
   registerReload(route, ctx);
   registerProcs(route, ctx);
@@ -348,7 +345,6 @@ export async function createTamnoraServer({
   registerEvents(route, ctx);
   registerState(route, ctx);
   registerPresence(route, ctx);
-  registerEval(route, ctx);
   registerSchedules(route, ctx);
 
   route('GET', '/api/hooks', ({ res }) => {

package/harness/packages/server/test/appearance-route.test.js

@@ -44,12 +44,12 @@ test('la apariencia se guarda en app.json y se valida', async () => {
     const put = await fetch(`${base}/api/settings`, {
       method: 'PUT',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ appearance: { theme: 'nord', font: 'plex', chatFont: 18, scale: 1.1 } }),
+      body: JSON.stringify({ appearance: { theme: 'github', font: 'sistema', chatFont: 18, scale: 1.1 } }),
     });
     assert.equal(put.status, 200);
     const saved = (await put.json()).settings.appearance;
-    assert.deepEqual(saved, { theme: 'nord', font: 'plex', chatFont: 18, scale: 1.1 });
-    assert.equal(readApp().appearance.theme, 'nord');
+    assert.deepEqual(saved, { theme: 'github', font: 'sistema', chatFont: 18, scale: 1.1 });
+    assert.equal(readApp().appearance.theme, 'github');
 
     const reloaded = (await (await fetch(`${base}/api/settings`)).json()).settings.appearance;
     assert.deepEqual(reloaded, saved);