@danieltmn/tamnora 0.13.1 → 0.15.0

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

@@ -52,8 +52,10 @@ export async function summarizeSession(ctx, session, instruction) {
   if (!messages.length) return { error: 'La sesión no tiene mensajes para resumir.', status: 400 };
   const resolved = providerFor(ctx, session);
   if (resolved.error) return resolved;
+  ctx.hooks?.dispatch({ type: 'session.compacting', sessionId: session.id, messages: messages.length });
   const summary = await summarize(ctx, session, messages, instruction);
   if (!summary) return { error: 'El modelo no devolvió un resumen.', status: 502 };
+  ctx.hooks?.dispatch({ type: 'session.compacted', sessionId: session.id, summary });
   return { summary };
 }
 
@@ -70,8 +72,10 @@ export async function maybeAutoCompact(ctx, session, history, { contextTokens }
   const live = liveHistory(history, session.meta?.summaryCursor ?? null);
   const plan = planCompaction(live, { contextTokens, threshold, keepLast });
   if (!plan) return null;
+  ctx.hooks?.dispatch({ type: 'session.compacting', sessionId: session.id, auto: true, messages: plan.toSummarize.length });
   const summary = await summarize(ctx, session, plan.toSummarize, COMPACT_INSTRUCTION, session.meta?.summary);
   if (!summary) return null;
   ctx.store.touchSession(session.id, { meta: { summary, summaryCursor: plan.cursor } });
+  ctx.hooks?.dispatch({ type: 'session.compacted', sessionId: session.id, auto: true, summary });
   return { summary, cursor: plan.cursor, summarized: plan.toSummarize.length };
 }

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

@@ -0,0 +1,45 @@
+// Runner de hooks: carga los modulos (`core/src/hooks`) y despacha eventos a
+// sus handlers de forma aislada (un hook que tira no rompe el run) y con los
+// datos redactados. Es opt-in: sin archivos de hooks, no se ejecuta codigo.
+
+import { loadHooks, redactDeep } from './core.js';
+
+/**
+ * Crea el runner. `dispatch(event)` llama a los handlers suscritos a
+ * `event.type` (y a los wildcard `*`); no devuelve valor (observadores).
+ */
+export async function createHookRunner(ctx, patterns = []) {
+  let hooks = [];
+  try {
+    hooks = await loadHooks(ctx.cwd, patterns);
+  } catch {
+    hooks = [];
+  }
+  const handlers = new Map();
+  for (const hook of hooks) {
+    for (const [event, fn] of Object.entries(hook.events)) {
+      if (typeof fn !== 'function') continue;
+      const list = handlers.get(event) ?? [];
+      list.push(fn);
+      handlers.set(event, list);
+    }
+  }
+
+  function dispatch(event) {
+    const list = [...(handlers.get(event.type) ?? []), ...(handlers.get('*') ?? [])];
+    if (!list.length) return;
+    const safe = redactDeep(event);
+    for (const fn of list) {
+      Promise.resolve()
+        .then(() => fn(safe, ctx))
+        .catch(() => {
+          // un hook caido no debe frenar el run
+        });
+    }
+  }
+
+  const view = () =>
+    hooks.map((hook) => ({ id: hook.id, path: hook.path, events: Object.keys(hook.events).filter((e) => e !== '*') }));
+
+  return { dispatch, count: hooks.length, list: view };
+}

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

