@danieltmn/tamnora 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -5,6 +5,19 @@ 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.6.0] - 2026-10-04
+
+### Cambios
+
+- docs: actividad colapsable, runs durables, subagentes y canales
+- feat(server): experiencia remota con actividad colapsable, runs durables, subagentes y canales
+
+## [0.5.1] - 2026-10-02
+
+### Cambios
+
+- docs: como actualizar desde versiones viejas
+
 ## [0.5.0] - 2026-10-02
 
 ### Agregado

package/README.md

@@ -63,6 +63,11 @@ Tamnora (override con `--home` o `TAMNORA_HOME`):
 - macOS: `~/Library/Application Support/tamnora`
 - Linux: `~/.config/tamnora`
 
+> **Actualizar**: en `0.4.1+` alcanza con `tamnora update` (o `--yes`). Si venis de
+> **`0.4.0` o anterior**, `tamnora update` fallaba en Windows, asi que hace una vez
+> `npm i -g @danieltmn/tamnora@latest` (agrega `--prefer-online` si el cache de npm
+> devuelve la version vieja) o corre con `npx @danieltmn/tamnora@latest`.
+
 ### Consola web
 
 `tamnora serve` sirve la consola en `http://127.0.0.1:4517`. Las pestanas

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

@@ -15,6 +15,7 @@ export const DEFAULT_CONFIG = {
   processes: { enabled: true, allow: [] },
   preview: { provider: 'tunnelmole' },
   telegram: { token: '', allowedChatIds: [] },
+  agents: { maxRounds: 6 },
 };
 
 /** Directory (relative to the project) where harness state lived historically. */

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

@@ -3,6 +3,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 { summarizeToolCall, previewToolResult } from './tools/labels.js';
 export { MODES, MODE_IDS, resolveMode } from './agent/modes.js';
 export { withRetry, isRetryableError, isAbortError } from './providers/resilience.js';
 export {

package/harness/packages/core/src/storage/sqlite.js

@@ -28,12 +28,37 @@ CREATE TABLE IF NOT EXISTS messages (
   tool_call_id TEXT,
   name TEXT,
   mode TEXT,
+  agent_id TEXT,
   tokens_in INTEGER,
   tokens_out INTEGER,
   created_at INTEGER
 );
 CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, created_at);
 
