@danieltmn/tamnora 0.16.1 → 0.17.0

package/CHANGELOG.md

@@ -5,6 +5,13 @@ Todos los cambios relevantes de este proyecto se documentan en este archivo.
 El formato sigue [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/)
 y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.17.0] - 2026-10-11
+
+### Cambios
+
+- docs: procesos de desarrollo e interrumpir el turno
+- feat: procesos por proyecto, /port y /portkill, e interrumpir el turno
+
 ## [0.16.1] - 2026-10-10
 
 ### Cambios

package/README.md

@@ -117,6 +117,10 @@ menu "mas" (los tres puntitos). En el chat:
   volver, la consola **reconecta** y reconstruye el progreso. Para cortarlo se usa
   el boton de detener (o `POST /api/sessions/:id/stop`), que ademas corta el stream
   del modelo y mata las tools de larga duracion (p. ej. `bash`) en curso.
+- **Encolar o interrumpir**: si el agente esta trabajando, lo que envias queda en
+  una **cola** visible y se manda al terminar. Para cortarlo y mandar el mensaje
+  **ya**, usa el boton **interrumpir** (⚡) o **Ctrl/Cmd+Enter**: cancela el turno en
+  curso y arranca el nuevo apenas se desenrolla.
 - **Solo lo pedido (estricto)**: el toggle de la pestaña Agente (o `PUT
   /api/settings` con `strictScope`) hace que el agente se limite a lo solicitado,
   sin mejoras ni cambios extra; se combina con Plan o Build.
@@ -128,7 +132,8 @@ menu "mas" (los tres puntitos). En el chat:
 - **Actualizar**: cuando npm tiene una version nueva aparece un banner para
   actualizar con un click; el server se reinicia solo.
 - **Comandos**: el input muestra un menu al escribir `/` (`/new`, `/init`, `/goal`,
-  `/resumen`, `/audioresumen`, `/compact`, `/clear`, `/cwd`, `/kill`, `/help`).
+  `/resumen`, `/audioresumen`, `/compact`, `/clear`, `/cwd`, `/port`, `/portkill`,
+  `/help`).
 - **Capturas**: el tool `screenshot` muestra la imagen inline en su tarjeta.
 
 ### Memoria, reglas y automatizacion
@@ -174,6 +179,21 @@ Laravel, PHP) y abrir un tunel al puerto para verlo desde el celular. Para sitio
 **estaticos** (un `index.html` sin script de dev) ofrece un chip "sitio estatico"
 que los sirve con un servidor sin dependencias (`harness/scripts/static-server.mjs`).
 
+En un **monorepo** donde cada parte arranca distinto, el proyecto declara sus
+procesos en `.tamnora/procs.json` (relativo al proyecto seleccionado); salen
+primero, se suman a los detectados y **solo** se pueden lanzar los que pasan por
+la allowlist `processes.allow`:
+
+```jsonc
+{ "processes": [
+  { "label": "backend",  "dir": "backend",  "command": "node", "args": ["index.js"], "port": 3000 },
+  { "label": "frontend", "dir": "frontend", "command": "npm",  "args": ["run", "dev"], "port": 5173 }
+] }
+```
+
+Los puertos se consultan y se liberan desde el chat: `/port <puerto>` dice si esta
+activo (y que PID lo usa) y `/portkill <puerto>` mata el proceso que lo escucha.
+
 El visor de archivos tiene **vista previa**: `.html`/`.svg` se sirven con sus CSS,
 JS e imagenes relativas, y `.md` se renderiza como markdown. Ambas vistas suman
 selector de tamano (movil/tablet/laptop/pc/adaptable) y boton para maximizar.

package/harness/packages/core/src/index.js

