@danieltmn/tamnora 0.13.1 → 0.14.0

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

@@ -22,7 +22,7 @@
   --mono: "DM Mono", ui-monospace, "Cascadia Code", "JetBrains Mono", "SF Mono", Consolas, monospace;
   --font: var(--sans);
   --chat-font: 14.5px;
-  --page-bg: linear-gradient(rgba(11, 12, 8, 0.96), rgba(11, 12, 8, 0.96)), url("/img/fondo-agentes.webp") center/cover fixed no-repeat;
+  --page-bg: #101107;
   color-scheme: dark;
 }
 
@@ -48,7 +48,7 @@ html[data-theme='paper'] {
   --warn: #8a5a00;
   --solid: #f7f2e6;
   --primary-fg: #fbf6ec;
-  --page-bg: linear-gradient(90deg, rgba(248, 244, 234, 0.9), rgba(244, 238, 224, 0.86)), url("/img/fondo-agentes.webp") center/cover fixed no-repeat;
+  --page-bg: #f5efe2;
 }
 html[data-theme='paper'] .tok-comment { color: #7a7669; }
 html[data-theme='paper'] .tok-string { color: #7a4a2c; }
@@ -144,9 +144,11 @@ pre, code, kbd, samp { font-family: var(--mono); }
   #more-menu button.menu-primary { display: none; }
 }
 
-#theme-toggle .ico-moon { display: none; }
-html[data-theme='dark'] #theme-toggle .ico-sun { display: none; }
-html[data-theme='dark'] #theme-toggle .ico-moon { display: block; }
+/* El icono muestra el tema al que se va a cambiar: claro -> luna, oscuro -> sol. */
+#theme-toggle .ico-sun { display: none; }
+#theme-toggle .ico-moon { display: block; }
+html[data-theme='dark'] #theme-toggle .ico-sun { display: block; }
+html[data-theme='dark'] #theme-toggle .ico-moon { display: none; }
 .menu-pop {
   position: absolute;
   top: calc(100% + 4px);
@@ -1384,9 +1386,12 @@ pre.code code { background: none; border: 0; padding: 0; font-size: 0.92em; }
   background: var(--rail);
   backdrop-filter: blur(14px);
 }
-.explorer-head { display: flex; align-items: center; gap: 6px; padding: 9px 12px; border-bottom: 1px solid var(--border); }
+.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. */
+.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; }
 .explorer-filter { padding: 9px 12px; }
@@ -1407,8 +1412,9 @@ 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; }
-.xtab { border: 0; background: none; color: var(--muted); cursor: pointer; font: 600 12px var(--sans); padding: 4px 7px; border-radius: 7px; }
+.xtabs { display: flex; gap: 4px; min-width: 0; flex: 0 1 auto; overflow-x: auto; scrollbar-width: none; }
+.xtabs::-webkit-scrollbar { display: none; }
+.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); }
 .xp-pane { display: flex; flex-direction: column; flex: 1; min-height: 0; }
@@ -1566,8 +1572,9 @@ dialog.file-modal.preview-maximized {
 }
 
 /* panel heads + collapsed handles ----------------------------------------- */