@@ -0,0 +1,76 @@
+// Plugins: agregan herramientas propias al agente (`.tamnora/plugins/*.mjs` o
+// las rutas de `config.plugins`). Corren codigo del usuario, asi que pasan por
+// permisos (default `ask`).
+
+import { loadPlugins } from './core.js';
+
+function normalizeName(value) {
+  return String(value ?? '')
+    .replace(/[^a-z0-9_-]+/gi, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, 64);
+}
+
+/** Crea el toolset de plugins. `execute(name, args, { approve })`. */
+export async function createPlugins(ctx, patterns = []) {
+  let plugins = [];
+  try {
+    plugins = await loadPlugins(ctx.cwd, patterns);
+  } catch {
+    plugins = [];
+  }
+
+  const tools = [];
+  const used = new Set();
+  for (const plugin of plugins) {
+    for (const tool of plugin.tools) {
+      const name = `plugin__${normalizeName(plugin.id)}__${normalizeName(tool.name)}`;
+      if (!name || used.has(name)) continue;
+      used.add(name);
+      tools.push({
+        name,
+        source: tool.name,
+        plugin: plugin.id,
+        description: String(tool.description || tool.name),
+        parameters: tool.parameters && typeof tool.parameters === 'object' ? tool.parameters : {},
+        required: Array.isArray(tool.required) ? tool.required : [],
+        handler: tool.handler,
+      });
+    }
+  }
+
+  const byName = new Map(tools.map((tool) => [tool.name, tool]));
+  const definitions = tools.map((tool) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: { type: 'object', properties: tool.parameters, required: tool.required },
+    },
+  }));
+
+  async function execute(name, args = {}, { approve } = {}) {
+    const tool = byName.get(name);
+    if (!tool) return `Herramienta desconocida: ${name}`;
+    const decision = (ctx.config.permissions ?? {})[tool.name] ?? 'ask';
+    if (decision === 'deny') return `Permiso denegado para "${name}".`;
+    if (decision === 'ask') {
+      const ok = approve ? await approve(name, args) : false;
+      if (!ok) return `Permiso denegado para "${name}".`;
+    }
+    try {
+      const out = await tool.handler(args, ctx);
+      return typeof out === 'string' ? out : JSON.stringify(out ?? null, null, 2);
+    } catch (error) {
+      return `Error en ${name}: ${error?.message ?? error}`;
+    }
+  }
+
+  return {
+    definitions,
+    handles: (name) => byName.has(name),
+    execute,
+    count: tools.length,
+    list: () => tools.map(({ name, source, plugin, description }) => ({ name, source, plugin, description })),
+  };
+}

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