@@ -157,8 +157,8 @@ export {
 export { reconocerGoogle, wavToPcm } from './stt/google.js';
 export { pidAlive, killPidTree } from './pid.js';
 export { openBrowser, openerFor } from './open.js';
-export { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW, staticServerChip } from './procs/detect.js';
-export { killPort } from './procs/kill.js';
+export { detectProcs, loadProjectProcs, packageManager, DEFAULT_PROCESS_ALLOW, staticServerChip, PROCS_FILE } from './procs/detect.js';
+export { killPort, portInfo, pidsOnPort } from './procs/kill.js';
 export {
   ROOT_PACKAGE_NAME,
   readPackageVersion,

package/harness/packages/core/src/procs/detect.js

@@ -24,12 +24,53 @@ const SCRIPT_ORDER = ['dev', 'start', 'serve', 'preview'];
 const STATIC_SERVER = fileURLToPath(new URL('../../../../scripts/static-server.mjs', import.meta.url));
 const STATIC_PORT = 8080;
 
+/** Archivo por proyecto (relativo a su raiz) que define sus procesos de dev. */
+export const PROCS_FILE = '.tamnora/procs.json';
+
 function findStaticRoot(dir) {
   if (existsSync(path.join(dir, 'index.html'))) return '.';
   if (existsSync(path.join(dir, 'public', 'index.html'))) return 'public';
   return null;
 }
 
+/** True si `target` es `root` o vive dentro de el (sin salirse por `..`). */
+function isInside(root, target) {
+  const rel = path.relative(root, target);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+/**
+ * Procesos definidos a mano por el proyecto en `<root>/.tamnora/procs.json`.
+ * Formato: `{ "processes": [{ label?, dir?, command, args?, port? }] }` o un array
+ * directo. `dir` es relativo a la raiz y debe quedar dentro de ella. Cada chip
+ * sigue pasando por la whitelist (`processes.allow`) al arrancar.
+ */
+export function loadProjectProcs(root) {
+  const file = path.join(root, PROCS_FILE);
+  if (!existsSync(file)) return [];
+  const raw = readJson(file);
+  const list = Array.isArray(raw) ? raw : Array.isArray(raw?.processes) ? raw.processes : [];
+  const chips = [];
+  for (const entry of list) {
+    if (!entry || typeof entry !== 'object') continue;
+    const command = String(entry.command ?? '').trim();
+    if (!command) continue;
+    const rel = String(entry.dir ?? '').trim().replace(/^[/\\]+/, '');
+    const cwd = path.resolve(root, rel || '.');
+    if (!isInside(root, cwd) || !existsSync(cwd)) continue;
+    const port = entry.port ? Number(entry.port) : undefined;
+    chips.push({
+      label: String(entry.label ?? command).trim() || command,
+      command,
+      args: Array.isArray(entry.args) ? entry.args.map(String) : [],
+      cwd,
+      port: Number.isInteger(port) && port > 0 ? port : undefined,
+      source: 'project',
+    });
+  }
+  return chips;
+}
+
 /** Chip para servir `dir` como sitio estático con el servidor sin dependencias. */
 export function staticServerChip(dir, { port = STATIC_PORT, label } = {}) {
   return {
@@ -59,9 +100,9 @@ export function packageManager(dir) {
   return 'npm';
 }
 
-/** Devuelve chips `{ label, command, args, cwd }` para arrancar el proyecto. */
+/** Devuelve chips `{ label, command, args, cwd, source }` para arrancar el proyecto. */
 export function detectProcs(dir) {
-  const chips = [];
+  const auto = [];
   const pkg = readJson(path.join(dir, 'package.json'));
   if (pkg?.scripts && typeof pkg.scripts === 'object') {
     const pm = packageManager(dir);
@@ -70,29 +111,39 @@ export function detectProcs(dir) {
       const first = Object.keys(pkg.scripts)[0];
       if (first) names.push(first);
     }
-    for (const name of names) chips.push({ label: `${name} (${pm})`, command: pm, args: ['run', name], cwd: dir });
+    for (const name of names) auto.push({ label: `${name} (${pm})`, command: pm, args: ['run', name], cwd: dir });
   }
 
   if (existsSync(path.join(dir, 'artisan'))) {
-    chips.push({ label: 'artisan serve', command: 'php', args: ['artisan', 'serve'], cwd: dir });
+    auto.push({ label: 'artisan serve', command: 'php', args: ['artisan', 'serve'], cwd: dir });
   } else if (readJson(path.join(dir, 'composer.json'))?.scripts?.dev) {
-    chips.push({ label: 'composer dev', command: 'composer', args: ['run', 'dev'], cwd: dir });
+    auto.push({ label: 'composer dev', command: 'composer', args: ['run', 'dev'], cwd: dir });
   }
 
   for (const rel of ['public/index.php', 'backend/public/index.php', 'index.php']) {
     if (!existsSync(path.join(dir, rel))) continue;
     const docroot = path.dirname(rel) === '.' ? '.' : path.dirname(rel);
-    chips.push({ label: `php -S (${rel})`, command: 'php', args: ['-S', '127.0.0.1:8000', '-t', docroot], cwd: dir });
+    auto.push({ label: `php -S (${rel})`, command: 'php', args: ['-S', '127.0.0.1:8000', '-t', docroot], cwd: dir });
     break;
   }
 
-  if (!chips.length) {
+  if (!auto.length) {
     const staticRoot = findStaticRoot(dir);
     if (staticRoot) {
       const target = staticRoot === '.' ? dir : path.join(dir, staticRoot);
-      chips.push(staticServerChip(target));
+      auto.push(staticServerChip(target));
     }
   }
 
+  const chips = [];
+  const seen = new Set();
+  const add = (chip) => {
+    const key = `${chip.command}|${(chip.args ?? []).join(' ')}|${chip.cwd ?? ''}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    chips.push(chip);
+  };
+  for (const chip of loadProjectProcs(dir)) add(chip);
+  for (const chip of auto) add({ ...chip, source: 'auto' });
   return chips;
 }

package/harness/packages/core/src/procs/kill.js

@@ -71,16 +71,37 @@ async function pidsOnUnix(port) {
   return [];
 }
 
+function validPort(port) {
+  const value = Number(port);
+  if (!Number.isInteger(value) || value < 1 || value > 65535) {
+    throw new Error('Puerto inválido (usá 1-65535).');
+  }
+  return value;
+}
+
+/** PIDs escuchando en `port` (Windows `netstat` o Unix lsof/fuser/ss). */
+export async function pidsOnPort(port) {
+  const value = validPort(port);
+  return process.platform === 'win32' ? pidsOnWindows(value) : pidsOnUnix(value);
+}
+
+/**
+ * Estado de un puerto.
+ * @returns {Promise<{port:number,listening:boolean,pids:number[]}>}
+ */
+export async function portInfo(port) {
+  const value = validPort(port);
+  const pids = await pidsOnPort(value);
+  return { port: value, listening: pids.length > 0, pids };
+}
+
 /**
  * Kill every process listening on `port`.
  * @returns {Promise<{port:number,pids:number[],killed:number[],errors:string[]}>}
  */
 export async function killPort(port) {
-  const value = Number(port);
-  if (!Number.isInteger(value) || value < 1 || value > 65535) {
-    throw new Error('Puerto inválido (usá 1-65535).');
-  }
-  const pids = process.platform === 'win32' ? await pidsOnWindows(value) : await pidsOnUnix(value);
+  const value = validPort(port);
+  const pids = await pidsOnPort(value);
   const killed = [];
   const errors = [];
   for (const pid of pids) {

package/harness/packages/core/test/procs.test.js

@@ -5,8 +5,8 @@ import net from 'node:net';
 import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW } from '../src/procs/detect.js';
-import { killPort } from '../src/procs/kill.js';
+import { detectProcs, loadProjectProcs, packageManager, DEFAULT_PROCESS_ALLOW, PROCS_FILE } from '../src/procs/detect.js';
+import { killPort, portInfo } from '../src/procs/kill.js';
 
 async function waitForPort(port, attempts = 50) {
   for (let i = 0; i < attempts; i++) {
@@ -99,3 +99,71 @@ test('detectProcs does not add the static chip when there is a dev script', asyn
   await writeFile(path.join(dir, 'package.json'), JSON.stringify({ scripts: { dev: 'vite' } }));
   assert.ok(!detectProcs(dir).some((c) => c.args.some((a) => String(a).endsWith('static-server.mjs'))));
 });
+
+test('loadProjectProcs reads .tamnora/procs.json and confines dir to the root', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
+  await mkdir(path.join(dir, '.tamnora'), { recursive: true });
+  await mkdir(path.join(dir, 'backend'));
+  await writeFile(
+    path.join(dir, PROCS_FILE),
+    JSON.stringify({
+      processes: [
+        { label: 'backend', dir: 'backend', command: 'node', args: ['index.js'], port: 3000 },
+        { label: 'afuera', dir: '..', command: 'node', args: ['evil.js'] },
+        { label: 'sin dir', command: 'npm', args: ['run', 'dev'] },
+      ],
+    })
+  );
+
+  const chips = loadProjectProcs(dir);
+  assert.equal(chips.length, 2, 'descarta el dir que se escapa');
+  assert.equal(chips[0].cwd, path.join(dir, 'backend'));
+  assert.equal(chips[0].port, 3000);
+  assert.equal(chips[0].source, 'project');
+  assert.equal(chips[1].cwd, dir);
+  assert.ok(chips.every((c) => c.source === 'project'));
+});
+
+test('detectProcs puts project chips first and dedupes against auto-detection', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
+  await mkdir(path.join(dir, '.tamnora'), { recursive: true });
+  await writeFile(path.join(dir, 'package.json'), JSON.stringify({ scripts: { dev: 'vite' } }));
+  await writeFile(
+    path.join(dir, PROCS_FILE),
+    JSON.stringify({
+      processes: [
+        { label: 'backend', command: 'node', args: ['server.js'], port: 3000 },
+        { label: 'dev repetido', command: 'npm', args: ['run', 'dev'] },
+      ],
+    })
+  );
+
+  const chips = detectProcs(dir);
+  assert.equal(chips[0].source, 'project');
+  assert.equal(chips[0].command, 'node');
+  const devChips = chips.filter((c) => c.command === 'npm' && c.args.join(' ') === 'run dev');
+  assert.equal(devChips.length, 1, 'el chip manual gana al autodetectado');
+});
+
+test('portInfo reports whether a port is listening', async (t) => {
+  const free = await portInfo(47599);
+  assert.equal(free.listening, false);
+  assert.deepEqual(free.pids, []);
+  await assert.rejects(() => portInfo(0), /Puerto inválido/);
+
+  const port = 48000 + Math.floor(Math.random() * 1000);
+  const script = `const http=require('node:http');http.createServer((q,r)=>r.end('ok')).listen(${port},'127.0.0.1');setInterval(()=>{},1000);`;
+  const child = spawn(process.execPath, ['-e', script], { stdio: 'ignore', windowsHide: true });
+  t.after(() => {
+    try {
+      child.kill('SIGKILL');
+    } catch {
+      // already gone
+    }
+  });
+  await waitForPort(port);
+  const info = await portInfo(port);
+  assert.equal(info.port, port);
+  assert.equal(info.listening, true);
+  assert.ok(info.pids.length >= 1);
+});

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

@@ -824,7 +824,13 @@ const chatForm = $('#chat-form');
 const chatInput = $('#chat-input');
 const submitBtn = chatForm.querySelector('button[type="submit"]');
 const stopBtn = $('#stop-btn');
+const interruptBtn = $('#interrupt-btn');
 const controllers = new Map();
+// `whenIdle` espera a que el turno de una sesion termine (lo usa "interrumpir").
+const idleWaiters = new Map();
+// Sesiones donde el turno actual se esta cortando a proposito: `drainQueue` no
+// debe arrancar un mensaje al final de ese turno (lo arranca el interruptor).
+const interrupting = new Set();
 const sessionsEl = $('#sessions');
 
 let activePane = blankPane;
@@ -1874,6 +1880,7 @@ function activateSession(id) {
   showPane(id);
   if (record.cwd) setCwd(record.cwd);
   if (stopBtn) stopBtn.hidden = !record.working;
+  syncInterruptBtn();
   auditStatus(record);
   updateStatus();
   renderTokens();
@@ -1891,6 +1898,39 @@ function updateSubmitLabel(working) {
   submitBtn.title = working ? 'El agente está trabajando: se envía al terminar' : 'enviar';
 }
 
+/** El boton de interrumpir solo tiene sentido con un turno en curso y texto que mandar. */
+function syncInterruptBtn() {
+  if (!interruptBtn) return;
+  const record = state.panes.get(state.sessionId);
+  const working = Boolean(record?.working);
+  const hasInput = Boolean(chatInput.value.trim()) || state.attachments.length > 0;
+  interruptBtn.hidden = !working;
+  interruptBtn.disabled = !working || !hasInput;
+}
+
+/** Promesa que resuelve cuando el turno de la sesion deja de estar activo. */
+function whenIdle(sessionKey, timeoutMs = 8000) {
+  const record = state.panes.get(sessionKey);
+  if (!record?.working) return Promise.resolve();
+  return new Promise((resolve) => {
+    let timer = null;
+    const settle = () => {
+      if (timer) clearTimeout(timer);
+      const list = idleWaiters.get(sessionKey);
+      if (list) {
+        const index = list.indexOf(settle);
+        if (index >= 0) list.splice(index, 1);
+        if (!list.length) idleWaiters.delete(sessionKey);
+      }
+      resolve();
+    };
+    timer = setTimeout(settle, timeoutMs);
+    const list = idleWaiters.get(sessionKey) ?? [];
+    list.push(settle);
+    idleWaiters.set(sessionKey, list);
+  });
+}
+
 function auditStatus(record) {
   submitBtn.disabled = false;
   updateSubmitLabel(record.working);
@@ -1941,10 +1981,18 @@ function setWorking(id, working) {
   // solo se recupera recargando.
   if (record) record.working = record.attached = working;
   renderTabs();
+  if (!working) {
+    const waiters = idleWaiters.get(id);
+    if (waiters) {
+      idleWaiters.delete(id);
+      for (const settle of [...waiters]) settle();
+    }
+  }
   if (id === state.sessionId) {
     submitBtn.disabled = false;
     updateSubmitLabel(working);
     if (stopBtn) stopBtn.hidden = !working;
+    syncInterruptBtn();
     $('#sb-rounds').textContent = working ? '' : 'listo';
     $('#sb-rounds').classList.toggle('running', working);
     renderFooterActivity(working ? 'thinking' : null);
@@ -2361,7 +2409,7 @@ function contextTokensForRequest() {
   return context ? Math.floor(context * 0.8) : undefined;
 }
 
-async function startTurn(sessionKey, pane, input, images) {
+async function startTurn(sessionKey, pane, input, images, opts = {}) {
   const user = addMessage('user', input || `(${images.length} imagen${images.length > 1 ? 'es' : ''})`, pane);
   appendImages(user, images);
   const turn = createChatTurn(pane, sessionKey);
@@ -2386,6 +2434,7 @@ async function startTurn(sessionKey, pane, input, images) {
         mode: modeSelect.value || undefined,
         yes: yesInput.checked ? true : undefined,
         contextTokens: contextTokensForRequest(),
+        interrupt: opts.interrupt ? true : undefined,
       },
       (event, data, id) => {
         if (id !== null) turn.cursor = Number(id) || turn.cursor;
@@ -2463,6 +2512,9 @@ function renderQueue(sessionKey = state.sessionId) {
 function drainQueue(sessionKey) {
   const record = state.panes.get(sessionKey);
   if (!record || record.working) return;
+  // Mientras se interrumpe, el mensaje que manda el usuario lo arranca
+  // `interruptAndSend`, no la cola.
+  if (interrupting.has(sessionKey)) return;
   const list = queueFor(sessionKey);
   if (!list.length) return;
   const next = list.shift();
@@ -2530,11 +2582,13 @@ async function sendMessage() {
   }
 
   // Si el agente está trabajando, el mensaje queda en cola y se envía solo.
+  // Para cortarlo y mandar el mensaje ya, está el botón/atajo de interrumpir.
   if (current?.working) {
     enqueueMessage(state.sessionId, input, images);
     chatInput.value = '';
     state.attachments = [];
     renderAttachments();
+    syncInterruptBtn();
     return;
   }
 
@@ -2572,12 +2626,55 @@ if (stopBtn) {
   });
 }
 
+/**
+ * Interrumpe el turno en curso y manda `input`/`images` ya mismo.
+ *
+ * Marcamos la sesion en `interrupting` para que el `finally` del turno viejo no
+ * dispare la cola (lo arrancamos nosotros). Esperamos a que el turno anterior se
+ * desenrolle antes de empezar el nuevo; el server, por su lado, cancela el run y
+ * espera a que termine antes de aceptar el POST con `interrupt: true`.
+ */
+async function interruptAndSend(sessionKey, input, images) {
+  const record = state.panes.get(sessionKey);
+  if (!record) return;
+  interrupting.add(sessionKey);
+  controllers.get(sessionKey)?.abort();
+  await whenIdle(sessionKey);
+  const promise = startTurn(sessionKey, record.el, input, images, { interrupt: true });
+  // startTurn ya arranco (working=true y controller nuevo); soltamos el guardia
+  // para que SU finally pueda drenar la cola.
+  interrupting.delete(sessionKey);
+  await promise;
+}
+
+function sendInterrupt() {
+  const record = state.panes.get(state.sessionId);
+  if (!record?.working) return;
+  const input = chatInput.value.trim();
+  // Los comandos (`/…`, `!…`) se resuelven por su camino normal, no interrumpen.
+  if (input.startsWith('/') || input.startsWith('!')) return sendMessage();
+  const images = state.attachments.slice();
+  if (!input && !images.length) return;
+  chatInput.value = '';
+  state.attachments = [];
+  renderAttachments();
+  syncInterruptBtn();
+  interruptAndSend(state.sessionId, input, images);
+}
+
+if (interruptBtn) interruptBtn.addEventListener('click', sendInterrupt);
+
 chatForm.addEventListener('submit', (event) => {
   event.preventDefault();
   sendMessage();
 });
 chatInput.addEventListener('keydown', (event) => {
   if (handleSlashKey(event)) return;
+  if (event.key === 'Enter' && (event.ctrlKey || event.metaKey)) {
+    event.preventDefault();
+    sendInterrupt();
+    return;
+  }
   if (event.key === 'Enter' && !event.shiftKey) {
     event.preventDefault();
     sendMessage();
@@ -3041,7 +3138,8 @@ const COMMANDS = [
   ['/compact', 'resumir la conversación y liberar contexto'],
   ['/clear', 'borrar los mensajes de esta sesión'],
   ['/cwd', 'mostrar la carpeta de trabajo'],
-  ['/kill <puerto>', 'matar el proceso que escucha en un puerto'],
+  ['/port <puerto>', 'ver si un puerto está activo (y qué PID lo usa)'],
+  ['/portkill <puerto>', 'matar el proceso que escucha en un puerto'],
   ['/help', 'mostrar esta ayuda'],
 ];
 
@@ -3104,13 +3202,14 @@ async function runCommand(name, arg) {
       notify(`Carpeta de trabajo: \`${cwd}\``);
       return { handled: true };
     }
+    case 'portkill':
     case 'kill': {
       const port = Number(arg);
       if (!Number.isInteger(port) || port < 1 || port > 65535) {
-        notify('Uso: `/kill <puerto>`, por ejemplo `/kill 3000`.', 'notice err');
+        notify('Uso: `/portkill <puerto>`, por ejemplo `/portkill 3000`.', 'notice err');
         return { handled: true };
       }
-      const out = await api('/api/procs/kill', { method: 'POST', body: { port } }).catch((error) => ({
+      const out = await api('/api/ports/kill', { method: 'POST', body: { port } }).catch((error) => ({
         error: error.message,
       }));
       if (out.error) notify(`No se pudo matar el puerto ${port}: ${out.error}`, 'notice err');
@@ -3119,6 +3218,18 @@ async function runCommand(name, arg) {
       else notify(`Puerto ${port}: no se pudo matar (PID ${out.errors.join(', ')}).`, 'notice err');
       return { handled: true };
     }
+    case 'port': {
+      const port = Number(arg);
+      if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        notify('Uso: `/port <puerto>`, por ejemplo `/port 3000`.', 'notice err');
+        return { handled: true };
+      }
+      const out = await api(`/api/ports/${port}`).catch((error) => ({ error: error.message }));
+      if (out.error) notify(`No se pudo consultar el puerto ${port}: ${out.error}`, 'notice err');
+      else if (out.listening) notify(`Puerto ${port}: **activo** (PID ${out.pids.join(', ')}).`);
+      else notify(`Puerto ${port}: nada escuchando.`);
+      return { handled: true };
+    }
     case 'clear':
     case 'limpiar': {
       if (!state.sessionId) return needSession();
@@ -3274,6 +3385,7 @@ function handleSlashKey(event) {
 function onChatInputChanged() {
   slashIndex = 0;
   updateSlashMenu();
+  syncInterruptBtn();
 }
 
 chatInput.addEventListener('blur', () => setTimeout(hideSlashMenu, 120));
@@ -5508,8 +5620,19 @@ async function detectProcs() {
   procsCwdEl.textContent = cwd ? `cwd: ${cwd}` : 'sin carpeta';
   const data = await api(`/api/procs/detect?cwd=${encodeURIComponent(cwd)}`).catch(() => null);
   if (!data) return;
-  for (const chip of data.chips) procsChipsEl.appendChild(button(chip.label, () => startProc(chip), 'xchip'));
+  for (const chip of data.chips) {
+    const node = button(chip.label, () => startProc(chip), 'xchip');
+    if (chip.source === 'project') node.title = 'definido en .tamnora/procs.json';
+    if (chip.allowed === false) {
+      node.disabled = true;
+      node.title = `"${chip.command}" no está en processes.allow`;
+    }
+    procsChipsEl.appendChild(node);
+  }
   if (!data.chips.length) procsChipsEl.appendChild(el('span', 'muted', 'no detecté comandos de dev'));
+  else if (data.chips.some((c) => c.source === 'project')) {
+    procsChipsEl.appendChild(el('span', 'muted', '· desde .tamnora/procs.json'));
+  }
   await refreshProcs();
 }
 

package/harness/packages/server/public/index.html

@@ -37,7 +37,7 @@
   </head>
   <body>
     <header class="topbar">
-      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span id="topbar-section" class="topbar-section">chat</span> <span class="ver">v0.16.1</span></div>
+      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span id="topbar-section" class="topbar-section">chat</span> <span class="ver">v0.17.0</span></div>
       <nav class="tabs">
         <button class="tab active" data-tab="chat">chat</button>
         <button class="tab" data-tab="providers">proveedores</button>
@@ -209,6 +209,9 @@
               <button class="send-btn" type="submit" aria-label="enviar" title="enviar">
                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m5 12 7-7 7 7" /><path d="M12 19V5" /></svg>
               </button>
+              <button class="add-btn interrupt-btn" type="button" id="interrupt-btn" title="Interrumpir al agente y enviar este mensaje (Ctrl+Enter)" aria-label="interrumpir y enviar" hidden>
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M13 2 3 14h9l-1 8 10-12h-9l1-8z" /></svg>
+              </button>
               <button class="add-btn" type="button" id="stop-btn" title="Detener la respuesta" aria-label="detener" hidden>
                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="6" y="6" width="12" height="12" rx="2" /></svg>
               </button>

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

@@ -1018,6 +1018,10 @@ details.reasoning .body { color: var(--muted); white-space: pre-wrap; margin-top
 .send-btn:hover { filter: brightness(1.08); }
 .send-btn:disabled { opacity: 0.5; cursor: default; }
 .send-btn[data-working="1"] { background: var(--theirs); color: var(--accent); border-color: var(--accent); }
+/* Interrumpir: corta el turno en curso y manda el mensaje ya. */
+.interrupt-btn { color: var(--accent); border-color: var(--accent); }
+.interrupt-btn:hover { background: var(--accent); color: var(--primary-fg); }
+.interrupt-btn:disabled { opacity: 0.45; cursor: default; color: var(--muted); border-color: var(--border); }
 /* Dictado activo: verde titilando (cuenta regresiva y grabación). */
 .add-btn.recording { color: #2eb872; border-color: currentColor; animation: live-pulse 1s ease-in-out infinite; }
 .add-btn.busy { opacity: 0.55; }
@@ -1407,8 +1411,8 @@ pre.code code { background: none; border: 0; padding: 0; font-size: 0.92em; }
 .explorer-head { display: flex; align-items: center; gap: 6px; padding: 9px 12px; border-bottom: 1px solid var(--border); min-width: 0; }
 .explorer-title { font: 700 14px var(--serif); letter-spacing: -0.02em; }
 .explorer-head .spacer { flex: 1; }
-/* Los botones de accion (refrescar/cerrar) nunca se recortan: las pestanas se
-   angostan y hacen scroll horizontal en vez de empujarlos fuera del panel. */
+/* Los botones de accion (refrescar/cerrar) nunca se recortan: las pestanas
+   bajan a una segunda fila (wrap) en vez de empujarlos fuera o desaparecer. */
 .explorer-head .btn.icon { flex: 0 0 auto; }
 .explorer-cwd { padding: 9px 12px 0; color: var(--muted); font: 500 11px var(--mono); word-break: break-all; }
 .explorer-cwd:empty { display: none; }
@@ -1430,8 +1434,7 @@ pre.code code { background: none; border: 0; padding: 0; font-size: 0.92em; }
 .explorer-status { padding: 6px 12px; border-top: 1px solid var(--border); color: var(--muted); font: 500 11px var(--mono); min-height: 27px; }
 .explorer-status.err { color: var(--danger); }
 
-.xtabs { display: flex; gap: 4px; min-width: 0; flex: 0 1 auto; overflow-x: auto; scrollbar-width: none; }
-.xtabs::-webkit-scrollbar { display: none; }
+.xtabs { display: flex; flex-wrap: wrap; gap: 4px; min-width: 0; flex: 0 1 auto; }
 .xtab { flex: 0 0 auto; border: 0; background: none; color: var(--muted); cursor: pointer; font: 600 12px var(--sans); padding: 4px 7px; border-radius: 7px; }
 .xtab:hover { background: var(--theirs); color: var(--text); }
 .xtab.is-active { background: var(--theirs); color: var(--text); }

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

@@ -36,11 +36,17 @@ export function createProcManager({ allow } = {}) {
   );
   const procs = new Map();
 
+  function allows(bin) {
+    const value = String(bin ?? '').trim();
+    if (!value) return false;
+    const base = path.basename(value).replace(/\.(exe|cmd|bat)$/i, '').toLowerCase();
+    return allowed.has(base) || allowed.has(value.toLowerCase());
+  }
+
   function start({ cwd, command, args = [], port } = {}) {
     const bin = String(command ?? '').trim();
     if (!bin) throw new Error('Falta el comando.');
-    const base = path.basename(bin).replace(/\.(exe|cmd|bat)$/i, '').toLowerCase();
-    if (!allowed.has(base) && !allowed.has(bin.toLowerCase())) {
+    if (!allows(bin)) {
       throw new Error(`Comando no permitido: ${bin}. Agregalo a processes.allow en tamnora.json.`);
     }
     const child = spawn(bin, args.map(String), {
@@ -106,5 +112,5 @@ export function createProcManager({ allow } = {}) {
     procs.clear();
   }
 
-  return { start, stop, list, logs, close, allowed: [...allowed] };
+  return { start, stop, list, logs, close, allows, allowed: [...allowed] };
 }

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

@@ -10,6 +10,15 @@
 export function createRunManager({ store }) {
   const runs = new Map();
   const listeners = new Set();
+  // Resolvers esperando a que el run de una sesion termine (`waitForIdle`).
+  const idleWaiters = new Map();
+
+  function settleIdle(sessionId) {
+    const waiters = idleWaiters.get(sessionId);
+    if (!waiters) return;
+    idleWaiters.delete(sessionId);
+    for (const resolve of waiters) resolve();
+  }
 
   function persist(run, sessionId, type, data, agentId) {
     const coalesce =
@@ -82,6 +91,7 @@ export function createRunManager({ store }) {
     run.subscribers.clear();
     runs.delete(sessionId);
     announce(sessionId, 'end', { durationMs: Date.now() - run.startedAt });
+    settleIdle(sessionId);
   }
 
   function cancel(sessionId) {
@@ -92,7 +102,24 @@ export function createRunManager({ store }) {
     const active = [...runs.values()];
     for (const run of active) run.controller.abort();
     runs.clear();
-    for (const run of active) announce(run.sessionId, 'end', { durationMs: Date.now() - run.startedAt, reason: 'shutdown' });
+    for (const run of active) {
+      announce(run.sessionId, 'end', { durationMs: Date.now() - run.startedAt, reason: 'shutdown' });
+      settleIdle(run.sessionId);
+    }
+  }
+
+  /**
+   * Promesa que resuelve cuando el run de la sesion ya no esta activo. Sirve
+   * para "interrumpir": cancelar el run actual y esperar a que se desenrolle
+   * antes de arrancar el siguiente (si no, `start` devuelve null y se pierde).
+   */
+  function waitForIdle(sessionId) {
+    if (!runs.has(sessionId)) return Promise.resolve();
+    return new Promise((resolve) => {
+      const waiters = idleWaiters.get(sessionId) ?? [];
+      waiters.push(resolve);
+      idleWaiters.set(sessionId, waiters);
+    });
   }
 
   function isActive(sessionId) {
@@ -120,5 +147,5 @@ export function createRunManager({ store }) {
     return () => listeners.delete(fn);
   }
 
-  return { emit, start, finish, cancel, cancelAll, isActive, signal, subscribe, subscribeAll, activeSessions };
+  return { emit, start, finish, cancel, cancelAll, isActive, waitForIdle, signal, subscribe, subscribeAll, activeSessions };
 }

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

@@ -155,7 +155,15 @@ export function registerChat(route, ctx) {
     }
 
     if (ctx.runs.isActive(sessionId)) {
-      return sendError(res, 409, 'La sesión ya tiene una respuesta en curso.');
+      // "Interrumpir": si el cliente lo pide, cancelamos el run en curso y
+      // esperamos a que se desenrolle antes de arrancar el nuevo. Sin esto, un
+      // segundo mensaje del mismo cliente chocaria con el 409.
+      if (body.interrupt !== true) {
+        return sendError(res, 409, 'La sesión ya tiene una respuesta en curso.');
+      }
+      ctx.runs.cancel(sessionId);
+      ctx.approvals.cancelForSession(sessionId);
+      await ctx.runs.waitForIdle(sessionId);
     }
 
     const mode = resolveMode(body.mode ?? ctx.store.getSetting('activeMode'));

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

@@ -1,4 +1,4 @@
-import { detectProcs, killPort } from '../lib/core.js';
+import { detectProcs, killPort, portInfo } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 import { requireLocal, resolveDirOr400 } from '../lib/workspace.js';
 
@@ -8,9 +8,11 @@ export function registerProcs(route, ctx) {
   });
 
   route('GET', '/api/procs/detect', ({ res, query }) => {
+    if (!ctx.procsEnabled) return sendJson(res, 200, { cwd: ctx.cwd, chips: [] });
     const dir = resolveDirOr400(res, query.get('cwd'), ctx.cwd);
     if (!dir) return;
-    sendJson(res, 200, { cwd: dir, chips: detectProcs(dir) });
+    const chips = detectProcs(dir).map((chip) => ({ ...chip, allowed: ctx.procs.allows(chip.command) }));
+    sendJson(res, 200, { cwd: dir, chips });
   });
 
   route('POST', '/api/procs/start', async ({ req, res }) => {
@@ -43,7 +45,7 @@ export function registerProcs(route, ctx) {
     sendJson(res, 200, { ok: true });
   });
 
-  route('POST', '/api/procs/kill', async ({ req, res }) => {
+  async function killPortHandler({ req, res }) {
     if (!requireLocal(req, res, 'Matar procesos solo está disponible en conexiones locales.')) {
       return;
     }
@@ -53,5 +55,20 @@ export function registerProcs(route, ctx) {
     } catch (error) {
       sendError(res, 400, error.message);
     }
+  }
+
+  route('POST', '/api/procs/kill', killPortHandler);
+
+  route('POST', '/api/ports/kill', killPortHandler);
+
+  route('GET', '/api/ports/:port', async ({ req, res, params }) => {
+    if (!requireLocal(req, res, 'Consultar puertos solo está disponible en conexiones locales.')) {
+      return;
+    }
+    try {
+      sendJson(res, 200, await portInfo(params.port));
+    } catch (error) {
+      sendError(res, 400, error.message);
+    }
   });
 }

package/harness/packages/server/test/server.test.js

@@ -262,7 +262,73 @@ test('keeps a run alive after the client disconnects and can stop it', async ()
   }
 });
 
-/** Lee un SSE hasta que `until(data)` se cumpla, y devuelve lo acumulado. */
+test('interrupt cancels the running turn and starts the new message right away', async () => {
+  const calls = { n: 0 };
+  let abortedFirst = false;
+  const provider = {
+    id: 'interrupt',
+    async streamChat(_config, { onEvent, signal }) {
+      calls.n += 1;
+      if (calls.n === 1) {
+        onEvent?.({ type: 'text', delta: 'trabajando', full: 'trabajando' });
+        await new Promise((resolve, reject) => {
+          const timer = setTimeout(resolve, 5000);
+          const onAbort = () => {
+            clearTimeout(timer);
+            abortedFirst = true;
+            reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+          };
+          if (signal?.aborted) return onAbort();
+          signal?.addEventListener('abort', onAbort, { once: true });
+        });
+      }
+      onEvent?.({ type: 'text', delta: 'listo', full: 'listo' });
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ model: 'm' }),
+      })
+    ).json();
+    const id = created.session.id;
+
+    const first = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'uno', model: 'm', sessionId: id }),
+    })
+      .then((res) => res.text())
+      .catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 80));
+
+    const second = await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'dos', model: 'm', sessionId: id, interrupt: true }),
+      })
+    ).text();
+
+    assert.match(second, /event: text/);
+    assert.match(second, /listo/);
+    assert.equal(abortedFirst, true);
+    await first;
+
+    await new Promise((resolve) => setTimeout(resolve, 60));
+    const after = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    assert.equal(after.running, false);
+  } finally {
+    await instance.close();
+  }
+});
+
+/** Lee un SSE hasta que `until(data)` se cumpla, y devuelve lo acumulado. */
 async function readSse(url, options, until, timeoutMs = 5000) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -1561,20 +1627,38 @@ test('runs a console shell command and kills a port', async () => {
     });
     assert.equal(missing.status, 400);
 
-    const badPort = await fetch(`${base}/api/procs/kill`, {
-      method: 'POST',
-      headers: json,
-      body: JSON.stringify({ port: 0 }),
-    });
-    assert.equal(badPort.status, 400);
-
-    const none = await fetch(`${base}/api/procs/kill`, {
-      method: 'POST',
-      headers: json,
-      body: JSON.stringify({ port: 47555 }),
-    });
-    assert.equal(none.status, 200);
-    assert.deepEqual((await none.json()).pids, []);
+    const badPort = await fetch(`${base}/api/procs/kill`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ port: 0 }),
+    });
+    assert.equal(badPort.status, 400);
+
+    const none = await fetch(`${base}/api/procs/kill`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ port: 47555 }),
+    });
+    assert.equal(none.status, 200);
+    assert.deepEqual((await none.json()).pids, []);
+
+    const status = await fetch(`${base}/api/ports/47555`);
+    assert.equal(status.status, 200);
+    const info = await status.json();
+    assert.equal(info.port, 47555);
+    assert.equal(info.listening, false);
+    assert.deepEqual(info.pids, []);
+
+    const aliasKill = await fetch(`${base}/api/ports/kill`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ port: 47555 }),
+    });
+    assert.equal(aliasKill.status, 200);
+    assert.deepEqual((await aliasKill.json()).pids, []);
+
+    const badStatus = await fetch(`${base}/api/ports/0`);
+    assert.equal(badStatus.status, 400);
   } finally {
     await instance.close();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",