+CREATE TABLE IF NOT EXISTS agents (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  parent_agent_id TEXT,
+  kind TEXT,
+  title TEXT,
+  status TEXT,
+  model TEXT,
+  summary TEXT,
+  created_at INTEGER,
+  updated_at INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_agents_session ON agents(session_id, created_at);
+
+CREATE TABLE IF NOT EXISTS session_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  agent_id TEXT,
+  type TEXT NOT NULL,
+  data TEXT,
+  created_at INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_session_events ON session_events(session_id, id);
+
 CREATE TABLE IF NOT EXISTS runs (
   id TEXT PRIMARY KEY,
   dataset TEXT,
@@ -107,6 +132,7 @@ export function openDatabase(file) {
 function migrate(db) {
   const columns = db.prepare('PRAGMA table_info(messages)').all().map((c) => c.name);
   if (!columns.includes('mode')) db.exec('ALTER TABLE messages ADD COLUMN mode TEXT');
+  if (!columns.includes('agent_id')) db.exec('ALTER TABLE messages ADD COLUMN agent_id TEXT');
 }
 
 const now = () => Date.now();
@@ -261,8 +287,8 @@ export class Store {
     const id = randomUUID();
     this.db
       .prepare(
-        `INSERT INTO messages (id, session_id, role, content, tool_calls, tool_call_id, name, mode, tokens_in, tokens_out, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        `INSERT INTO messages (id, session_id, role, content, tool_calls, tool_call_id, name, mode, agent_id, tokens_in, tokens_out, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       )
       .run(
         id,
@@ -273,6 +299,7 @@ export class Store {
         message.tool_call_id ?? null,
         message.name ?? null,
         message.mode ?? null,
+        message.agent_id ?? null,
         message.tokens_in ?? null,
         message.tokens_out ?? null,
         now()
@@ -298,10 +325,74 @@ export class Store {
         if (row.tool_call_id) message.tool_call_id = row.tool_call_id;
         if (row.name) message.name = row.name;
         if (row.mode) message.mode = row.mode;
+        if (row.agent_id) message.agent_id = row.agent_id;
         return message;
       });
   }
 
+  // --- Agents (subagentes) ------------------------------------------------
+
+  createAgent({ sessionId, parentAgentId = null, kind = 'task', title, model } = {}) {
+    const id = randomUUID();
+    const ts = now();
+    this.db
+      .prepare(
+        `INSERT INTO agents (id, session_id, parent_agent_id, kind, title, status, model, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(id, sessionId, parentAgentId, kind, title ?? null, 'running', model ?? null, ts, ts);
+    return id;
+  }
+
+  finishAgent(id, { status = 'done', summary } = {}) {
+    this.db
+      .prepare(`UPDATE agents SET status = ?, summary = ?, updated_at = ? WHERE id = ?`)
+      .run(status, summary ?? null, now(), id);
+  }
+
+  getAgent(id) {
+    const row = this.db.prepare(`SELECT * FROM agents WHERE id = ?`).get(id);
+    return row ? toAgent(row) : null;
+  }
+
+  listAgents(sessionId) {
+    return this.db
+      .prepare(`SELECT * FROM agents WHERE session_id = ? ORDER BY created_at ASC`)
+      .all(sessionId)
+      .map(toAgent);
+  }
+
+  // --- Session events (run log for reconnection) --------------------------
+
+  addSessionEvent(sessionId, { agentId = null, type, data } = {}) {
+    const info = this.db
+      .prepare(`INSERT INTO session_events (session_id, agent_id, type, data, created_at) VALUES (?, ?, ?, ?, ?)`)
+      .run(sessionId, agentId, type, json(data), now());
+    return Number(info.lastInsertRowid);
+  }
+
+  updateSessionEvent(id, data) {
+    this.db.prepare(`UPDATE session_events SET data = ? WHERE id = ?`).run(json(data), id);
+  }
+
+  getSessionEvents(sessionId, { from = 0, limit = 5000 } = {}) {
+    return this.db
+      .prepare(`SELECT * FROM session_events WHERE session_id = ? AND id > ? ORDER BY id ASC LIMIT ?`)
+      .all(sessionId, from, limit)
+      .map((row) => ({ id: row.id, agentId: row.agent_id, type: row.type, data: parseJson(row.data), createdAt: row.created_at }));
+  }
+
+  lastSessionEventId(sessionId) {
+    const row = this.db
+      .prepare(`SELECT COALESCE(MAX(id), 0) AS id FROM session_events WHERE session_id = ?`)
+      .get(sessionId);
+    return row?.id ?? 0;
+  }
+
+  clearSessionEvents(sessionId) {
+    this.db.prepare(`DELETE FROM session_events WHERE session_id = ?`).run(sessionId);
+  }
+
   // --- Runs (evaluation) --------------------------------------------------
 
   createRun({ dataset, config } = {}) {
@@ -468,6 +559,21 @@ export class Store {
   }
 }
 
+function toAgent(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    parentAgentId: row.parent_agent_id ?? null,
+    kind: row.kind ?? 'task',
+    title: row.title ?? '',
+    status: row.status ?? 'running',
+    model: row.model ?? null,
+    summary: row.summary ?? null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
 function toProvider(row) {
   return {
     id: row.id,

package/harness/packages/core/src/tools/labels.js

@@ -0,0 +1,83 @@
+// Etiquetas legibles para tool-calls y previews de resultados. Las usa la
+// consola (y cualquier canal) para mostrar la actividad del agente de forma
+// compacta, colapsable y apta para pantallas chicas.
+
+function text(value) {
+  return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+function shorten(value, max = 80) {
+  const raw = text(value);
+  return raw.length > max ? `${raw.slice(0, max - 1)}…` : raw;
+}
+
+/**
+ * Una linea con la esencia de un tool-call: `read src/app.js`,
+ * `grep "foo" *.js`, `bash npm test`. Devuelve '' si no hay nada util.
+ */
+export function summarizeToolCall(name, args = {}) {
+  const a = args && typeof args === 'object' ? args : {};
+  const tool = String(name ?? '');
+  const path = (value) => (value ? shorten(value, 60) : '');
+
+  switch (tool) {
+    case 'read': {
+      const base = path(a.path) || '.';
+      const offset = Number(a.offset) || 0;
+      const limit = Number(a.limit) || 0;
+      if (offset && limit) return `${base}:${offset}-${offset + limit - 1}`;
+      if (offset) return `${base}:${offset}+`;
+      return base;
+    }
+    case 'write':
+    case 'edit':
+      return path(a.path) || 'archivo';
+    case 'list':
+      return path(a.path) || '.';
+    case 'glob':
+      return [a.pattern ? `"${shorten(a.pattern, 50)}"` : '', a.path ? `en ${path(a.path)}` : ''].filter(Boolean).join(' ');
+    case 'grep':
+      return [
+        a.pattern ? `"${shorten(a.pattern, 50)}"` : '',
+        a.include ? `${shorten(a.include, 30)}` : '',
+        a.path ? `en ${path(a.path)}` : '',
+      ]
+        .filter(Boolean)
+        .join(' ');
+    case 'bash': {
+      const line = text(a.command).split('\n')[0];
+      return shorten(line, 90);
+    }
+    case 'fetch_url':
+      return shorten(a.url, 90);
+    case 'git_diff':
+      return [a.ref ? `vs ${shorten(a.ref, 30)}` : a.staged ? 'staged' : 'unstaged', a.path ? path(a.path) : '']
+        .filter(Boolean)
+        .join(' ');
+    case 'git_log':
+      return a.limit ? `${a.limit} commits` : '';
+    case 'git_commit':
+      return shorten(a.message, 70);
+    case 'task':
+    case 'spawn_agent':
+      return shorten(a.description || a.prompt, 80);
+    default:
+      return '';
+  }
+}
+
+/**
+ * Recorta un resultado para mostrarlo como preview. Devuelve el texto y si
+ * quedo truncado (para ofrecer "ver completo" bajo demanda).
+ */
+export function previewToolResult(_name, result, { maxLines = 24, maxChars = 4000 } = {}) {
+  const value = typeof result === 'string' ? result : JSON.stringify(result ?? '', null, 2) ?? '';
+  const lines = value.split('\n');
+  let preview = lines.slice(0, maxLines).join('\n');
+  let truncated = lines.length > maxLines;
+  if (preview.length > maxChars) {
+    preview = preview.slice(0, maxChars);
+    truncated = true;
+  }
+  return { preview, truncated, totalLines: lines.length };
+}

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

@@ -0,0 +1,34 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { summarizeToolCall, previewToolResult } from '../src/index.js';
+
+test('summarizeToolCall describe las tools de exploracion', () => {
+  assert.equal(summarizeToolCall('read', { path: 'src/app.js' }), 'src/app.js');
+  assert.equal(summarizeToolCall('read', { path: 'src/app.js', offset: 10, limit: 5 }), 'src/app.js:10-14');
+  assert.equal(summarizeToolCall('list', {}), '.');
+  assert.equal(summarizeToolCall('glob', { pattern: 'src/**/*.js' }), '"src/**/*.js"');
+  assert.equal(summarizeToolCall('grep', { pattern: 'foo', include: '*.js' }), '"foo" *.js');
+});
+
+test('summarizeToolCall describe acciones y comandos', () => {
+  assert.equal(summarizeToolCall('bash', { command: 'npm test\n--watch' }), 'npm test --watch');
+  assert.equal(summarizeToolCall('write', { path: 'a/b.txt' }), 'a/b.txt');
+  assert.equal(summarizeToolCall('git_commit', { message: 'feat: algo' }), 'feat: algo');
+});
+
+test('summarizeToolCall tolera args invalidos y recorta', () => {
+  assert.equal(summarizeToolCall('read', null), '.');
+  assert.equal(summarizeToolCall('desconocida', { a: 1 }), '');
+  assert.ok(summarizeToolCall('bash', { command: 'x'.repeat(500) }).length <= 90);
+});
+
+test('previewToolResult recorta por lineas y marca truncado', () => {
+  const short = previewToolResult('read', 'uno\ndos\ntres');
+  assert.equal(short.preview, 'uno\ndos\ntres');
+  assert.equal(short.truncated, false);
+  assert.equal(short.totalLines, 3);
+
+  const long = previewToolResult('read', Array.from({ length: 100 }, (_, i) => `linea ${i}`).join('\n'));
+  assert.equal(long.truncated, true);
+  assert.equal(long.preview.split('\n').length, 24);
+});