@@ -0,0 +1,190 @@
+// Tareas programadas: un tick por minuto revisa `schedules` y dispara las que
+// vencieron. `shell` usa la allowlist de procesos; `agent` corre un turno
+// headless en una sesion (reusa runManager, asi que los canales avisan solos).
+
+import { runAgent, createTools, resolveMode, parseScheduleSpec, nextRun, MAX_TOOL_ROUNDS } from './core.js';
+import {
+  combineToolset,
+  composeAgentMessages,
+  buildUserMessage,
+  resolveProviderFor,
+  toolCallPayload,
+  toolResultPayload,
+} from './agentRun.js';
+import { createSubagentTool } from './tasks.js';
+import { createRulesInjector } from './rules.js';
+
+function scheduleSessionId(ctx, schedule) {
+  const payload = schedule.payload ?? {};
+  if (payload.sessionId) return payload.sessionId;
+  return ctx.store.getSetting(`scheduleSession:${schedule.id}`) ?? null;
+}
+
+async function runAgentSchedule(ctx, schedule) {
+  const payload = schedule.payload ?? {};
+  const cwd = schedule.cwd || ctx.cwd;
+  const providerId = payload.provider || ctx.effectiveProviderId();
+  const model = payload.model || ctx.effectiveModel();
+  if (!model) throw new Error('Falta el modelo para la tarea.');
+  const mode = resolveMode(payload.mode ?? 'agent');
+  const prompt = String(payload.prompt ?? '').trim() || `Ejecutá la tarea programada "${schedule.name}".`;
+
+  let sessionId = scheduleSessionId(ctx, schedule);
+  if (!sessionId || !ctx.store.getSession(sessionId)) {
+    sessionId = ctx.store.createSession({ title: `Tarea: ${schedule.name}`, provider: providerId, model, cwd });
+    ctx.store.setSetting(`scheduleSession:${schedule.id}`, sessionId);
+  }
+
+  const run = ctx.runs.start(sessionId);
+  if (!run) throw new Error('La sesión de la tarea ya está corriendo.');
+
+  let mcp = null;
+  try {
+    mcp = await ctx.getMcp();
+  } catch {
+    mcp = null;
+  }
+
+  const signal = ctx.runs.signal(sessionId);
+  const sessionRecord = ctx.store.getSession(sessionId);
+  const history = ctx.store.getMessages(sessionId);
+  const userMessage = buildUserMessage(prompt);
+  const messages = await composeAgentMessages({ ctx, cwd, mode, history, userMessage, sessionRecord });
+  ctx.store.addMessage(sessionId, userMessage);
+  const prefixLength = messages.length;
+
+  const local = createTools({ root: cwd, enabled: mode.tools ?? undefined, permissions: ctx.config.permissions, yes: true, mcp, signal });
+  const exposeAdmin = !mode.tools;
+  const admin = ctx.agentTools;
+  const emit = (type, data, agentId = null) => ctx.runs.emit(sessionId, type, data, { agentId });
+  const tasks = createSubagentTool(ctx, {
+    sessionId,
+    cwd,
+    providerId,
+    model,
+    permissions: ctx.config.permissions,
+    mcp,
+    signal,
+    exclude: admin.definitions.map((d) => d.function.name),
+    emit,
+  });
+  const { definitions, execute } = combineToolset({
+    local,
+    admin,
+    tasks,
+    plugins: exposeAdmin ? ctx.plugins : null,
+    exposeAdmin,
+    approve: async () => true,
+  });
+  const { provider, config } = resolveProviderFor(ctx, providerId);
+
+  try {
+    const result = await runAgent({
+      provider,
+      config,
+      model,
+      messages,
+      tools: definitions,
+      execute,
+      toolContext: { cwd, sessionId },
+      onLifecycle: createRulesInjector({ cwd, patterns: ctx.config.rules ?? [] }) ?? undefined,
+      signal,
+      maxRounds: ctx.effectiveMaxRounds?.() || MAX_TOOL_ROUNDS,
+      maxTokens: ctx.effectiveMaxTokens?.() || 0,
+      maxDurationMs: ctx.effectiveMaxDurationMs?.() || 0,
+      maxOutputTokens: ctx.effectiveMaxOutputTokens?.() || 0,
+      onEvent(event) {
+        if (event.type === 'text') emit('text', { full: event.full });
+        else if (event.type === 'reasoning') emit('reasoning', { full: event.full });
+        else if (event.type === 'tool_call') emit('tool_call', toolCallPayload(event));
+        else if (event.type === 'tool_result') emit('tool_result', { id: event.id, name: event.name, ...toolResultPayload(event) });
+        else if (event.type === 'usage') emit('usage', { tokens: event.usage });
+      },
+    });
+    ctx.store.addMessages(sessionId, result.messages.slice(prefixLength));
+    ctx.runs.emit(sessionId, 'done', {
+      sessionId,
+      content: result.content,
+      rounds: result.rounds,
+      stopReason: result.stopReason,
+      wrappedUp: result.wrappedUp === true,
+      tokens: result.usage ?? null,
+      schedule: schedule.id,
+    });
+    return { ok: true, sessionId };
+  } finally {
+    ctx.runs.finish(sessionId);
+  }
+}
+
+function runShellSchedule(ctx, schedule) {
+  const payload = schedule.payload ?? {};
+  if (!ctx.procsEnabled) throw new Error('Los procesos están deshabilitados.');
+  const cwd = schedule.cwd || ctx.cwd;
+  const proc = ctx.procs.start({ cwd, command: payload.command, args: payload.args ?? [], port: payload.port });
+  return { ok: true, procId: proc.id };
+}
+
+async function executeSchedule(ctx, schedule) {
+  if (schedule.type === 'shell') return runShellSchedule(ctx, schedule);
+  return runAgentSchedule(ctx, schedule);
+}
+
+/**
+ * Crea el scheduler. `tick()` revisa y dispara lo vencido; `start()` lo corre
+ * cada `intervalMs` (default 30 s). `runNow(id)` dispara una tarea a mano.
+ */
+export function createScheduler(ctx, { intervalMs = 30000, log = () => {} } = {}) {
+  let timer = null;
+  let ticking = false;
+
+  function plan(schedule, from = Date.now()) {
+    const parsed = parseScheduleSpec(schedule.spec);
+    return parsed ? nextRun(parsed, from) : null;
+  }
+
+  async function fire(schedule) {
+    const next = plan(schedule);
+    ctx.store.markScheduleRun(schedule.id, { status: 'running', nextRun: next });
+    try {
+      const result = await executeSchedule(ctx, schedule);
+      ctx.store.markScheduleRun(schedule.id, { status: 'ok', nextRun: next });
+      log(`tarea "${schedule.id}" ok`);
+      return result;
+    } catch (error) {
+      const message = String(error?.message ?? error);
+      ctx.store.markScheduleRun(schedule.id, { status: `error: ${message}`.slice(0, 140), nextRun: next });
+      log(`tarea "${schedule.id}" falló: ${message}`);
+      throw error;
+    }
+  }
+
+  async function tick() {
+    if (ticking) return;
+    ticking = true;
+    try {
+      for (const schedule of ctx.store.dueSchedules()) {
+        try {
+          await fire(schedule);
+        } catch {
+          // seguir con las siguientes
+        }
+      }
+    } finally {
+      ticking = false;
+    }
+  }
+
+  function start() {
+    if (timer) return;
+    timer = setInterval(() => tick().catch(() => {}), intervalMs);
+    timer.unref?.();
+  }
+
+  function stop() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  }
+
+  return { start, stop, tick, fire, runNow: (id) => fire(ctx.store.getSchedule(id)) };
+}

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

