@danieltmn/tamnora 0.7.1 → 0.9.0

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

@@ -1,8 +1,6 @@
-import { spawn } from 'node:child_process';
-import { appendFileSync, writeFileSync, readFileSync } from 'node:fs';
+import { writeFileSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import {
-  setHome,
   homeDir,
   ensureHome,
   homeExists,
@@ -12,10 +10,12 @@ import {
   databasePath,
   pidPath,
   serverLogPath,
+  openBrowser,
 } from '../../../core/src/index.js';
 import { createTamnoraServer } from '../../../server/src/index.js';
 import { parse, num } from '../lib/util.js';
 import {
+  applyHomeOverride,
   killPid,
   pidAlive,
   readRuntime,
@@ -23,6 +23,9 @@ import {
   clearRuntime,
   stopRunningServer,
   portHint,
+  createFileLogger,
+  spawnDetached,
+  waitForState,
   tailLines,
 } from '../lib/daemon.js';
 
@@ -42,29 +45,16 @@ const OPTIONS = {
   dir: { type: 'string' },
   home: { type: 'string' },
   force: { type: 'boolean' },
+  'no-open': { type: 'boolean' },
   yes: { type: 'boolean', short: 'y' },
   help: { type: 'boolean', short: 'h' },
 };
 
 function applyHome(values) {
-  const override = values.home ? path.resolve(values.home) : process.env.TAMNORA_HOME || null;
-  if (values.home) {
-    setHome(values.home);
-    process.env.TAMNORA_HOME = override;
-  }
-  return override;
+  applyHomeOverride(values);
 }
 
-function log(line) {
-  const text = `[${new Date().toISOString()}] ${line}`;
-  try {
-    ensureHome();
-    appendFileSync(serverLogPath(), `${text}\n`);
-  } catch {
-    /* sin log no detenemos nada */
-  }
-  console.log(text);
-}
+const log = createFileLogger(serverLogPath());
 
 export async function serverCommand(argv) {
   const { values } = parse(argv, OPTIONS);
@@ -118,34 +108,29 @@ async function cmdStart(values) {
   const isChild = Boolean(process.env.TAMNORA_DETACHED);
   const foreground = Boolean(values.stream || values.foreground) || isChild;
 
-  if (!isChild) {
+if (!isChild) {
     const cur = readRuntime();
     if (cur && pidAlive(cur.pid)) {
       console.log(`Tamnora ya esta corriendo (pid ${cur.pid}).`);
       printStatus(cur);
+      // Aprovechamos que ya esta sirviendo para abrir la consola.
+      if (!values['no-open']) await openBrowser(cur.url, { log: (line) => console.warn(line) });
       return 0;
     }
   }
 
-  if (!foreground) {
+if (!foreground) {
     const bin = process.argv[1];
     const args = [bin, 'server', '--stream', '--port', String(port), '--host', host];
     if (values.dir) args.push('--dir', cwd);
     if (process.env.TAMNORA_HOME) args.push('--home', process.env.TAMNORA_HOME);
     if (values.yes) args.push('--yes');
-    const child = spawn(process.execPath, args, {
-      detached: true,
-      stdio: 'ignore',
-      windowsHide: true,
-      env: { ...process.env, TAMNORA_DETACHED: '1' },
-    });
-    child.unref();
-    let dead = false;
-    child.on('exit', () => {
-      dead = true;
-    });
+    // El hijo es quien.listen() y por lo tanto quien abre el navegador: el flag
+    // tiene que viajar con el o `--no-open` no serviria de nada.
+    if (values['no-open']) args.push('--no-open');
+    const { child, isDead } = spawnDetached(args, { envFlag: 'TAMNORA_DETACHED' });
     console.log(`Tamnora arrancando en segundo plano (pid ${child.pid})...`);
-    const rt = await waitForRuntime(child.pid, () => dead, 30000);
+    const rt = await waitForState(() => readRuntime(), { childPid: child.pid, isDead, timeoutMs: 30000, tickMs: 400 });
     const tail = rt ? '' : tailLines(serverLogPath(), 8);
     if (tail) {
       console.log('');
@@ -202,10 +187,13 @@ async function runForeground({ values, port, host, cwd }) {
   } catch {
     /* nada */
   }
-  log(`Tamnora escuchando en ${info.url} (workspace ${cwd})`);
-  if (!instance.ctx.authEnabled) {
+log(`Tamnora escuchando en ${info.url} (workspace ${cwd})`);
+if (!instance.ctx.authEnabled) {
     log('aviso: sin usuario configurado; el server no pide login. Crea uno: tamnora user --name <n> --password <p>');
   }
+  // Abrir la consola es lo esperable al arrancar. Solo cuando queda escuchando:
+  // si hubo EADDRINUSE ya hay una consola abierta sirviendo.
+  if (!values['no-open']) await openBrowser(info.url, { log: (line) => log(line) });
 
   return new Promise((resolve) => {
     let closing = false;
@@ -247,8 +235,9 @@ async function cmdStop() {
 }
 
 async function cmdReload(values) {
+  const previous = readRuntime();
   await cmdStop();
-  for (let i = 0; i < 25 && pidAlive(readPid()); i++) {
+  for (let i = 0; i < 25 && previous?.pid && pidAlive(previous.pid); i++) {
     await new Promise((r) => setTimeout(r, 200));
   }
   return cmdStart(values);
@@ -308,20 +297,6 @@ function readPid() {
   }
 }
 
-function waitForRuntime(childPid, isDead, timeoutMs) {
-  return new Promise((resolve) => {
-    const start = Date.now();
-    const tick = () => {
-      if (isDead()) return resolve(null);
-      const rt = readRuntime();
-      if (rt && rt.pid && pidAlive(rt.pid) && (!childPid || rt.pid === childPid)) return resolve(rt);
-      if (Date.now() - start > timeoutMs) return resolve(null);
-      setTimeout(tick, 400);
-    };
-    tick();
-  });
-}
-
 function printHelp() {
   console.log(`Uso: tamnora server [accion] [opciones]
 
@@ -341,5 +316,6 @@ Opciones:
   --host <addr>     Interfaz (default: 127.0.0.1)
   --dir <path>      Workspace del server
   --home <path>     Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)
+  --no-open         No abrir la consola en el navegador al arrancar
   -y, --yes         Auto-aprobar tools con permiso "ask"`);
 }

package/harness/packages/cli/src/commands/tui.js

@@ -113,7 +113,7 @@ Opciones:
   --model <id>      Modelo (por defecto: el activo)
   --mode <id>       Modo de agente: agent | plan
   --dir <path>      Directorio del proyecto
-  --max-steps <n>   Máximo de rondas de herramientas
+  --max-steps <n>   Techo de rondas de herramientas (0 = sin límite, default)
   --tools <lista>   Tools habilitadas (coma)   --no-tools
   -y, --yes         Auto-aprobar tools con permiso "ask"`);
 }

package/harness/packages/cli/src/lib/daemon.js

@@ -1,69 +1,121 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { appendFileSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import path from 'node:path';
 import {
+  setHome,
+  ensureHome,
   runtimePath,
   pidPath,
-  bridgeLogPath,
+  bridgeStatePath,
   serverLogPath,
+  bridgeLogPath,
+  killPidTree,
+  pidAlive,
 } from '../../../core/src/index.js';
 
 /** Mata un proceso y su arbol de hijos (taskkill en Windows; grupo en POSIX). */
 export function killPid(pid) {
-  if (!pid) return;
-  try {
-    if (process.platform === 'win32') {
-      spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
-    } else {
+  killPidTree(pid);
+}
+
+export { pidAlive };
+
+/** Crea `setHome` + env TAMNORA_HOME a partir de `--home` (comun a CLI commands). */
+export function applyHomeOverride(values) {
+  if (!values?.home) return;
+  setHome(values.home);
+  process.env.TAMNORA_HOME = path.resolve(values.home);
+}
+
+/** read/write/clear de un archivo JSON de estado (runtime del server, bridge). */
+function jsonStateIO(file, { extraClear = [] } = {}) {
+  return {
+    read() {
       try {
-        process.kill(-pid, 'SIGTERM');
+        return JSON.parse(readFileSync(file, 'utf8'));
       } catch {
-        /* sin grupo propio */
+        return null;
       }
+    },
+    write(data) {
+      ensureHome();
       try {
-        process.kill(pid, 'SIGTERM');
+        writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`);
       } catch {
-        /* ya no esta */
+        /* sin estado no detenemos nada */
       }
-    }
-  } catch {
-    /* ya no esta */
-  }
+    },
+    clear() {
+      for (const f of [file, ...extraClear]) {
+        try {
+          unlinkSync(f);
+        } catch {
+          /* nada */
+        }
+      }
+    },
+  };
 }
 
-export function pidAlive(pid) {
-  if (!pid) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
+export const runtimeState = jsonStateIO(runtimePath(), { extraClear: [pidPath()] });
+export const bridgeState = jsonStateIO(bridgeStatePath());
 
 export function readRuntime() {
-  try {
-    return JSON.parse(readFileSync(runtimePath(), 'utf8'));
-  } catch {
-    return null;
-  }
+  return runtimeState.read();
 }
-
 export function writeRuntime(data) {
-  try {
-    writeFileSync(runtimePath(), `${JSON.stringify(data, null, 2)}\n`);
-  } catch {
-    /* sin runtime no detenemos nada */
-  }
+  runtimeState.write(data);
 }
-
 export function clearRuntime() {
-  for (const file of [runtimePath(), pidPath()]) {
+  runtimeState.clear();
+}
+
+/** Logger con timestamp a archivo + consola (server, bridge, tunnel). */
+export function createFileLogger(logPath) {
+  return (line) => {
+    const text = `[${new Date().toISOString()}] ${line}`;
     try {
-      unlinkSync(file);
+      ensureHome();
+      appendFileSync(logPath, `${text}\n`);
     } catch {
-      /* nada */
+      /* sin log no detenemos nada */
     }
-  }
+    console.log(text);
+  };
+}
+
+/** Hijo detached con un flag de env que marca que es el proceso child. */
+export function spawnDetached(args, { envFlag, env = process.env } = {}) {
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env: envFlag ? { ...env, [envFlag]: '1' } : { ...env },
+  });
+  child.unref();
+  let dead = false;
+  child.on('exit', () => {
+    dead = true;
+  });
+  return { child, isDead: () => dead };
+}
+
+/**
+ * Espera a que `readFn()` devuelva un estado cuyo pid este vivo (y sea el
+ * child esperado, si hay). Null si el child murio o vencio el timeout.
+ */
+export function waitForState(readFn, { childPid, isDead = () => false, timeoutMs = 30000, tickMs = 400 } = {}) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const tick = () => {
+      if (isDead()) return resolve(null);
+      const state = readFn();
+      if (state?.pid && pidAlive(state.pid) && (!childPid || state.pid === childPid)) return resolve(state);
+      if (Date.now() - start > timeoutMs) return resolve(null);
+      setTimeout(tick, tickMs);
+    };
+    tick();
+  });
 }
 
 /** PIDs escuchando en un puerto TCP (netstat en Windows; lsof en el resto). */

package/harness/packages/cli/test/release.test.js

@@ -32,3 +32,12 @@ test('renderChangelog promotes the Unreleased section', () => {
   assert.doesNotMatch(out, /## \[Unreleased\]/);
   assert.match(out, /## \[1\.0\.0\]/);
 });
+
+test('renderChangelog promotes the [No publicado] section', () => {
+  const cl = '# Changelog\n\n## [No publicado]\n\n### Agregado\n\n- algo\n\n## [1.0.0] - 2026-01-01\n\n- viejo\n';
+  const out = renderChangelog(cl, '1.1.0', '- nota', '2026-02-02');
+  assert.match(out, /## \[1\.1\.0\] - 2026-02-02/);
+  assert.match(out, /- algo/);
+  assert.doesNotMatch(out, /## \[No publicado\]/);
+  assert.match(out, /## \[1\.0\.0\]/);
+});

package/harness/packages/core/src/agent/modes.js

@@ -13,7 +13,7 @@ export const MODES = {
     id: 'plan',
     label: 'Plan',
     description: 'Solo lectura: investiga y propone un plan, sin modificar nada.',
-    tools: ['read', 'list', 'glob', 'grep', 'fetch_url', 'git_status', 'git_diff', 'git_log'],
+    tools: ['read', 'list', 'glob', 'grep', 'fetch_url', 'speak', 'git_status', 'git_diff', 'git_log'],
     systemPrompt:
       'Estás en modo PLAN: no modifiques archivos ni ejecutes comandos. Investigá el proyecto con las herramientas de solo lectura y respondé con un plan concreto y accionable.',
   },

package/harness/packages/core/src/agent/runAgent.js

@@ -150,6 +150,9 @@ export async function runAgent({
     }
 
     const tokens = accumulateUsage(result.usage ?? null);
+    // Uso de la ronda para el medidor de contexto en vivo (last_prompt_tokens
+    // es el tamano real de contexto de esta ronda).
+    if (result.usage) onEvent?.({ type: 'usage', usage: { ...usageTotal } });
 
     const calls = result.toolCalls ?? [];
     if (calls.length === 0) {

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

@@ -0,0 +1,177 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+
+const GIT_TIMEOUT_MS = 8000;
+const MAX_DIFF_CHARS = 200_000;
+const MAX_STDERR_CHARS = 20_000;
+
+/** Run `git <args>` in `root`. Never rejects; resolves `{ code, stdout, stderr }`. */
+function runGit(root, args, { timeout = GIT_TIMEOUT_MS } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn('git', args, { cwd: root, windowsHide: true });
+    } catch (error) {
+      resolve({ code: -1, stdout: '', stderr: `Error ejecutando git: ${error.message}` });
+      return;
+    }
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+        // already gone
+      }
+      finish({ code: -1, stdout, stderr: stderr || 'git: tiempo de espera agotado' });
+    }, timeout);
+    child.stdout?.on('data', (chunk) => {
+      if (stdout.length < MAX_DIFF_CHARS) stdout += chunk.toString();
+    });
+    child.stderr?.on('data', (chunk) => {
+      if (stderr.length < MAX_STDERR_CHARS) stderr += chunk.toString();
+    });
+    child.on('error', (error) => {
+      finish({ code: -1, stdout, stderr: `Error ejecutando git: ${error.message}` });
+    });
+    child.on('close', (code) => finish({ code: code ?? -1, stdout, stderr }));
+  });
+}
+
+/** Fast synchronous check for a `.git` entry in the workspace root. */
+export function isGitRepo(root) {
+  return Boolean(root) && fs.existsSync(path.join(root, '.git'));
+}
+
+function parseBranch(text) {
+  let value = String(text ?? '').trim();
+  let ahead = 0;
+  let behind = 0;
+  const flags = value.match(/\[(.+?)\]\s*$/);
+  if (flags) {
+    const a = flags[1].match(/ahead (\d+)/);
+    const b = flags[1].match(/behind (\d+)/);
+    if (a) ahead = Number(a[1]);
+    if (b) behind = Number(b[1]);
+    value = value.slice(0, flags.index).trim();
+  }
+  const dots = value.indexOf('...');
+  if (dots !== -1) value = value.slice(0, dots);
+  value = value.replace(/^No commits yet on /, '').trim();
+  return { branch: value || '(sin rama)', ahead, behind };
+}
+
+function classify(index, worktree) {
+  const pair = `${index}${worktree}`;
+  if (pair === '??') return 'untracked';
+  if (pair === '!!') return 'ignored';
+  if (index === 'U' || worktree === 'U' || pair === 'AA' || pair === 'DD') return 'conflicted';
+  if (index === 'R' || worktree === 'R') return 'renamed';
+  if (index === 'A' || worktree === 'A') return 'added';
+  if (index === 'D' || worktree === 'D') return 'deleted';
+  if (index === 'M' || worktree === 'M') return 'modified';
+  return 'modified';
+}
+
+/** Parse `git status --porcelain=v1 -z --branch` output. */
+function parseStatus(raw) {
+  const tokens = String(raw ?? '').split('\0').filter((token) => token.length > 0);
+  let branch = null;
+  let ahead = 0;
+  let behind = 0;
+  const entries = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith('## ')) {
+      ({ branch, ahead, behind } = parseBranch(token.slice(3)));
+      continue;
+    }
+    const index = token[0] ?? ' ';
+    const worktree = token[1] ?? ' ';
+    let origPath = null;
+    if (index === 'R' || worktree === 'R') {
+      origPath = tokens[i + 1] ?? null;
+      i++;
+    }
+    entries.push({
+      path: token.slice(3),
+      origPath,
+      index,
+      worktree,
+      status: classify(index, worktree),
+    });
+  }
+  return { isRepo: true, branch, ahead, behind, entries };
+}
+
+/**
+ * Working-tree status as structured data.
+ * @returns {Promise<{isRepo:boolean,branch:string|null,ahead:number,behind:number,entries:Array}>}
+ */
+export async function gitStatus(root) {
+  const result = await runGit(root, ['status', '--porcelain=v1', '-z', '--branch']);
+  if (result.code !== 0) {
+    return { isRepo: false, branch: null, ahead: 0, behind: 0, entries: [] };
+  }
+  return parseStatus(result.stdout);
+}
+
+/** Build a `new file` unified diff for an untracked path (no `--no-index` needed). */
+async function untrackedDiff(root, target) {
+  let stat;
+  try {
+    stat = await fsp.stat(path.resolve(root, target));
+  } catch {
+    return `# ${target}: no se pudo leer el archivo.\n`;
+  }
+  if (stat.isDirectory()) return `# ${target}: carpeta sin seguimiento (sin diff)\n`;
+  if (stat.size > MAX_DIFF_CHARS) return `# ${target}: archivo demasiado grande para mostrar el diff.\n`;
+  let buffer;
+  try {
+    buffer = await fsp.readFile(path.resolve(root, target));
+  } catch (error) {
+    return `# ${target}: ${error.message}\n`;
+  }
+  if (buffer.includes(0)) return `# ${target}: archivo binario (sin diff).\n`;
+  const lines = buffer.toString('utf8').replace(/\r\n/g, '\n').split('\n');
+  if (lines[lines.length - 1] === '') lines.pop();
+  const header =
+    `diff --git a/${target} b/${target}\n` +
+    `new file mode 100644\n--- /dev/null\n+++ b/${target}\n` +
+    `@@ -0,0 +1,${lines.length} @@\n`;
+  return header + lines.map((line) => `+${line}`).join('\n') + '\n';
+}
+
+/**
+ * Unified diff for a single path (or the whole tree if `path` is empty).
+ * @returns {Promise<{ok:boolean,diff:string,staged:boolean,untracked:boolean,error?:string}>}
+ */
+export async function gitDiff(root, { path: filePath, staged = false } = {}) {
+  const target = String(filePath ?? '').trim();
+  const args = ['diff', '--no-color'];
+  if (staged) args.push('--staged');
+  if (target) {
+    const status = await gitStatus(root);
+    if (!status.isRepo) return { ok: false, error: 'No es un repositorio git.' };
+    const entry = status.entries.find((e) => e.path === target || e.origPath === target);
+    if (entry?.status === 'untracked') {
+      const diff = (await untrackedDiff(root, target)).slice(0, MAX_DIFF_CHARS);
+      return { ok: true, diff, staged: false, untracked: true };
+    }
+  }
+  if (target) args.push('--', target);
+  const result = await runGit(root, args);
+  if (result.code !== 0 && !result.stdout) {
+    return { ok: false, error: result.stderr.trim() || 'git diff falló.' };
+  }
+  return { ok: true, diff: result.stdout.slice(0, MAX_DIFF_CHARS), staged, untracked: false };
+}

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

@@ -13,6 +13,7 @@ export { ensureUtf8Console } from './console.js';
 export { MAX_TOOL_ROUNDS, runAgent, parseToolArguments } from './agent/runAgent.js';
 export { estimateTokens, trimContext } from './agent/context.js';
 export { diffLines } from './tools/diff.js';
+export { isGitRepo, gitStatus, gitDiff } from './git/index.js';
 export { summarizeToolCall, previewToolResult } from './tools/labels.js';
 export { MODES, MODE_IDS, resolveMode } from './agent/modes.js';
 export { withRetry, isRetryableError, isAbortError } from './providers/resilience.js';
@@ -92,6 +93,20 @@ export {
   registryServerToConfig,
   normalizeMcpConfig,
 } from './mcp/registry.js';
-export { parseTunnelmoleUrls, startTunnelmole, startTunnel } from './tunnel.js';
+export { parseTunnelmoleUrls, startTunnelmole, startRelay, startTunnel, tunnelState, tunnelActive } from './tunnel.js';
+export {
+  TRUSTED_CLIENT_TOKEN,
+  EDGE_VERSION,
+  FORMATO_POR_DEFECTO,
+  MAX_TEXTO,
+  VOZ_POR_DEFECTO,
+  generarSecMsGec,
+  generarSsml,
+  sintetizar,
+  listarVoces,
+} from './tts/edge.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 { readPackageVersion } from './version.js';

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

@@ -0,0 +1,43 @@
+import { spawn } from 'node:child_process';
+
+/**
+ * Abre una URL en el navegador predeterminado.
+ *
+ * Es best-effort y nunca falla el comando que la llama: si no hay navegador
+ * (contenedor, servicio, CI) solo se avisa y se sigue. Por eso devuelve una
+ * promesa que resuelve siempre.
+ */
+export function openBrowser(url, { platform = process.platform, log = console.warn } = {}) {
+  const [command, args] = openerFor(url, platform);
+  if (!command) {
+    log(`No se pudo abrir el navegador automaticamente: ${url}`);
+    return Promise.resolve(false);
+  }
+  return new Promise((resolve) => {
+    try {
+      const child = spawn(command, args, {
+        // Sin shell: una URL con query (&, ?) no debe pasar por cmd.
+        shell: false,
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+      child.once('error', (error) => {
+        log(`No se pudo abrir el navegador (${error.message}). Entra a ${url}`);
+        resolve(false);
+      });
+      child.unref();
+      resolve(true);
+    } catch (error) {
+      log(`No se pudo abrir el navegador (${error.message}). Entra a ${url}`);
+      resolve(false);
+    }
+  });
+}
+
+/** El comando nativo de cada plataforma; `rundll32` evita el shell en Windows. */
+export function openerFor(url, platform = process.platform) {
+  if (platform === 'win32') return ['rundll32.exe', ['url.dll,FileProtocolHandler', url]];
+  if (platform === 'darwin') return ['open', [url]];
+  return ['xdg-open', [url]];
+}

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

@@ -0,0 +1,35 @@
+import { spawn } from 'node:child_process';
+
+/** True si el proceso con ese pid esta vivo. */
+export function pidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Mata un proceso y su arbol de hijos (taskkill /T en Windows; grupo + SIGTERM en POSIX). */
+export function killPidTree(pid) {
+  if (!pid) return;
+  try {
+    if (process.platform === 'win32') {
+      spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+    } else {
+      try {
+        process.kill(-pid, 'SIGTERM');
+      } catch {
+        /* sin grupo propio */
+      }
+      try {
+        process.kill(pid, 'SIGTERM');
+      } catch {
+        /* ya no esta */
+      }
+    }
+  } catch {
+    /* ya no esta */
+  }
+}