-.panel-head { display: flex; align-items: center; gap: 8px; padding: 2px 2px 6px; }
-.panel-head-title { flex: 1; font: 700 13px var(--serif); letter-spacing: -0.02em; color: var(--muted); text-transform: lowercase; }
+.panel-head { display: flex; align-items: center; gap: 8px; padding: 2px 2px 6px; min-width: 0; }
+.panel-head-title { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font: 700 13px var(--serif); letter-spacing: -0.02em; color: var(--muted); text-transform: lowercase; }
+.panel-head .btn.icon { flex: 0 0 auto; }
 .panel-handle {
   position: absolute;
   top: 50%;

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

@@ -35,6 +35,27 @@ export function combineToolset({ local, admin = null, tasks = null, exposeAdmin
   return { definitions, execute };
 }
 
+/**
+ * Combina varios handlers de `onLifecycle` en uno: los corre a todos y concatena
+ * los `inject` que devuelvan (reglas por path, más tarde hooks).
+ */
+export function combineLifecycle(handlers = []) {
+  const active = handlers.filter(Boolean);
+  if (!active.length) return null;
+  return async function onLifecycle(event) {
+    const injects = [];
+    for (const handler of active) {
+      const out = await Promise.resolve()
+        .then(() => handler(event))
+        .catch(() => undefined);
+      if (out && typeof out === 'object' && typeof out.inject === 'string' && out.inject.trim()) {
+        injects.push(out.inject);
+      }
+    }
+    return injects.length ? { inject: injects.join('\n\n') } : undefined;
+  };
+}
+
 /** Resuelve proveedor + config con la API key almacenada. */
 export function resolveProviderFor(ctx, providerId, extra = {}) {
   return ctx.resolveProvider({

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

@@ -0,0 +1,106 @@
+// Checkpoints: pre-imagen de los archivos que `write`/`edit` van a tocar, para
+// poder "deshacer" un turno. Se guardan en la casa (`checkpoints/`), no en el
+// workspace, asi no ensucian el repo. Indexados por `sessionId` + turno (id del
+// mensaje del usuario que abrio el run).
+
+import path from 'node:path';
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { homeDir, resolveInRoot } from './core.js';
+
+const MAX_FILE_BYTES = 512 * 1024;
+
+function checkpointsDir() {
+  return path.join(homeDir(), 'checkpoints');
+}
+
+function manifestPath(sessionId) {
+  const safe = String(sessionId).replace(/[^a-zA-Z0-9_-]/g, '-');
+  return path.join(checkpointsDir(), `${safe}.json`);
+}
+
+async function readManifest(sessionId) {
+  try {
+    return JSON.parse(await readFile(manifestPath(sessionId), 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+async function writeManifest(sessionId, manifest) {
+  await mkdir(checkpointsDir(), { recursive: true });
+  await writeFile(manifestPath(sessionId), JSON.stringify(manifest), 'utf8');
+}
+
+/**
+ * Handler de `onLifecycle` que, antes de un `write`/`edit`, guarda la version
+ * previa del archivo (o marca que no existia) para el turno `turnId`.
+ */
+export function createCheckpointer(ctx, { sessionId, cwd, turnId }) {
+  if (!sessionId || !turnId) return null;
+  return async function onLifecycle(event) {
+    if (event?.type !== 'tool.before') return undefined;
+    if (event.name !== 'write' && event.name !== 'edit') return undefined;
+    const rel = String(event.args?.path ?? '').trim();
+    if (!rel) return undefined;
+    let abs;
+    try {
+      abs = resolveInRoot(cwd, rel);
+    } catch {
+      return undefined;
+    }
+    let entry;
+    try {
+      const st = await stat(abs);
+      if (!st.isFile() || st.size > MAX_FILE_BYTES) return undefined;
+      entry = { path: rel, existed: true, content: (await readFile(abs)).toString('base64') };
+    } catch {
+      entry = { path: rel, existed: false, content: null };
+    }
+    const manifest = await readManifest(sessionId);
+    const list = manifest[turnId] ?? (manifest[turnId] = []);
+    if (!list.some((item) => item.path === rel)) list.push(entry);
+    await writeManifest(sessionId, manifest);
+    return undefined;
+  };
+}
+
+/** Turnos (ids de mensaje) que tienen checkpoint guardado. */
+export async function checkpointTurns(sessionId) {
+  return Object.keys(await readManifest(sessionId));
+}
+
+/** Restaura los archivos del turno y trunca el historial desde ese mensaje. */
+export async function rewindSession(ctx, sessionId, turnId) {
+  const session = ctx.store.getSession(sessionId);
+  const cwd = session?.cwd || ctx.cwd;
+  const manifest = await readManifest(sessionId);
+  const entries = manifest[turnId] ?? [];
+  let restored = 0;
+  const files = [];
+  for (const entry of entries) {
+    let abs;
+    try {
+      abs = resolveInRoot(cwd, entry.path);
+    } catch {
+      continue;
+    }
+    try {
+      if (entry.existed) {
+        await mkdir(path.dirname(abs), { recursive: true });
+        await writeFile(abs, Buffer.from(entry.content ?? '', 'base64'));
+      } else {
+        await rm(abs, { force: true });
+      }
+      restored += 1;
+      files.push(entry.path);
+    } catch {
+      // un archivo que no se pudo restaurar no frena el resto
+    }
+  }
+  const removed = ctx.store.deleteMessagesFrom(sessionId, turnId);
+  if (manifest[turnId]) {
+    delete manifest[turnId];
+    await writeManifest(sessionId, manifest);
+  }
+  return { restored, removed, files, turnId };
+}

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

@@ -0,0 +1,183 @@
+// 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, 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/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
@@ -254,8 +256,12 @@ 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 }),
+    ]);
 
     (async () => {
       const startedAt = Date.now();
@@ -270,7 +276,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,

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,8 @@ 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';
 
 const VERSION = readPackageVersion();
 
@@ -223,6 +225,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 +268,7 @@ export async function createTamnoraServer({
   registerState(route, ctx);
   registerPresence(route, ctx);
   registerEval(route, ctx);
+  registerSchedules(route, ctx);
 
   function matchRoute(method, pathname) {
     const parts = pathname.split('/').filter(Boolean);
@@ -347,6 +353,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 +362,7 @@ export async function createTamnoraServer({
   const close = async () => {
     approvals.cancelAll();
     runs.cancelAll();
+    ctx.scheduler?.stop();
     channels.stop();
     preview.close();
     procs.close();