@@ -20,6 +20,8 @@ export function registerAdvisor(route, ctx) {
     if ('explain' in body) next.explain = body.explain !== false;
     if ('advice' in body) next.advice = body.advice !== false;
     if ('notes' in body) next.notes = String(body.notes ?? '').slice(0, 2000);
+    if ('provider' in body) next.provider = String(body.provider ?? '').trim().slice(0, 60);
+    if ('model' in body) next.model = String(body.model ?? '').trim().slice(0, 120);
     if ('maxWords' in body) {
       const value = Number(body.maxWords);
       next.maxWords = Number.isFinite(value)
@@ -34,8 +36,8 @@ export function registerAdvisor(route, ctx) {
 
   route('POST', '/api/advisor/test', async ({ res }) => {
     const options = resolveAdvisor(ctx.app);
-    const providerId = ctx.effectiveProviderId();
-    const model = ctx.effectiveModel();
+    const providerId = options.provider || ctx.effectiveProviderId();
+    const model = options.model || ctx.effectiveModel();
     if (!model) return sendError(res, 400, 'Elegí un proveedor y un modelo primero.');
     const { provider, config } = ctx.resolveProvider({
       ...ctx.providerSettings(providerId),

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

@@ -10,6 +10,7 @@ import { workspaceForRequest, resolveExistingDir } from '../lib/workspace.js';
 import { createSubagentTool } from '../lib/tasks.js';
 import {
   combineToolset,
+  combineLifecycle,
   composeAgentMessages,
   buildUserMessage,
   resolveProviderFor,
@@ -20,6 +21,7 @@ import { fraseInicio, fraseFin, fraseError, createFiltroTools } from '../lib/ann
 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';
 
 /**
  * Emit streaming partials at most once per `ms` window, keeping only the
@@ -219,11 +221,18 @@ export function registerChat(route, ctx) {
       permissions: ctx.config.permissions,
       mcp,
       signal: ctx.runs.signal(sessionId),
-      exclude: admin.definitions.map((d) => d.function.name),
+      exclude: [...admin.definitions.map((d) => d.function.name), ...(ctx.plugins?.list?.().map((t) => t.name) ?? [])],
       emit: emitAgent,
     });
     const approve = autoApprove ? async () => true : (name, args) => onAsk(name, args);
-    const { definitions, execute } = combineToolset({ local, admin, tasks, exposeAdmin, approve });
+    const { definitions, execute } = combineToolset({
+      local,
+      admin,
+      tasks,
+      plugins: exposeAdmin ? ctx.plugins : null,
+      exposeAdmin,
+      approve,
+    });
 
     const { provider, config } = resolveProviderFor(ctx, providerId, {
       baseUrl: body.baseUrl || ctx.providerSettings(providerId).baseUrl,
@@ -254,8 +263,13 @@ export function registerChat(route, ctx) {
     });
     // Persistimos el mensaje del usuario ya: asi sobrevive a un corte y la
     // reconexion puede reconstruir el turno desde el historial.
-    ctx.store.addMessage(sessionId, userMessage);
+    const userMessageId = ctx.store.addMessage(sessionId, userMessage);
     const prefixLength = messages.length;
+    const onLifecycle = combineLifecycle([
+      createRulesInjector({ cwd: sessionCwd, patterns: ctx.config.rules ?? [] }),
+      createCheckpointer(ctx, { sessionId, cwd: sessionCwd, turnId: userMessageId }),
+      ctx.hooks ? (event) => ctx.hooks.dispatch(event) : null,
+    ]);
 
     (async () => {
       const startedAt = Date.now();
@@ -270,7 +284,7 @@ export function registerChat(route, ctx) {
           tools: definitions,
           execute,
           toolContext: { cwd: sessionCwd, sessionId },
-          onLifecycle: createRulesInjector({ cwd: sessionCwd, patterns: ctx.config.rules ?? [] }) ?? undefined,
+          onLifecycle: onLifecycle ?? undefined,
           signal: ctx.runs.signal(sessionId),
           maxRounds: Number(body.maxRounds) || ctx.effectiveMaxRounds?.() || MAX_TOOL_ROUNDS,
           maxTokens: Number(body.maxTokens) || ctx.effectiveMaxTokens?.() || 0,
@@ -350,10 +364,20 @@ export function registerChat(route, ctx) {
           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,
-            config,
-            model,
+            provider: advisorProvider,
+            config: advisorConfig,
+            model: advisorModel,
             signal: ctx.runs.signal(sessionId),
             userInput: input,
             answer: result.content,
@@ -368,6 +392,7 @@ export function registerChat(route, ctx) {
               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) {

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

@@ -0,0 +1,124 @@
+// Tareas programadas: CRUD + "correr ahora". El tick vive en lib/scheduler.js.
+
+import { randomUUID } from 'node:crypto';
+import { parseScheduleSpec, nextRunFor } from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+
+const ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
+
+function sanitizeId(value) {
+  return String(value ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40);
+}
+
+function buildPayload(body, type) {
+  if (type === 'shell') {
+    const args = Array.isArray(body.args)
+      ? body.args.map(String)
+      : String(body.args ?? '').trim()
+        ? String(body.args).match(/(?:[^\s"]+|"[^"]*")+/g).map((s) => s.replace(/^"|"$/g, ''))
+        : [];
+    return { command: String(body.command ?? '').trim(), args, port: body.port ?? null };
+  }
+  return {
+    prompt: String(body.prompt ?? '').trim(),
+    mode: body.mode === 'plan' ? 'plan' : 'agent',
+    model: body.model || undefined,
+    provider: body.provider || undefined,
+    sessionId: body.sessionId || undefined,
+  };
+}
+
+function validate(type, payload) {
+  if (type === 'shell' && !payload.command) return 'Una tarea shell necesita "command".';
+  if (type === 'agent' && !payload.prompt) return 'Una tarea agent necesita "prompt".';
+  return null;
+}
+
+export function registerSchedules(route, ctx) {
+  route('GET', '/api/schedules', ({ res }) => {
+    sendJson(res, 200, { schedules: ctx.store.listSchedules() });
+  });
+
+  route('POST', '/api/schedules', async ({ req, res }) => {
+    const body = await readJson(req);
+    const spec = String(body.spec ?? '').trim();
+    if (!parseScheduleSpec(spec)) {
+      return sendError(res, 400, 'Especificación inválida. Ej.: "every 30 m", "daily 09:00", "0 6 * * 1".');
+    }
+    const id = sanitizeId(body.id || body.name) || randomUUID().slice(0, 8);
+    if (!ID_PATTERN.test(id)) return sendError(res, 400, 'Id de tarea inválido.');
+    if (ctx.store.getSchedule(id)) return sendError(res, 409, `Ya existe una tarea con id "${id}".`);
+    const type = body.type === 'shell' ? 'shell' : 'agent';
+    const payload = buildPayload(body, type);
+    const problem = validate(type, payload);
+    if (problem) return sendError(res, 400, problem);
+    const schedule = ctx.store.saveSchedule({
+      id,
+      name: String(body.name ?? id).trim() || id,
+      type,
+      spec,
+      cwd: body.cwd || ctx.cwd,
+      enabled: body.enabled !== false,
+      payload,
+      nextRun: nextRunFor(spec),
+    });
+    sendJson(res, 201, { schedule });
+  });
+
+  route('PUT', '/api/schedules/:id', async ({ req, res, params }) => {
+    const current = ctx.store.getSchedule(params.id);
+    if (!current) return sendError(res, 404, 'Tarea no encontrada.');
+    const body = await readJson(req);
+    const spec = body.spec === undefined ? current.spec : String(body.spec).trim();
+    if (!parseScheduleSpec(spec)) return sendError(res, 400, 'Especificación inválida.');
+    const type = body.type === 'shell' || body.type === 'agent' ? body.type : current.type;
+    const merged = { ...current.payload, ...buildPayload(body, type) };
+    const problem = validate(type, merged);
+    if (problem) return sendError(res, 400, problem);
+    const schedule = ctx.store.saveSchedule({
+      id: current.id,
+      name: body.name ?? current.name,
+      type,
+      spec,
+      cwd: body.cwd ?? current.cwd,
+      enabled: body.enabled === undefined ? current.enabled : body.enabled !== false,
+      payload: merged,
+      nextRun: nextRunFor(spec),
+    });
+    sendJson(res, 200, { schedule });
+  });
+
+  route('POST', '/api/schedules/:id/toggle', ({ res, params }) => {
+    const current = ctx.store.getSchedule(params.id);
+    if (!current) return sendError(res, 404, 'Tarea no encontrada.');
+    const enabled = !current.enabled;
+    ctx.store.setScheduleEnabled(current.id, enabled);
+    const nextRun = enabled ? nextRunFor(current.spec) : null;
+    ctx.store.markScheduleRun(current.id, { status: current.lastStatus, nextRun });
+    sendJson(res, 200, { id: current.id, enabled, schedule: ctx.store.getSchedule(current.id) });
+  });
+
+  route('DELETE', '/api/schedules/:id', ({ res, params }) => {
+    const current = ctx.store.getSchedule(params.id);
+    if (!current) return sendError(res, 404, 'Tarea no encontrada.');
+    ctx.store.deleteSchedule(params.id);
+    sendJson(res, 200, { schedules: ctx.store.listSchedules() });
+  });
+
+  route('POST', '/api/schedules/:id/run', async ({ res, params }) => {
+    const current = ctx.store.getSchedule(params.id);
+    if (!current) return sendError(res, 404, 'Tarea no encontrada.');
+    if (!ctx.scheduler) return sendError(res, 503, 'El planificador no está activo.');
+    try {
+      const result = await ctx.scheduler.runNow(params.id);
+      sendJson(res, 200, { ok: true, result, schedule: ctx.store.getSchedule(params.id) });
+    } catch (error) {
+      sendError(res, 500, `La tarea falló: ${error?.message ?? error}`);
+    }
+  });
+}

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

@@ -2,6 +2,7 @@ import { readJson, sendJson, sendError } from '../lib/http.js';
 import { workspaceForRequest } from '../lib/workspace.js';
 import { sessionView, sessionState, awaitingBySession } from '../lib/sessionView.js';
 import { summarizeSession, COMPACT_INSTRUCTION, SUMMARY_INSTRUCTION } from '../lib/compact.js';
+import { rewindSession, checkpointTurns } from '../lib/checkpoints.js';
 
 export function registerSessions(route, ctx) {
   route('GET', '/api/sessions', ({ res }) => {
@@ -117,8 +118,23 @@ export function registerSessions(route, ctx) {
     sendJson(res, 200, { ok: true, removed });
   });
 
-  route('POST', '/api/sessions/:id/compact', async ({ res, params }) => {
-    const session = ctx.store.getSession(params.id);
+  route('GET', '/api/sessions/:id/checkpoints', async ({ res, params }) => {
+    if (!ctx.store.getSession(params.id)) return sendError(res, 404, 'Sesión no encontrada.');
+    sendJson(res, 200, { turns: await checkpointTurns(params.id) });
+  });
+
+  route('POST', '/api/sessions/:id/rewind', async ({ req, res, params }) => {
+    if (!ctx.store.getSession(params.id)) return sendError(res, 404, 'Sesión no encontrada.');
+    if (ctx.runs?.isActive(params.id)) return sendError(res, 409, 'Hay un run en curso en esta sesión.');
+    const body = await readJson(req);
+    const turn = String(body.turn || '');
+    if (!turn) return sendError(res, 400, 'Falta "turn" (id del mensaje del turno).');
+    const result = await rewindSession(ctx, params.id, turn);
+    ctx.store.touchSession(params.id, { meta: { summary: undefined, summaryCursor: undefined } });
+    sendJson(res, 200, { ok: true, ...result });
+  });
+
+  route('POST', '/api/sessions/:id/compact', async ({ res, params }) => {    const session = ctx.store.getSession(params.id);
     if (!session) return sendError(res, 404, 'Sesión no encontrada.');
     const out = await summarizeSession(ctx, session, COMPACT_INSTRUCTION);
     if (out.error) return sendError(res, out.status, out.error);

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

@@ -51,6 +51,10 @@ 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';
+import { createPlugins } from './lib/plugins.js';
 
 const VERSION = readPackageVersion();
 
@@ -215,6 +219,12 @@ export async function createTamnoraServer({
   ctx.systemPrompt = (await ctx.systemPromptFor(cwd)) || DEFAULT_SYSTEM_PROMPT;
   ctx.agentTools = createAgentTools(ctx);
 
+  // Hooks locales (opt-in: solo si hay archivos). Observan el ciclo de vida.
+  ctx.hooks = await createHookRunner(ctx, config.hooks ?? []);
+
+  // Plugins locales: tools propias del usuario (`.tamnora/plugins/*.mjs`).
+  ctx.plugins = await createPlugins(ctx, config.plugins ?? []);
+
   // Canales de mensajeria (Telegram via long polling) si hay token.
   const channels = createChannelsManager(ctx, {
     enabled: telegram,
@@ -223,6 +233,9 @@ export async function createTamnoraServer({
   channels.load();
   ctx.channels = channels;
 
+  // Planificador de tareas (tick cada 30 s). Arranca cuando el server escucha.
+  ctx.scheduler = createScheduler(ctx, { log: (message) => process.stderr.write(`${message}\n`) });
+
   const routes = [];
   const route = (method, pattern, handler) =>
     routes.push({ method, segments: pattern.split('/').filter(Boolean), handler });
@@ -263,6 +276,15 @@ export async function createTamnoraServer({
   registerState(route, ctx);
   registerPresence(route, ctx);
   registerEval(route, ctx);
+  registerSchedules(route, ctx);
+
+  route('GET', '/api/hooks', ({ res }) => {
+    sendJson(res, 200, { hooks: ctx.hooks?.list?.() ?? [] });
+  });
+
+  route('GET', '/api/plugins', ({ res }) => {
+    sendJson(res, 200, { plugins: ctx.plugins?.list?.() ?? [] });
+  });
 
   function matchRoute(method, pathname) {
     const parts = pathname.split('/').filter(Boolean);
@@ -347,6 +369,7 @@ export async function createTamnoraServer({
             url: `http://${address.address === '::' ? '127.0.0.1' : address.address}:${address.port}`,
           };
           ctx.serverInfo = info;
+          ctx.scheduler?.start();
           resolve(info);
         }
       );
@@ -355,6 +378,7 @@ export async function createTamnoraServer({
   const close = async () => {
     approvals.cancelAll();
     runs.cancelAll();
+    ctx.scheduler?.stop();
     channels.stop();
     preview.close();
     procs.close();