agent-workbench 0.8.1 → 0.9.0

package/dist/server.js

@@ -3,7 +3,7 @@
 // packages/server/src/index.ts
 import { existsSync as existsSync4 } from "node:fs";
 import { createServer } from "node:http";
-import path75 from "node:path";
+import path77 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import express from "express";
 
@@ -83,6 +83,27 @@ function serverText(key, ...params) {
   const [values] = params;
   return values === void 0 ? { key } : { key, params: values };
 }
+function parseServerText(value, depth = 0) {
+  const record = asRecord(value);
+  if (record === null) return null;
+  const key = asString(record["key"]);
+  if (key === null || key.length === 0) return null;
+  const rawParams = record["params"];
+  if (rawParams === void 0) return { key };
+  const paramsRecord = asRecord(rawParams);
+  if (paramsRecord === null) return null;
+  const params = {};
+  for (const [name, param] of Object.entries(paramsRecord)) {
+    if (typeof param === "string" || typeof param === "number" && Number.isFinite(param)) {
+      params[name] = param;
+      continue;
+    }
+    const nested = depth === 0 ? parseServerText(param, depth + 1) : null;
+    if (nested === null) return null;
+    params[name] = nested;
+  }
+  return { key, params };
+}
 var ServerTextError = class extends Error {
   text;
   constructor(text, options) {
@@ -241,6 +262,9 @@ function sameQuestionItem(a, b) {
     return left.length > 0 && right.length > 0 && (left.startsWith(right) || right.startsWith(left));
   });
 }
+function askedBeforeLaunch(askedAt, launchedAt) {
+  return askedAt > 0 && launchedAt !== null && askedAt < launchedAt;
+}
 var CONVERSATION_IMAGE_SOURCES = [
   "content",
   "attachment",
@@ -498,6 +522,17 @@ function parseComposerDraft(value) {
   return { text, pasted: pasted2 };
 }
 
+// packages/shared/src/scheduled-messages.ts
+var MAX_SCHEDULED_MESSAGES = 50;
+var MAX_SCHEDULED_TEXT_CHARS = 2e5;
+var MAX_SCHEDULE_AHEAD_MS = 30 * 24 * 60 * 60 * 1e3;
+var SCHEDULE_LATE_LIMIT_MS = 60 * 60 * 1e3;
+function scheduleTimeProblem(sendAt, now) {
+  if (!Number.isFinite(sendAt) || sendAt <= now) return "past";
+  if (sendAt - now > MAX_SCHEDULE_AHEAD_MS) return "too-far";
+  return null;
+}
+
 // packages/shared/src/memory.ts
 var MEMORY_DIR = ".agents/memory";
 var MEMORY_INDEX_FILE = "MEMORY.md";
@@ -857,13 +892,16 @@ function asAgentIdList(value) {
 function parseAppSettingsChange(record) {
   const rawShell = record["consoleShell"];
   const rawAgents = record["disabledAgents"];
+  const rawScheduled = record["scheduledMessages"];
   const consoleShell = rawShell === void 0 ? void 0 : asConsoleShellId(rawShell);
   const disabledAgents = rawAgents === void 0 ? void 0 : asAgentIdList(rawAgents);
-  if (consoleShell === null || disabledAgents === null) return null;
-  if (consoleShell === void 0 && disabledAgents === void 0) return null;
+  const scheduledMessages = rawScheduled === void 0 ? void 0 : typeof rawScheduled === "boolean" ? rawScheduled : null;
+  if (consoleShell === null || disabledAgents === null || scheduledMessages === null) return null;
+  if (consoleShell === void 0 && disabledAgents === void 0 && scheduledMessages === void 0) return null;
   return {
     ...consoleShell !== void 0 ? { consoleShell } : {},
-    ...disabledAgents !== void 0 ? { disabledAgents } : {}
+    ...disabledAgents !== void 0 ? { disabledAgents } : {},
+    ...scheduledMessages !== void 0 ? { scheduledMessages } : {}
   };
 }
 
@@ -1300,6 +1338,21 @@ function parseClientMessage(raw) {
       const draft = parseComposerDraft(record["draft"]);
       return terminalId === null || draft === null ? null : { type: "composer.draft", terminalId, draft };
     }
+    case "schedule.create": {
+      const requestId = asNonEmptyString(record["requestId"]);
+      const terminalId = asNonEmptyString(record["terminalId"]);
+      const text = asString(record["text"]);
+      const sendAt = asFiniteNumber(record["sendAt"]);
+      return requestId === null || terminalId === null || text === null || sendAt === null ? null : { type: "schedule.create", requestId, terminalId, text, sendAt };
+    }
+    case "schedule.cancel": {
+      const id = asNonEmptyString(record["id"]);
+      return id === null ? null : { type: "schedule.cancel", id };
+    }
+    case "schedule.sendNow": {
+      const id = asNonEmptyString(record["id"]);
+      return id === null ? null : { type: "schedule.sendNow", id };
+    }
     case "settings.update": {
       const change = parseAppSettingsChange(record);
       return change === null ? null : { type: "settings.update", ...change };
@@ -1382,8 +1435,8 @@ function parseClientMessage(raw) {
     case "worktree.changesDiff": {
       const requestId = asNonEmptyString(record["requestId"]);
       const worktreeId = asNonEmptyString(record["worktreeId"]);
-      const path76 = asNonEmptyString(record["path"]);
-      return requestId === null || worktreeId === null || path76 === null ? null : { type: "worktree.changesDiff", requestId, worktreeId, path: path76 };
+      const path78 = asNonEmptyString(record["path"]);
+      return requestId === null || worktreeId === null || path78 === null ? null : { type: "worktree.changesDiff", requestId, worktreeId, path: path78 };
     }
     case "worktree.requestReview": {
       const requestId = asNonEmptyString(record["requestId"]);
@@ -1521,6 +1574,15 @@ function notesImagesDir() {
 function composerDraftsPath() {
   return path.join(appConfigDir(), "composer-drafts.json");
 }
+function scheduledMessagesPath() {
+  return path.join(appConfigDir(), "scheduled-messages.json");
+}
+function scheduledClaimsDir() {
+  return path.join(appConfigDir(), "scheduled-claims");
+}
+function runningInstancesDir() {
+  return path.join(appConfigDir(), "instances");
+}
 function catalogTempDir() {
   return path.join(tmpdir(), "agent-workbench", "agy-catalog");
 }
@@ -2970,9 +3032,9 @@ function toTitle(raw) {
   return text;
 }
 function withoutPastedText(raw) {
-  const normalized = raw.replace(/\r\n?/g, "\n");
-  const typed = normalized.replace(pastedBlockPattern(), "$1");
-  return typed.trim().length > 0 ? typed : normalized.replace(pastedBoundaryPattern(), " ");
+  const normalized2 = raw.replace(/\r\n?/g, "\n");
+  const typed = normalized2.replace(pastedBlockPattern(), "$1");
+  return typed.trim().length > 0 ? typed : normalized2.replace(pastedBoundaryPattern(), " ");
 }
 
 // packages/server/src/agents/antigravity/session-follower.ts
@@ -3240,12 +3302,12 @@ function blockPattern(name) {
   return new RegExp(`<${name}>([\\s\\S]*?)</${name}>`, "g");
 }
 function unwrapUserInput(content) {
-  const open9 = content.indexOf(REQUEST_OPEN);
-  const close = open9 === -1 ? -1 : content.indexOf(REQUEST_CLOSE, open9 + REQUEST_OPEN.length);
+  const open10 = content.indexOf(REQUEST_OPEN);
+  const close = open10 === -1 ? -1 : content.indexOf(REQUEST_CLOSE, open10 + REQUEST_OPEN.length);
   let text;
   let rest;
-  if (open9 !== -1 && close !== -1) {
-    text = content.slice(open9 + REQUEST_OPEN.length, close).trim();
+  if (open10 !== -1 && close !== -1) {
+    text = content.slice(open10 + REQUEST_OPEN.length, close).trim();
     rest = content.slice(close + REQUEST_CLOSE.length);
   } else {
     text = content.replace(blockPattern("ADDITIONAL_METADATA"), "").replace(blockPattern("USER_SETTINGS_CHANGE"), "").trim();
@@ -4068,6 +4130,15 @@ function createAntigravityQueueEdit() {
   return { run: (io, context) => runAntigravityQueueEdit(io, context) };
 }
 
+// packages/server/src/agents/antigravity/ready-screen.ts
+function antigravityReadyScreen(lines) {
+  const screen = readAntigravityQueueScreen(lines);
+  if (screen === null || screen.queued) return false;
+  const tail = lines.filter((line) => line.trim() !== "").slice(-3);
+  if (tail.some((line) => /esc to cancel|Generating/.test(line))) return false;
+  return tail.some((line) => /^\s*\? for shortcuts/.test(line));
+}
+
 // packages/server/src/agents/antigravity/settings.ts
 import { readFile as readFile4, stat as stat7 } from "node:fs/promises";
 var SETTINGS_MAX_BYTES = 256 * 1024;
@@ -4652,6 +4723,8 @@ var ANTIGRAVITY_BASE_CAPABILITIES = {
   forceSend: true,
   // La flecha arriba saca la cola al editor, y Ctrl+U Ctrl+K lo vacian sin cortar el turno (1.4.4, §6.35.1).
   editQueue: true,
+  // Hito 52: sin status line no se sabe si trabaja, y no se le programa nada.
+  scheduledSend: false,
   /*
     Hito 49: `--mode plan`. Medido con la 1.4.0 al lanzar: arranca en "Plan
     mode: research & plan only" y el ciclo sigue desde ahi. Que hace con
@@ -4663,7 +4736,13 @@ var ANTIGRAVITY_STATUS_LINE_CAPABILITIES = {
   ...ANTIGRAVITY_BASE_CAPABILITIES,
   statusSource: true,
   readySignal: READY_SIGNAL_SAFE,
-  contextWindowSource: "status-line"
+  contextWindowSource: "status-line",
+  /*
+    Hito 52 (§12.17): con la status line si. Al retomar una conversacion, el
+    primer "libre" escrito despues de lanzarla llego cuando su pantalla ya
+    aceptaba un pegado (3 de 3), y la caja vacia lo confirma.
+  */
+  scheduledSend: true
 };
 var ANTIGRAVITY_INPUT = {
   imageReference: null,
@@ -4858,6 +4937,8 @@ function createAntigravityAdapter(options = {}) {
       es lo que la app le mando con el agente trabajando. "Enviar ya" es Alt+M.
     */
     promptQueue: { source: "app", forceSend: "alt-m" },
+    // Hito 52 (§12.17): con la status line, que dice si trabaja; lo escrito se confirma cuando pasa a trabajando.
+    scheduled: { kind: "screen", readyScreen: antigravityReadyScreen, confirmTimeoutMs: 6e4 },
     // Sacar la cola para editarla en el cuadro (§6.35.1): vuelve lo que la app le mando.
     queueEdit: createAntigravityQueueEdit(),
     /**
@@ -5087,6 +5168,17 @@ async function readAgentDefaults(cwd, sessionModel = null) {
 import { readdir as readdir7, readFile as readFile8 } from "node:fs/promises";
 import path14 from "node:path";
 
+// packages/server/src/process-alive.ts
+function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+
 // packages/server/src/agents/claude-code/paths.ts
 import { homedir as homedir4, tmpdir as tmpdir2 } from "node:os";
 import path13 from "node:path";
@@ -5127,7 +5219,16 @@ function readStatus(value) {
     statusUpdatedAt: typeof updatedAt === "number" && Number.isFinite(updatedAt) ? updatedAt : null
   };
 }
+function fileCounts(record, isAlive) {
+  const pid = record["pid"];
+  return typeof pid !== "number" || isAlive(pid);
+}
 var CliStatusWatcher = class {
+  /** Inyectable para el chequeo, que no puede inventar procesos vivos. */
+  constructor(isAlive = processAlive) {
+    this.isAlive = isAlive;
+  }
+  isAlive;
   subscriptions = /* @__PURE__ */ new Set();
   timer = null;
   reading = false;
@@ -5176,6 +5277,34 @@ var CliStatusWatcher = class {
       await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
     }
   }
+  /**
+   * true si algun proceso vivo de la CLI tiene esa conversacion (hito 51,
+   * §6.39). Cuenta tambien el archivo que todavia no escribio su estado: la CLI
+   * lo crea antes de decir si esta libre (medido con la 2.1.310), y ese proceso
+   * ya tiene la conversacion abierta.
+   */
+  async isOpen(sessionId) {
+    const root = cliSessionsStateRoot();
+    let names;
+    try {
+      names = await readdir7(root);
+    } catch {
+      return false;
+    }
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(await readFile8(path14.join(root, name), "utf8"));
+      } catch {
+        continue;
+      }
+      if (typeof parsed !== "object" || parsed === null) continue;
+      const record = parsed;
+      if (record["sessionId"] === sessionId && fileCounts(record, this.isAlive)) return true;
+    }
+    return false;
+  }
   dispose() {
     this.subscriptions.clear();
     this.stop();
@@ -5214,8 +5343,10 @@ var CliStatusWatcher = class {
         continue;
       }
       if (typeof parsed !== "object" || parsed === null) continue;
-      const sessionId = parsed["sessionId"];
+      const record = parsed;
+      const sessionId = record["sessionId"];
       if (typeof sessionId !== "string" || sessionId.length === 0) continue;
+      if (!fileCounts(record, this.isAlive)) continue;
       const status = readStatus(parsed);
       if (status !== null) found.set(sessionId, status);
     }
@@ -5896,11 +6027,11 @@ function relativeInside(root, absolute) {
 }
 function planFileNameOf(value) {
   if (typeof value !== "string" || value.length === 0) return null;
-  const normalized = value.replace(/\\/g, "/");
+  const normalized2 = value.replace(/\\/g, "/");
   const marker = "/.claude/plans/";
-  const at = normalized.toLowerCase().lastIndexOf(marker);
+  const at = normalized2.toLowerCase().lastIndexOf(marker);
   if (at === -1) return null;
-  const name = normalized.slice(at + marker.length);
+  const name = normalized2.slice(at + marker.length);
   if (name.length === 0 || name.includes("/")) return null;
   if (name === "." || name === "..") return null;
   return name;
@@ -5980,18 +6111,18 @@ var BranchTracker = class {
   }
   /** La linea y todas las de las que cuelga. */
   pathFrom(leaf) {
-    const path76 = /* @__PURE__ */ new Set();
+    const path78 = /* @__PURE__ */ new Set();
     let current = leaf;
-    while (current !== null && !path76.has(current)) {
+    while (current !== null && !path78.has(current)) {
       const node = this.nodes.get(current);
       if (node === void 0) break;
-      path76.add(current);
+      path78.add(current);
       current = node.parent;
     }
-    return path76;
+    return path78;
   }
   recompute() {
-    const path76 = this.pathFrom(this.leaf());
+    const path78 = this.pathFrom(this.leaf());
     const children = /* @__PURE__ */ new Map();
     for (const [uuid, node] of this.nodes) {
       const key = node.parent !== null && this.nodes.has(node.parent) ? node.parent : null;
@@ -6000,9 +6131,9 @@ var BranchTracker = class {
       else list.push(uuid);
     }
     const roots = [];
-    for (const uuid of children.get(null) ?? []) if (!path76.has(uuid)) roots.push(uuid);
-    for (const uuid of path76) {
-      for (const child of children.get(uuid) ?? []) if (!path76.has(child)) roots.push(child);
+    for (const uuid of children.get(null) ?? []) if (!path78.has(uuid)) roots.push(uuid);
+    for (const uuid of path78) {
+      for (const child of children.get(uuid) ?? []) if (!path78.has(child)) roots.push(child);
     }
     const hidden = /* @__PURE__ */ new Set();
     for (const root of roots) {
@@ -8019,6 +8150,12 @@ var CLAUDE_CODE_CAPABILITIES = {
   forceSend: true,
   // La flecha arriba saca la cola a su caja, y Ctrl+U Ctrl+K la vacian sin cortar el turno (2.1.309, §6.35.1).
   editQueue: true,
+  /*
+    Hito 51: su archivo de `sessions/` dice si esta libre, si otro proceso tiene
+    la conversacion (con el pid vivo: el de una CLI matada queda, medido con la
+    2.1.310) y cuando quedo lista despues de abrirla (§6.39).
+  */
+  scheduledSend: true,
   /*
     Hito 49: `--permission-mode plan`. Medido con la 2.1.304 y el pedido de
     revision: corrio git log, diff y status sin pedir permiso, no ofrecio salir
@@ -8052,6 +8189,8 @@ function createStatusSource(watcher) {
       )
     ),
     waitUntilReady: (sessionId, timeoutMs) => watcher.waitUntilIdle(sessionId, timeoutMs),
+    // Hito 51: antes de abrir una pestana dormida para un mensaje programado.
+    isOpen: (sessionId) => watcher.isOpen(sessionId),
     dispose: () => watcher.dispose()
   };
 }
@@ -8672,9 +8811,9 @@ var CodexSessionDiscovery = class {
       onInput: () => void 0,
       onSubmitted: (text) => {
         if (released || this.pending.get(terminalId) !== tab) return;
-        const normalized = normalizeMessageText(text);
-        if (normalized.length === 0) return;
-        tab.submitted.push(normalized);
+        const normalized2 = normalizeMessageText(text);
+        if (normalized2.length === 0) return;
+        tab.submitted.push(normalized2);
         if (tab.submitted.length > MAX_SUBMITTED) tab.submitted.splice(0, tab.submitted.length - MAX_SUBMITTED);
       }
     };
@@ -9089,6 +9228,13 @@ var CodexRolloutSink = class {
   turns = [];
   /** Llamadas del turno en curso sin resultado todavia: `call_id` -> epoch ms. */
   openCalls = /* @__PURE__ */ new Map();
+  /**
+   * Desde cuando hay un turno abierto (epoch ms; 0 si su linea no trae hora), o
+   * null. Hito 52: Codex no publica si trabaja, y el reloj de los mensajes
+   * programados no le escribe con un turno abierto (§10.13: le cortaria la
+   * respuesta).
+   */
+  turnOpenSince = null;
   warnedForeignMeta = false;
   getUsage() {
     return this.usage;
@@ -9114,7 +9260,13 @@ var CodexRolloutSink = class {
     }
     return false;
   }
+  /** Ver `SessionFollower.hasOpenTurn`. Un turno sin hora no se sabe de que proceso es: cuenta. */
+  hasOpenTurn(launchedAt) {
+    if (this.turnOpenSince === null) return false;
+    return this.turnOpenSince === 0 || this.turnOpenSince >= launchedAt;
+  }
   reset() {
+    this.turnOpenSince = null;
     this.model = null;
     this.effort = null;
     this.window = null;
@@ -9196,6 +9348,7 @@ var CodexRolloutSink = class {
     if (TURN_START_TYPES.includes(kind)) {
       this.lastAssistantEventId = null;
       this.openCalls.clear();
+      this.turnOpenSince = at;
       const window = readWindow(payload["model_context_window"]);
       if (window !== null) {
         this.window = window;
@@ -9217,6 +9370,7 @@ var CodexRolloutSink = class {
     }
     if (TURN_END_TYPES.includes(kind)) {
       this.openCalls.clear();
+      this.turnOpenSince = null;
       const duration = payload["duration_ms"];
       const eventId = this.lastAssistantEventId;
       this.lastAssistantEventId = null;
@@ -9450,6 +9604,9 @@ var CodexSessionFollower = class {
   hasOpenToolCall(launchedAt) {
     return this.sink.hasOpenToolCall(launchedAt);
   }
+  hasOpenTurn(launchedAt) {
+    return this.sink.hasOpenTurn(launchedAt);
+  }
   getState() {
     return this.jsonl.getState();
   }
@@ -9597,6 +9754,18 @@ function createCodexHistory(options = {}) {
   };
 }
 
+// packages/server/src/agents/codex/ready-screen.ts
+var BUSY = /esc to interrupt|Working \(|Waiting for startup|esc cancel/;
+var FOOTER = /\? for shortcuts/;
+var COMPOSER = /^\s*›\s/;
+function codexReadyScreen(lines) {
+  const tail = lines.filter((line) => line.trim() !== "").slice(-8);
+  if (tail.some((line) => BUSY.test(line))) return false;
+  const footer = tail.findIndex((line) => FOOTER.test(line));
+  if (footer <= 0) return false;
+  return tail.slice(0, footer).some((line) => COMPOSER.test(line));
+}
+
 // packages/server/src/agents/codex/index.ts
 var CODEX_COMMAND = "codex";
 var CODEX_INSTALL_URL = "https://learn.chatgpt.com/docs/codex/cli";
@@ -9632,6 +9801,11 @@ var CODEX_CAPABILITIES = {
   // No hace cola: un mensaje con el agente trabajando le llega al modelo en el acto (hito 45).
   forceSend: false,
   editQueue: false,
+  /*
+    Hito 52 (§10.18): por su pantalla, cuando muestra la caja vacia y el
+    historial no tiene un turno abierto. Codex no publica si trabaja.
+  */
+  scheduledSend: true,
   /*
     Hito 49: `--sandbox read-only`, al abrir y al reanudar. Medido con la 0.162.1
     y un proveedor falso: con la sandbox de Windows del usuario, escribir fallo
@@ -9718,6 +9892,13 @@ function createCodexAdapter() {
     },
     history: createCodexHistory({ planLimits }),
     status: null,
+    /*
+      Hito 52 (§10.18): un mensaje programado se escribe cuando la pantalla
+      muestra la caja vacia. Con el daemon en frio lo escrito espera en la caja
+      ("Waiting for startup") y llego a los 40 s: la confirmacion espera dos
+      minutos.
+    */
+    scheduled: { kind: "screen", readyScreen: codexReadyScreen, confirmTimeoutMs: 12e4 },
     planLimits,
     defaults: () => Promise.resolve(null),
     /**
@@ -10379,7 +10560,22 @@ FROM part WHERE id = $id AND json_extract(data, '$.type') = 'file'`,
    * `question`; `$id` y `$s`.
    */
   partCallById: `SELECT message_id, json_extract(data, '$.callID') AS call_id
-FROM part WHERE id = $id AND session_id = $s AND json_extract(data, '$.tool') = 'question'`
+FROM part WHERE id = $id AND session_id = $s AND json_extract(data, '$.tool') = 'question'`,
+  /**
+   * Hito 52 (§11.16). El agente, el modelo y la variante del ultimo mensaje del
+   * usuario de UNA sesion, para mandar un mensaje programado por `prompt_async`
+   * con los de la conversacion: sin agente, OpenCode usa el predeterminado
+   * (medido con la 1.19.4). Solo esos cuatro campos; `$s`. Los del ultimo
+   * instante, en el orden de siempre (regla 3): el ultimo de la lista es el que
+   * vale.
+   */
+  lastUserPrompt: `SELECT json_extract(data, '$.agent') AS agent,
+  json_extract(data, '$.model.providerID') AS provider_id,
+  json_extract(data, '$.model.modelID') AS model_id,
+  json_extract(data, '$.variant') AS variant
+FROM message WHERE session_id = $s AND json_extract(data, '$.role') = 'user'
+  AND time_created = (SELECT max(time_created) FROM message WHERE session_id = $s AND json_extract(data, '$.role') = 'user')
+ORDER BY time_created, id`
 });
 var OPENCODE_REQUIRED_COLUMNS = Object.freeze([
   { table: "session", columns: ["id", "parent_id", "directory", "title", "time_created", "time_updated", "revert"] },
@@ -11246,6 +11442,29 @@ var OpenCodeServeClient = class {
     if (!OPENCODE_SESSION_ID_PATTERN.test(sessionId)) throw new Error("Invalid OpenCode session id.");
     await this.request("POST", `/session/${sessionId}/abort`, directory, {});
   }
+  /**
+   * Hito 52 (§11.16). Manda un mensaje a la sesion sin esperar la respuesta:
+   * `POST /session/{id}/prompt_async`, que contesta 204 y deja el mensaje en la
+   * base en el acto; el TUI enganchado lo muestra como uno mas (medido con la
+   * 1.19.4, a los ~2 s). Sin agente, OpenCode usa el predeterminado y no el de
+   * la conversacion: por eso se le pasan el agente, el modelo y la variante del
+   * ultimo mensaje del usuario, si se conocen. `not-sent` si la sesion no existe
+   * (404): no se mando nada. Otro fallo lanza: no se sabe si lo tomo.
+   */
+  async promptAsync(directory, sessionId, text, choice) {
+    if (!OPENCODE_SESSION_ID_PATTERN.test(sessionId)) throw new Error("Invalid OpenCode session id.");
+    const body = { parts: [{ type: "text", text }] };
+    if (choice?.agent) body["agent"] = choice.agent;
+    if (choice?.providerID && choice.modelID) body["model"] = { providerID: choice.providerID, modelID: choice.modelID };
+    if (choice?.variant) body["variant"] = choice.variant;
+    try {
+      await this.request("POST", `/session/${sessionId}/prompt_async`, directory, body);
+      return "sent";
+    } catch (error) {
+      if (error instanceof ServeRequestError && error.status === 404) return "not-sent";
+      throw error;
+    }
+  }
   /**
    * El flujo de `/global/event`. Reconecta con las esperas de
    * `SERVE_RECONNECT_DELAYS_MS` y llama `onReconnect` **cada vez que la conexion
@@ -12286,6 +12505,22 @@ var OpenCodeServeStatus = class {
   }
 };
 
+// packages/server/src/agents/opencode/scheduled.ts
+var OPENCODE_SCHEDULED_CONFIRM_MS = 3e4;
+function shortText2(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 200 ? value : null;
+}
+function readLastUserPrompt(db, sessionId) {
+  const row = db.all(OPENCODE_SQL.lastUserPrompt, { $s: sessionId }).at(-1);
+  if (row === void 0) return null;
+  return {
+    agent: shortText2(row.agent),
+    providerID: shortText2(row.provider_id),
+    modelID: shortText2(row.model_id),
+    variant: shortText2(row.variant)
+  };
+}
+
 // packages/server/src/agents/opencode/index.ts
 var OPENCODE_COMMAND = "opencode";
 var OPENCODE_INSTALL_URL = "https://opencode.ai/docs/";
@@ -12336,6 +12571,11 @@ var OPENCODE_CAPABILITIES = {
   forceSend: false,
   // El mensaje en cola ya esta escrito en su base (§11.13): no hay de donde sacarlo.
   editQueue: false,
+  /*
+    Hito 52 (§11.16): por la API de su `serve` (`prompt_async`), sin tocar la
+    pantalla del TUI, con el agente y el modelo del ultimo mensaje.
+  */
+  scheduledSend: true,
   /*
     Hito 49: ninguno. Su agente `plan` pide permiso antes de editar, pero la app
     abre el TUI con `opencode attach`, que segun su documentacion no acepta
@@ -12461,6 +12701,27 @@ function createOpenCodeAdapter(options = {}) {
     questions,
     // La cola la dice la base: un mensaje sin respuesta detras de uno que se esta contestando (hito 45, §11.13).
     promptQueue: { source: "session", forceSend: null },
+    /*
+      Hito 52 (§11.16): un mensaje programado va por `prompt_async` del `serve`
+      que la pestana abierta ya levanto, con el agente, el modelo y la variante
+      del ultimo mensaje del usuario. Sin `serve`, o sin poder leer la base, no
+      se manda nada: sin el agente, OpenCode usaria el predeterminado.
+    */
+    scheduled: {
+      kind: "api",
+      confirmTimeoutMs: OPENCODE_SCHEDULED_CONFIRM_MS,
+      deliver: async (target, text) => {
+        const client = current?.client ?? null;
+        if (client === null) return "not-sent";
+        let choice;
+        try {
+          choice = readLastUserPrompt(db, target.sessionId);
+        } catch {
+          return "not-sent";
+        }
+        return client.promptAsync(target.cwd, target.sessionId, text, choice);
+      }
+    },
     /**
      * La base que se lee, para el arranque. Solo si hay algo que decir, para que
      * quien no usa OpenCode no vea una linea nueva:
@@ -13086,8 +13347,8 @@ function textOf2(message) {
 }
 function sameFile(a, b) {
   const normalize3 = (value) => {
-    const normalized = path36.normalize(value);
-    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+    const normalized2 = path36.normalize(value);
+    return process.platform === "win32" ? normalized2.toLowerCase() : normalized2;
   };
   return normalize3(a) === normalize3(b);
 }
@@ -14086,6 +14347,23 @@ function createPiQueueEdit(timing = DEFAULT_TIMING3) {
   return { run: (io, context) => runPiQueueEdit(io, context, piDequeueKeys(), timing) };
 }
 
+// packages/server/src/agents/pi/ready-screen.ts
+function isBorder2(line) {
+  return /^─{2}.*─{6,}$/.test(line.trim());
+}
+function piReadyScreen(lines) {
+  const screen = readPiQueueScreen(lines);
+  if (screen === null || screen.editor.length > 0 || screen.queued) return false;
+  const borders = [];
+  lines.forEach((line, index) => {
+    if (isBorder2(line)) borders.push(index);
+  });
+  const top = borders.at(-2);
+  if (top === void 0) return false;
+  if (/[A-Za-z]/.test(lines[top] ?? "")) return false;
+  return lines.slice(0, top).some((line) => line.trim() !== "" && !isBorder2(line));
+}
+
 // packages/server/src/agents/pi/tab-watch.ts
 import { readdir as readdir11, stat as stat25 } from "node:fs/promises";
 import path40 from "node:path";
@@ -14208,9 +14486,9 @@ var PiTabWatch = class {
   checkTrust() {
     if (this.closed || this.sessionId.length === 0) return;
     const output = this.context.readOutput();
-    const open9 = trustDialogOpen(output);
-    this.live.setBlocked(this.sessionId, open9);
-    if (open9) return;
+    const open10 = trustDialogOpen(output);
+    this.live.setBlocked(this.sessionId, open10);
+    if (open10) return;
     if (interfaceStarted(output) || this.now() - this.context.launchedAt > STARTUP_DEADLINE_MS) {
       if (this.startupTimer !== null) clearInterval(this.startupTimer);
       this.startupTimer = null;
@@ -14380,6 +14658,11 @@ var PI_BASE_CAPABILITIES = {
     (§6.35.1). Medido en Windows; fuera, la tecla es Alt+Up y no esta medida.
   */
   editQueue: process.platform === "win32",
+  /*
+    Hito 52 (§16.21): por su pantalla, cuando muestra el editor vacio con la
+    cabecera ya dibujada (un Enter antes, Pi no lo manda), y libre por su estado.
+  */
+  scheduledSend: true,
   // Hito 49: sin `edit` ni `write` (`PI_REVIEW_TOOLS`), pero su consola puede escribir: a medias (§16.19).
   readOnlyLaunch: { mode: null, guard: "tools" }
 };
@@ -14489,6 +14772,8 @@ function createPiAdapter(options = {}) {
       a mandar lo que devolvio a su editor (hito 45, §16.18).
     */
     promptQueue: { source: "app", forceSend: "interrupt-and-resend" },
+    // Hito 52 (§16.21): el mensaje entra a la sesion unos 50 ms despues del Enter.
+    scheduled: { kind: "screen", readyScreen: piReadyScreen, confirmTimeoutMs: 6e4 },
     // Sacar la cola para editarla en el cuadro (§6.35.1): vuelve lo que la app le mando.
     queueEdit: createPiQueueEdit(),
     // `settings.json` no se abre: sin modelo por defecto que anunciar. Al reanudar,
@@ -15214,12 +15499,13 @@ var ConversationHub = class extends EventEmitter {
   /**
    * Avisa la pregunta leida de la pantalla si cambio. No se avisa la que el
    * historial ya tiene abierta: esa tarjeta ya esta en el hilo, con el id de la
-   * CLI, y verla dos veces seria peor que no verla.
+   * CLI, y verla dos veces seria peor que no verla. Una igual que hizo un
+   * proceso anterior no cuenta: esa ya no espera (§5.5.3).
    */
   refreshLiveQuestion(terminalId, entry) {
     if (this.entries.get(terminalId) !== entry) return;
     const read2 = entry.live?.current()?.part ?? null;
-    const pending = read2 === null ? null : this.pendingQuestionOf(entry);
+    const pending = read2 === null ? null : this.pendingQuestionOf(terminalId, entry);
     const item = read2?.questions[0];
     const shown = read2 !== null && item !== void 0 && !(pending?.questions.some((each) => sameQuestionItem(each, item)) ?? false) ? read2 : null;
     if (shown?.toolUseId === entry.liveShown?.toolUseId) return;
@@ -15308,10 +15594,10 @@ var ConversationHub = class extends EventEmitter {
    */
   refreshOpenToolCall(terminalId, entry) {
     const launchedAt = this.isBlind(entry) ? this.registry.launchedAtOf(terminalId) : null;
-    const open9 = launchedAt !== null && entry.follower.hasOpenToolCall(launchedAt);
-    if (open9 === entry.openToolCall) return;
-    entry.openToolCall = open9;
-    this.emit("toolCall", terminalId, open9);
+    const open10 = launchedAt !== null && entry.follower.hasOpenToolCall(launchedAt);
+    if (open10 === entry.openToolCall) return;
+    entry.openToolCall = open10;
+    this.emit("toolCall", terminalId, open10);
   }
   /**
    * Recalcula los subagentes que siguen trabajando y avisa si cambiaron
@@ -15759,10 +16045,15 @@ var ConversationHub = class extends EventEmitter {
    * Se recorre desde el final: la ultima pregunta sin su `tool_result` es la
    * abierta. Si ya tiene resultado —porque se contesto desde la solapa CLI—
    * devuelve null, y esa es la unica defensa contra responder dos veces.
+   *
+   * Tambien devuelve null si la hizo un proceso anterior de la CLI (24-10-2026,
+   * §5.5.3): sin resultado en el archivo, pero la CLI de ahora no tiene ese
+   * menu, y las teclas caerian en su prompt. Sin proceso la pregunta sigue
+   * aca, y la escritura falla con el aviso de la pestana sin CLI.
    */
   getPendingQuestion(terminalId) {
     const entry = this.entries.get(terminalId);
-    return entry === void 0 ? null : this.pendingQuestionOf(entry);
+    return entry === void 0 ? null : this.pendingQuestionOf(terminalId, entry);
   }
   /**
    * La pregunta leida de la pantalla que el hilo esta mostrando (§5.5.4), o
@@ -15792,7 +16083,7 @@ var ConversationHub = class extends EventEmitter {
     if (entry === void 0 || entry.live === null || item === void 0) return "unknown";
     return entry.live.check(item);
   }
-  pendingQuestionOf(entry) {
+  pendingQuestionOf(terminalId, entry) {
     const { events } = entry.follower.getTail(PENDING_QUESTION_LOOKBACK);
     const answered = /* @__PURE__ */ new Set();
     for (const event2 of events) {
@@ -15801,11 +16092,13 @@ var ConversationHub = class extends EventEmitter {
       }
     }
     for (let index = events.length - 1; index >= 0; index -= 1) {
-      const parts = events[index]?.parts ?? [];
+      const event2 = events[index];
+      const parts = event2?.parts ?? [];
       for (let at = parts.length - 1; at >= 0; at -= 1) {
         const part = parts[at];
         if (part?.kind !== "question") continue;
-        return answered.has(part.toolUseId) ? null : part;
+        if (answered.has(part.toolUseId)) return null;
+        return askedBeforeLaunch(event2?.at ?? 0, this.registry.launchedAtOf(terminalId)) ? null : part;
       }
     }
     return null;
@@ -18099,9 +18392,9 @@ function findMarkers(content, lines, ignoredFences) {
       }
       continue;
     }
-    const open9 = FENCE_OPEN.exec(text);
-    const opening = open9?.[1];
-    if (opening !== void 0 && !ignoredFences.has(index) && !(opening[0] === "`" && (open9?.[2] ?? "").includes("`"))) {
+    const open10 = FENCE_OPEN.exec(text);
+    const opening = open10?.[1];
+    if (opening !== void 0 && !ignoredFences.has(index) && !(opening[0] === "`" && (open10?.[2] ?? "").includes("`"))) {
       fence = { line: index, char: opening[0] ?? "`", length: opening.length };
       continue;
     }
@@ -19317,8 +19610,8 @@ function buildContinuationMessage(input) {
   }
   return sanitizeForPaste(lines.join("\n"));
 }
-function transcriptReferenceFor(path76, style) {
-  return style === "at-quoted" ? fileReference(path76, "at-quoted") : `"${path76}"`;
+function transcriptReferenceFor(path78, style) {
+  return style === "at-quoted" ? fileReference(path78, "at-quoted") : `"${path78}"`;
 }
 function planTranscript(input) {
   const turns = splitTurns(input.events);
@@ -20259,7 +20552,8 @@ function defaultAppSettings() {
     vault: { enabled: false, dir: null, toolResultMaxChars: VAULT_TOOL_RESULT_DEFAULT_CHARS },
     remote: { enabled: false, port: REMOTE_DEFAULT_PORT },
     console: { shell: "auto" },
-    agents: { disabled: [] }
+    agents: { disabled: [] },
+    scheduledMessages: { enabled: false }
   };
 }
 function isAbsoluteDir(dir, platform) {
@@ -20281,6 +20575,8 @@ function parseAppSettings(value, platform, warn = () => void 0) {
   const agentsRecord = asRecord(record["agents"]);
   const disabled = agentsRecord === null ? null : asAgentIdList(agentsRecord["disabled"]);
   if (disabled !== null) settings2.agents.disabled = disabled;
+  const scheduledRecord = asRecord(record["scheduledMessages"]);
+  settings2.scheduledMessages.enabled = (scheduledRecord === null ? null : asBoolean(scheduledRecord["enabled"])) ?? false;
   const remote = asRecord(record["remote"]);
   if (remote !== null) {
     settings2.remote.enabled = asBoolean(remote["enabled"]) ?? false;
@@ -20304,7 +20600,8 @@ function frozen(settings2) {
     vault: Object.freeze({ ...settings2.vault }),
     remote: Object.freeze({ ...settings2.remote }),
     console: Object.freeze({ ...settings2.console }),
-    agents: Object.freeze({ disabled: Object.freeze([...settings2.agents.disabled]) })
+    agents: Object.freeze({ disabled: Object.freeze([...settings2.agents.disabled]) }),
+    scheduledMessages: Object.freeze({ ...settings2.scheduledMessages })
   });
 }
 var SettingsStore = class {
@@ -20360,6 +20657,23 @@ var SettingsStore = class {
     if (settings2 === null) return;
     this.current = frozen({ ...this.current, remote: settings2.remote });
   }
+  /**
+   * Relee **solo** "Mensajes programados" (hito 51), por lo mismo que el acceso
+   * remoto: apagarlo desde la otra instancia tiene que valer en esta, que es la
+   * que podria estar por mandar algo. true si cambio.
+   */
+  async reloadScheduledMessages() {
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile21(this.filePath, "utf8"));
+    } catch {
+      return false;
+    }
+    const settings2 = parseAppSettings(parsed, this.platform);
+    if (settings2 === null || settings2.scheduledMessages.enabled === this.current.scheduledMessages.enabled) return false;
+    this.current = frozen({ ...this.current, scheduledMessages: settings2.scheduledMessages });
+    return true;
+  }
   /** Una marca que cambia cuando el archivo cambia (fecha y tamano), o '' si no esta. */
   async stamp() {
     try {
@@ -20381,12 +20695,14 @@ var SettingsStore = class {
   update(patch) {
     const run2 = async () => {
       if (patch.remote === void 0) await this.reloadRemote();
+      if (patch.scheduledMessages === void 0) await this.reloadScheduledMessages();
       const next = {
         version: SETTINGS_VERSION,
         vault: { ...this.current.vault },
         remote: { ...this.current.remote },
         console: { ...this.current.console },
-        agents: { disabled: [...this.current.agents.disabled] }
+        agents: { disabled: [...this.current.agents.disabled] },
+        scheduledMessages: { ...this.current.scheduledMessages }
       };
       const vault = patch.vault ?? {};
       if (vault.enabled !== void 0) next.vault.enabled = vault.enabled;
@@ -20401,6 +20717,7 @@ var SettingsStore = class {
       }
       if (patch.console?.shell !== void 0) next.console.shell = patch.console.shell;
       if (patch.agents?.disabled !== void 0) next.agents.disabled = [...new Set(patch.agents.disabled)];
+      if (patch.scheduledMessages?.enabled !== void 0) next.scheduledMessages.enabled = patch.scheduledMessages.enabled;
       const remote = patch.remote ?? {};
       if (remote.enabled !== void 0) next.remote.enabled = remote.enabled;
       if (remote.port !== void 0) {
@@ -20960,10 +21277,353 @@ var DraftStore = class {
   }
 };
 
+// packages/server/src/scheduled-messages/store.ts
+import { mkdir as mkdir14, open as open8, readFile as readFile24, readdir as readdir14, rm as rm5, stat as stat34 } from "node:fs/promises";
+import path56 from "node:path";
+var STATE_VERSION4 = 1;
+var ID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function isScheduledMessageId(value) {
+  return ID_PATTERN2.test(value);
+}
+function sameOwner(a, b) {
+  return a.agent === b.agent && a.sessionId === b.sessionId;
+}
+function parseEntry2(value) {
+  const record = asRecord(value);
+  if (record === null) return null;
+  const id = asNonEmptyString(record["id"]);
+  const agent = asLiteral(record["agent"], AGENT_IDS);
+  const sessionId = asNonEmptyString(record["sessionId"]);
+  const text = asString(record["text"]);
+  const sendAt = asFiniteNumber(record["sendAt"]);
+  const createdAt = asFiniteNumber(record["createdAt"]);
+  if (id === null || !isScheduledMessageId(id) || agent === null || sessionId === null) return null;
+  if (text === null || text.length === 0 || text.length > MAX_SCHEDULED_TEXT_CHARS) return null;
+  if (sendAt === null || createdAt === null) return null;
+  const message = { id, agent, sessionId, text, sendAt, createdAt };
+  if (record["failure"] !== void 0) {
+    const failure = parseServerText(record["failure"]);
+    message.failure = failure ?? { key: "scheduledUncertain" };
+  }
+  return message;
+}
+function parseScheduledState(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const record = asRecord(parsed);
+  if (record === null || record["version"] !== STATE_VERSION4) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const messages = [];
+  for (const message of asArrayFiltered(record["messages"], parseEntry2) ?? []) {
+    if (seen.has(message.id)) continue;
+    seen.add(message.id);
+    messages.push(message);
+  }
+  return messages;
+}
+function copyOf2(message) {
+  return message.failure === void 0 ? { ...message } : { ...message, failure: { ...message.failure } };
+}
+var ScheduledMessageStore = class {
+  messages = [];
+  /** Fecha y tamano del archivo la ultima vez que se leyo: si cambian, lo cambio otra instancia. */
+  stamp = "";
+  /** Los cambios, en fila: cada uno relee lo que dejo el anterior. */
+  queue = Promise.resolve();
+  statePath;
+  claimsDir;
+  pid;
+  isAlive;
+  constructor(options = {}) {
+    this.statePath = options.statePath ?? scheduledMessagesPath();
+    this.claimsDir = options.claimsDir ?? scheduledClaimsDir();
+    this.pid = options.pid ?? process.pid;
+    this.isAlive = options.isAlive ?? processAlive;
+  }
+  async load() {
+    await this.readDisk();
+  }
+  /** Una copia de cada uno. */
+  list() {
+    return this.messages.map(copyOf2);
+  }
+  get(id) {
+    const found = this.messages.find((message) => message.id === id);
+    return found === void 0 ? null : copyOf2(found);
+  }
+  get size() {
+    return this.messages.length;
+  }
+  /** Relee el archivo si cambio desde la ultima vez (lo cambio otra instancia). true si cambio. */
+  async refresh() {
+    if (await this.currentStamp() === this.stamp) return false;
+    const before = JSON.stringify(this.messages);
+    await this.readDisk();
+    return JSON.stringify(this.messages) !== before;
+  }
+  add(message) {
+    return this.mutate((messages) => {
+      messages.push(copyOf2(message));
+      return void 0;
+    });
+  }
+  /** Saca uno. Devuelve el que estaba, o null. */
+  remove(id) {
+    return this.mutate((messages) => {
+      const index = messages.findIndex((message) => message.id === id);
+      if (index === -1) return null;
+      const [removed] = messages.splice(index, 1);
+      return removed === void 0 ? null : copyOf2(removed);
+    });
+  }
+  /** Cambia la hora o la falla de uno. null si ya no esta. */
+  update(id, change) {
+    return this.mutate((messages) => {
+      const message = messages.find((entry) => entry.id === id);
+      if (message === void 0) return null;
+      if (change.sendAt !== void 0) message.sendAt = change.sendAt;
+      if (change.failure === null) delete message.failure;
+      else if (change.failure !== void 0) message.failure = { ...change.failure };
+      return copyOf2(message);
+    });
+  }
+  /** Saca los de una conversacion: se cerro su pestana. Devuelve los que saco. */
+  removeOwner(owner) {
+    return this.mutate((messages) => {
+      const removed = messages.filter((message) => sameOwner(message, owner));
+      if (removed.length === 0) return removed;
+      const kept = messages.filter((message) => !sameOwner(message, owner));
+      messages.splice(0, messages.length, ...kept);
+      return removed.map(copyOf2);
+    });
+  }
+  /**
+   * La pestana cambio de conversacion (`/clear`): sus mensajes van con ella,
+   * como el borrador (§6.29). Solo pasa entre CLIs iguales: el id es de una.
+   */
+  move(from, to) {
+    if (sameOwner(from, to) || from.agent !== to.agent) return Promise.resolve(0);
+    return this.mutate((messages) => {
+      let moved = 0;
+      for (const message of messages) {
+        if (!sameOwner(message, from)) continue;
+        message.sessionId = to.sessionId;
+        moved += 1;
+      }
+      return moved;
+    });
+  }
+  /**
+   * Deja solo los de estas conversaciones: las pestanas del archivo del
+   * arranque. Lo demas es de una pestana que se cerro con una build anterior,
+   * que no los borra, y no lo va a mostrar nadie.
+   */
+  retainOnly(owners) {
+    const keep = [...owners];
+    return this.mutate((messages) => {
+      const kept = messages.filter((message) => keep.some((owner) => sameOwner(message, owner)));
+      const dropped = messages.length - kept.length;
+      if (dropped > 0) messages.splice(0, messages.length, ...kept);
+      return dropped;
+    });
+  }
+  /** Espera a que se escriba lo pendiente, para el apagado. */
+  async flush() {
+    await this.queue.catch(() => void 0);
+  }
+  // ---- quien lo esta mandando ----
+  /**
+   * Reclama un mensaje para este proceso, en `reserved`. Un reclamo de un
+   * proceso muerto en `reserved` se borra y se vuelve a intentar: ese proceso no
+   * escribio nada.
+   */
+  async claim(id) {
+    if (!isScheduledMessageId(id)) return "other";
+    await mkdir14(this.claimsDir, { recursive: true });
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        const handle = await open8(this.claimPath(id), "wx");
+        try {
+          await handle.writeFile(this.claimBody("reserved"));
+        } finally {
+          await handle.close();
+        }
+        return "mine";
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+      const existing = await this.claimOf(id);
+      if (existing === null) continue;
+      if (existing.mine) return "mine";
+      if (existing.alive) return "other";
+      if (existing.phase === "writing") return "orphan-writing";
+      await rm5(this.claimPath(id), { force: true });
+    }
+    return "other";
+  }
+  /** Pasa un reclamo propio a otro paso. */
+  async setPhase(id, phase) {
+    const existing = await this.claimOf(id);
+    if (existing === null || !existing.mine) return;
+    await writeFileAtomic(this.claimPath(id), this.claimBody(phase));
+  }
+  /** Suelta un reclamo propio. El de otra instancia no se toca. */
+  async release(id) {
+    const existing = await this.claimOf(id);
+    if (existing === null || !existing.mine) return;
+    await rm5(this.claimPath(id), { force: true });
+  }
+  /** Borra el reclamo de un proceso muerto, ya declarado. El de uno vivo no se toca. */
+  async discardOrphan(id) {
+    const existing = await this.claimOf(id);
+    if (existing === null || existing.mine || existing.alive) return;
+    await rm5(this.claimPath(id), { force: true });
+  }
+  /** El reclamo de un mensaje, o null si no hay (o no se entiende: se trata como ausente). */
+  async claimOf(id) {
+    if (!isScheduledMessageId(id)) return null;
+    let raw;
+    try {
+      raw = await readFile24(this.claimPath(id), "utf8");
+    } catch {
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return { pid: -1, phase: "reserved", mine: false, alive: true };
+    }
+    const record = asRecord(parsed);
+    const pid = record === null ? null : asFiniteNumber(record["pid"]);
+    const phase = record === null ? null : asLiteral(record["phase"], ["reserved", "writing"]);
+    if (pid === null || phase === null) return { pid: -1, phase: "reserved", mine: false, alive: true };
+    const mine = pid === this.pid;
+    return { pid, phase, mine, alive: mine || this.isAlive(pid) };
+  }
+  /** Los ids que tienen reclamo en disco. Para limpiar los de mensajes que ya no estan. */
+  async claimedIds() {
+    let names;
+    try {
+      names = await readdir14(this.claimsDir);
+    } catch {
+      return [];
+    }
+    return names.filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -".json".length)).filter(isScheduledMessageId);
+  }
+  /** Suelta los reclamos propios en `reserved`: la instancia se apaga sin haber escrito nada. */
+  async releaseReserved() {
+    for (const id of await this.claimedIds()) {
+      const existing = await this.claimOf(id);
+      if (existing !== null && existing.mine && existing.phase === "reserved") await rm5(this.claimPath(id), { force: true });
+    }
+  }
+  // ---- disco ----
+  claimPath(id) {
+    return path56.join(this.claimsDir, `${id}.json`);
+  }
+  claimBody(phase) {
+    return `${JSON.stringify({ pid: this.pid, phase, at: Date.now() })}
+`;
+  }
+  async currentStamp() {
+    try {
+      const info = await stat34(this.statePath);
+      return `${info.mtimeMs}:${info.size}`;
+    } catch {
+      return "";
+    }
+  }
+  async readDisk() {
+    const stamp2 = await this.currentStamp();
+    let messages = [];
+    try {
+      messages = parseScheduledState(await readFile24(this.statePath, "utf8"));
+    } catch {
+    }
+    this.messages = messages;
+    this.stamp = stamp2;
+    return messages;
+  }
+  /** Relee, aplica el cambio y escribe. Lo que devuelve `change` es lo que devuelve el cambio. */
+  mutate(change) {
+    const run2 = async () => {
+      const messages = await this.readDisk();
+      const before = JSON.stringify(messages);
+      const result2 = change(messages);
+      if (JSON.stringify(messages) === before) return result2;
+      await mkdir14(path56.dirname(this.statePath), { recursive: true });
+      await writeFileAtomic(this.statePath, `${JSON.stringify({ version: STATE_VERSION4, messages }, null, 2)}
+`);
+      this.messages = messages;
+      this.stamp = await this.currentStamp();
+      return result2;
+    };
+    const result = this.queue.then(run2, run2);
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+};
+
+// packages/server/src/scheduled-messages/instances.ts
+import { mkdir as mkdir15, readdir as readdir15, rm as rm6, writeFile as writeFile9 } from "node:fs/promises";
+import path57 from "node:path";
+var FILE_PATTERN = /^(\d+)\.json$/;
+var RunningInstances = class {
+  constructor(dir = runningInstancesDir(), pid = process.pid, isAlive = processAlive) {
+    this.dir = dir;
+    this.pid = pid;
+    this.isAlive = isAlive;
+  }
+  dir;
+  pid;
+  isAlive;
+  fileOf(pid) {
+    return path57.join(this.dir, `${pid}.json`);
+  }
+  /** Anota esta instancia. Nunca lanza: sin el archivo, la otra no espera, como antes del hito. */
+  async register() {
+    try {
+      await mkdir15(this.dir, { recursive: true });
+      await writeFile9(this.fileOf(this.pid), `${JSON.stringify({ pid: this.pid, startedAt: Date.now() })}
+`);
+    } catch (error) {
+      console.warn("[scheduled] couldn't note this instance:", error);
+    }
+  }
+  /** La saca, al apagarse. Nunca lanza. */
+  async unregister() {
+    await rm6(this.fileOf(this.pid), { force: true }).catch(() => void 0);
+  }
+  /** true si otra instancia esta corriendo. Borra los archivos de las que ya no estan. */
+  async othersRunning() {
+    let names;
+    try {
+      names = await readdir15(this.dir);
+    } catch {
+      return false;
+    }
+    let found = false;
+    for (const name of names) {
+      const match = FILE_PATTERN.exec(name);
+      if (match === null) continue;
+      const pid = Number(match[1]);
+      if (pid === this.pid) continue;
+      if (this.isAlive(pid)) found = true;
+      else await rm6(this.fileOf(pid), { force: true }).catch(() => void 0);
+    }
+    return found;
+  }
+};
+
 // packages/server/src/shell-locator.ts
 import { access as access2 } from "node:fs/promises";
 import { constants as fsConstants2 } from "node:fs";
-import path56 from "node:path";
+import path58 from "node:path";
 async function isExecutable(candidate) {
   try {
     await access2(candidate, process.platform === "win32" ? fsConstants2.R_OK : fsConstants2.X_OK);
@@ -20981,21 +21641,21 @@ var SYSTEM_PROBE = {
 function windowsPowerShellPath(env) {
   const systemRoot = env["SystemRoot"] ?? env["windir"];
   if (systemRoot === void 0 || systemRoot.length === 0) return null;
-  return path56.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  return path58.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
 }
 function gitBashCandidates(gitPath, env) {
   const candidates = [];
   if (gitPath !== null) {
-    let dir = path56.win32.dirname(gitPath);
+    let dir = path58.win32.dirname(gitPath);
     for (let level = 0; level < 3; level++) {
-      candidates.push(path56.win32.join(dir, "bin", "bash.exe"));
-      const parent = path56.win32.dirname(dir);
+      candidates.push(path58.win32.join(dir, "bin", "bash.exe"));
+      const parent = path58.win32.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
   }
-  for (const base of [env["ProgramFiles"], env["LOCALAPPDATA"] === void 0 ? void 0 : path56.win32.join(env["LOCALAPPDATA"], "Programs")]) {
-    if (base !== void 0 && base.length > 0) candidates.push(path56.win32.join(base, "Git", "bin", "bash.exe"));
+  for (const base of [env["ProgramFiles"], env["LOCALAPPDATA"] === void 0 ? void 0 : path58.win32.join(env["LOCALAPPDATA"], "Programs")]) {
+    if (base !== void 0 && base.length > 0) candidates.push(path58.win32.join(base, "Git", "bin", "bash.exe"));
   }
   const systemRoot = (env["SystemRoot"] ?? env["windir"] ?? "").toLowerCase();
   return [...new Set(candidates)].filter((candidate) => systemRoot.length === 0 || !candidate.toLowerCase().startsWith(systemRoot));
@@ -21026,7 +21686,7 @@ async function locatePosixShells(probe) {
   const found = [];
   const preferred = probe.env["SHELL"];
   if (preferred !== void 0 && preferred.length > 0 && await probe.isExecutable(preferred)) {
-    const name = path56.posix.basename(preferred);
+    const name = path58.posix.basename(preferred);
     found.push({ id: "login", label: name, location: { file: preferred, args: [], name } });
   }
   for (const [id, file] of [["bash", "/bin/bash"], ["sh", "/bin/sh"], ["zsh", "/bin/zsh"]]) {
@@ -21075,9 +21735,18 @@ var AppSettingsService = class extends EventEmitter5 {
       consoleShells: this.options.shells.map(({ id, label }) => ({ id, label })),
       shellName: this.currentShell()?.name ?? null,
       disabledAgents: [...settings2.agents.disabled],
-      disabledAtStart: [...this.disabledAtStart]
+      disabledAtStart: [...this.disabledAtStart],
+      scheduledMessages: settings2.scheduledMessages.enabled
     };
   }
+  /** "Mensajes programados" encendido, segun lo ultimo leido (hito 51). */
+  scheduledMessagesEnabled() {
+    return this.options.settings.get().scheduledMessages.enabled;
+  }
+  /** Lo relee del disco; si la otra instancia lo cambio, avisa como cualquier cambio. */
+  async refreshScheduledMessages() {
+    if (await this.options.settings.reloadScheduledMessages()) this.emit("status", this.status());
+  }
   /** Guarda el cambio, avisa al registro si cambio la consola, y emite `status`. */
   async update(change) {
     if (change.consoleShell !== void 0 && !this.offered(change.consoleShell)) {
@@ -21086,7 +21755,8 @@ var AppSettingsService = class extends EventEmitter5 {
     const before = this.currentShell();
     await this.options.settings.update({
       ...change.consoleShell !== void 0 ? { console: { shell: change.consoleShell } } : {},
-      ...change.disabledAgents !== void 0 ? { agents: { disabled: change.disabledAgents } } : {}
+      ...change.disabledAgents !== void 0 ? { agents: { disabled: change.disabledAgents } } : {},
+      ...change.scheduledMessages !== void 0 ? { scheduledMessages: { enabled: change.scheduledMessages } } : {}
     });
     const after = this.currentShell();
     if (after !== before) this.options.onShellChange(after);
@@ -21098,13 +21768,13 @@ var AppSettingsService = class extends EventEmitter5 {
 };
 
 // packages/server/src/session-watcher.ts
-import { stat as stat34 } from "node:fs/promises";
+import { stat as stat35 } from "node:fs/promises";
 import chokidar3 from "chokidar";
 var INDEX_DEBOUNCE_MS = 750;
 var ROOT_PROBE_MS = 5e3;
 async function isDirectory3(target) {
   try {
-    return (await stat34(target)).isDirectory();
+    return (await stat35(target)).isDirectory();
   } catch {
     return false;
   }
@@ -21207,7 +21877,7 @@ function watchSessions(index, hub, agents, options = {}) {
 // packages/server/src/terminal-registry.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { EventEmitter as EventEmitter6 } from "node:events";
-import { stat as stat35 } from "node:fs/promises";
+import { stat as stat36 } from "node:fs/promises";
 
 // packages/server/src/launch-hook-slot.ts
 var LaunchHookSlot = class {
@@ -21508,9 +22178,9 @@ async function resolveLaunchPlan(launch) {
 }
 
 // packages/server/src/workspace-store.ts
-import { mkdir as mkdir14, readFile as readFile24, writeFile as writeFile9 } from "node:fs/promises";
-import path57 from "node:path";
-var STATE_VERSION4 = 1;
+import { mkdir as mkdir16, readFile as readFile25, writeFile as writeFile10 } from "node:fs/promises";
+import path59 from "node:path";
+var STATE_VERSION5 = 1;
 var WRITE_DEBOUNCE_MS4 = 400;
 var LEGACY_TAB_AGENT = "claude-code";
 function placeByPosition(base, placed) {
@@ -21574,7 +22244,7 @@ function parseState4(raw) {
   try {
     const parsed = JSON.parse(raw);
     if (!isRecord(parsed)) return null;
-    if (parsed["version"] !== STATE_VERSION4) return null;
+    if (parsed["version"] !== STATE_VERSION5) return null;
     const rawTabs = parsed["tabs"];
     if (!Array.isArray(rawTabs)) return null;
     const base = [];
@@ -21612,7 +22282,7 @@ function serializeState(state) {
       otherTabs.push({ ...entry.tab, position });
     }
   }
-  return otherTabs.length === 0 ? { version: STATE_VERSION4, tabs } : { version: STATE_VERSION4, tabs, otherTabs };
+  return otherTabs.length === 0 ? { version: STATE_VERSION5, tabs } : { version: STATE_VERSION5, tabs, otherTabs };
 }
 var EMPTY_STATE = () => ({ tabs: [], foreignTabs: [] });
 function persistableTabs(descriptors) {
@@ -21636,7 +22306,7 @@ var WorkspaceStore = class {
   pending = null;
   async load() {
     try {
-      const raw = await readFile24(workspaceStatePath(), "utf8");
+      const raw = await readFile25(workspaceStatePath(), "utf8");
       return parseState4(raw) ?? EMPTY_STATE();
     } catch {
       return EMPTY_STATE();
@@ -21666,10 +22336,10 @@ var WorkspaceStore = class {
   }
   async writeNow(state) {
     try {
-      await mkdir14(appConfigDir(), { recursive: true });
+      await mkdir16(appConfigDir(), { recursive: true });
       const target = workspaceStatePath();
-      const temporary = path57.join(path57.dirname(target), `workspace.${process.pid}.tmp`);
-      await writeFile9(temporary, JSON.stringify(serializeState(state), null, 2), "utf8");
+      const temporary = path59.join(path59.dirname(target), `workspace.${process.pid}.tmp`);
+      await writeFile10(temporary, JSON.stringify(serializeState(state), null, 2), "utf8");
       const { rename: rename8 } = await import("node:fs/promises");
       await rename8(temporary, target);
     } catch (error) {
@@ -21937,7 +22607,7 @@ var TerminalRegistry = class extends EventEmitter6 {
   async assertDirectory(cwd) {
     let info;
     try {
-      info = await stat35(cwd);
+      info = await stat36(cwd);
     } catch {
       throw new TerminalOpenError("invalid-cwd", serverText("cwdMissing", { cwd }));
     }
@@ -22395,26 +23065,26 @@ import { WebSocketServer } from "ws";
 
 // packages/server/src/directory-picker.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { lstat, mkdir as mkdir15, readdir as readdir14, stat as stat36 } from "node:fs/promises";
+import { lstat, mkdir as mkdir17, readdir as readdir16, stat as stat37 } from "node:fs/promises";
 import { homedir as homedir14 } from "node:os";
-import path58 from "node:path";
+import path60 from "node:path";
 var MAX_ENTRIES = 500;
 var MAX_PICKERS = 8;
 var SKIPPED = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "bin", "obj", "$RECYCLE.BIN"]);
 var DirectoryPickerError = class extends ServerTextError {
 };
 function isInsideProtected(target, dirs) {
-  const resolved = path58.resolve(target);
+  const resolved = path60.resolve(target);
   return dirs.some((dir) => {
-    const protectedDir = path58.resolve(dir);
-    return resolved === protectedDir || resolved.startsWith(protectedDir + path58.sep);
+    const protectedDir = path60.resolve(dir);
+    return resolved === protectedDir || resolved.startsWith(protectedDir + path60.sep);
   });
 }
 async function isListedDirectory(parent, entry, readLink = lstat) {
   if (entry.isDirectory()) return true;
   if (!entry.isSymbolicLink()) return false;
   try {
-    const info = await readLink(path58.join(parent, entry.name));
+    const info = await readLink(path60.join(parent, entry.name));
     return info.isDirectory() && !info.isSymbolicLink();
   } catch {
     return false;
@@ -22429,7 +23099,7 @@ async function listRoots() {
       letters.map(async (letter) => {
         const drive = `${letter}:\\`;
         try {
-          await stat36(drive);
+          await stat37(drive);
           return drive;
         } catch {
           return null;
@@ -22481,14 +23151,14 @@ var DirectoryPickers = class {
   async enter(pickerId, name) {
     const picker = this.require(pickerId);
     if (name === "..") {
-      const parent = path58.dirname(picker.current);
+      const parent = path60.dirname(picker.current);
       if (parent !== picker.current) picker.current = parent;
       return this.listing(picker);
     }
     if (!picker.entries.has(name)) {
       throw new DirectoryPickerError(serverText("pickerNotListed"));
     }
-    const target = path58.join(picker.current, name);
+    const target = path60.join(picker.current, name);
     if (isInsideProtected(target, this.protectedDirs)) {
       throw new DirectoryPickerError(serverText("pickerCliFolder"));
     }
@@ -22528,12 +23198,12 @@ var DirectoryPickers = class {
         throw new DirectoryPickerError(serverText("pickerNameChars"));
       }
     }
-    const target = path58.join(picker.current, clean);
+    const target = path60.join(picker.current, clean);
     if (isInsideProtected(target, this.protectedDirs)) {
       throw new DirectoryPickerError(serverText("pickerNoProjectsHere"));
     }
     try {
-      await mkdir15(target);
+      await mkdir17(target);
     } catch (error) {
       const code = error.code;
       throw new DirectoryPickerError(
@@ -22564,9 +23234,9 @@ var DirectoryPickers = class {
     let names = [];
     let truncated = false;
     try {
-      const found = await readdir14(picker.current, { withFileTypes: true });
+      const found = await readdir16(picker.current, { withFileTypes: true });
       const listed = await Promise.all(found.map((entry) => isListedDirectory(picker.current, entry)));
-      const dirs = found.filter((_, index) => listed[index] === true).map((entry) => entry.name).filter((name) => !SKIPPED.has(name)).filter((name) => !isInsideProtected(path58.join(picker.current, name), this.protectedDirs)).sort((a, b) => a.localeCompare(b));
+      const dirs = found.filter((_, index) => listed[index] === true).map((entry) => entry.name).filter((name) => !SKIPPED.has(name)).filter((name) => !isInsideProtected(path60.join(picker.current, name), this.protectedDirs)).sort((a, b) => a.localeCompare(b));
       truncated = dirs.length > MAX_ENTRIES;
       names = dirs.slice(0, MAX_ENTRIES);
     } catch {
@@ -22577,7 +23247,7 @@ var DirectoryPickers = class {
       path: picker.current,
       entries: names,
       roots,
-      canGoUp: path58.dirname(picker.current) !== picker.current,
+      canGoUp: path60.dirname(picker.current) !== picker.current,
       truncated
     };
   }
@@ -22637,7 +23307,7 @@ var PlanLimitsBoard = class {
 
 // packages/server/src/cli-folders.ts
 import { realpath as realpath4 } from "node:fs/promises";
-import path59 from "node:path";
+import path61 from "node:path";
 function isSameOrInside(child, parent, platform) {
   const childKey = normalizeCwdKey(child, platform);
   const parentKey = normalizeCwdKey(parent, platform);
@@ -22649,7 +23319,7 @@ function isSameOrInside(child, parent, platform) {
 async function cliFolders(dirs, platform = process.platform) {
   const known = [];
   for (const dir of dirs) {
-    known.push(path59.resolve(dir));
+    known.push(path61.resolve(dir));
     try {
       known.push(await realpath4(dir));
     } catch {
@@ -22672,8 +23342,8 @@ async function cliFolders(dirs, platform = process.platform) {
 
 // packages/server/src/file-browser.ts
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile25, readdir as readdir15, realpath as realpath5, stat as stat37 } from "node:fs/promises";
-import path60 from "node:path";
+import { readFile as readFile26, readdir as readdir17, realpath as realpath5, stat as stat38 } from "node:fs/promises";
+import path62 from "node:path";
 var MAX_ENTRIES2 = 1e3;
 var SEARCH_MAX_RESULTS = 200;
 var SEARCH_MAX_DIRECTORIES = 4e3;
@@ -22736,7 +23406,7 @@ function languageFor(fileName) {
   const lower = fileName.toLowerCase();
   const byName = LANGUAGE_BY_NAME[lower];
   if (byName !== void 0) return byName;
-  const extension = path60.extname(lower);
+  const extension = path62.extname(lower);
   return LANGUAGE_BY_EXTENSION[extension] ?? null;
 }
 function looksBinary2(buffer) {
@@ -22773,7 +23443,7 @@ async function listDirectory(cwd, relativePath, folders, options = {}) {
     let sizeBytes = 0;
     let modifiedAt = 0;
     try {
-      const info = await stat37(path60.join(absolute, candidate.name));
+      const info = await stat38(path62.join(absolute, candidate.name));
       sizeBytes = candidate.isDirectory ? 0 : info.size;
       modifiedAt = info.mtimeMs;
     } catch {
@@ -22799,7 +23469,7 @@ async function scanLevel(absolute, repoRoot2, folders) {
   return level;
 }
 async function readLevel(absolute, folders) {
-  const dirents = await readdir15(absolute, { withFileTypes: true });
+  const dirents = await readdir17(absolute, { withFileTypes: true });
   const realLevel = await realpath5(absolute);
   let skipped = 0;
   const candidates = [];
@@ -22807,8 +23477,8 @@ async function readLevel(absolute, folders) {
     const always = ALWAYS_SKIP.has(dirent.name.toLowerCase());
     if (dirent.isSymbolicLink()) {
       try {
-        const linked = path60.join(absolute, dirent.name);
-        const target = await stat37(linked);
+        const linked = path62.join(absolute, dirent.name);
+        const target = await stat38(linked);
         if (folders.holds(await realpath5(linked))) continue;
         candidates.push({
           name: dirent.name,
@@ -22824,7 +23494,7 @@ async function readLevel(absolute, folders) {
       skipped += 1;
       continue;
     }
-    if (folders.holds(path60.join(realLevel, dirent.name))) continue;
+    if (folders.holds(path62.join(realLevel, dirent.name))) continue;
     candidates.push({
       name: dirent.name,
       isDirectory: dirent.isDirectory(),
@@ -22839,7 +23509,7 @@ async function markIgnored(repoRoot2, levels) {
   for (const level of levels) {
     for (const entry of level.entries) {
       if (entry.hidden !== null) continue;
-      keys.set(entry, toPosixPath(path60.relative(repoRoot2, path60.join(level.absolute, entry.name))));
+      keys.set(entry, toPosixPath(path62.relative(repoRoot2, path62.join(level.absolute, entry.name))));
     }
   }
   if (keys.size === 0) return;
@@ -22901,7 +23571,7 @@ async function searchFiles(cwd, query, folders, options = {}) {
         let sizeBytes = 0;
         let modifiedAt = 0;
         try {
-          const info = await stat37(path60.join(level.absolute, candidate.name));
+          const info = await stat38(path62.join(level.absolute, candidate.name));
           sizeBytes = candidate.isDirectory ? 0 : info.size;
           modifiedAt = info.mtimeMs;
         } catch {
@@ -22939,7 +23609,7 @@ async function existingPaths(cwd, relativePaths, folders) {
   for (const relativePath of relativePaths) {
     try {
       const absolute = await resolveForFiles(cwd, relativePath, folders);
-      const info = await stat37(absolute);
+      const info = await stat38(absolute);
       if (info.isFile()) files.push(relativePath);
       else if (info.isDirectory()) directories.push(relativePath);
     } catch {
@@ -22955,12 +23625,12 @@ function isEditableText(content, text) {
 }
 async function readPreview(cwd, relativePath, folders) {
   const absolute = await resolveForFiles(cwd, relativePath, folders);
-  const info = await stat37(absolute);
+  const info = await stat38(absolute);
   if (info.isDirectory()) {
     throw new Error("It's a directory, not a file.");
   }
-  const content = await readFile25(absolute);
-  const fileName = path60.basename(absolute);
+  const content = await readFile26(absolute);
+  const fileName = path62.basename(absolute);
   if (looksBinary2(content)) {
     return {
       path: relativePath,
@@ -22986,7 +23656,7 @@ async function readPreview(cwd, relativePath, folders) {
 
 // packages/server/src/file-write.ts
 import { constants } from "node:fs";
-import { access as access3, readFile as readFile26, realpath as realpath6, stat as stat38 } from "node:fs/promises";
+import { access as access3, readFile as readFile27, realpath as realpath6, stat as stat39 } from "node:fs/promises";
 var FileWriteError = class extends ServerTextError {
 };
 function withLineEndings(text, original) {
@@ -23011,9 +23681,9 @@ async function saveProjectFile(cwd, relativePath, text, baseHash, folders) {
   }
   if (await folders.contains(absolute)) throw new InvalidPathError(serverText("cliFolderClosed"));
   const target = await realpath6(absolute);
-  const info = await stat38(target);
+  const info = await stat39(target);
   if (!info.isFile()) throw new FileWriteError(serverText("fileSaveFailed"));
-  const current = await readFile26(target);
+  const current = await readFile27(target);
   if (contentHash(current) !== baseHash) {
     return { outcome: "changed", preview: await readPreview(cwd, relativePath, folders).catch(() => null) };
   }
@@ -23323,12 +23993,115 @@ function prefillReasonFor(outcome) {
   }
 }
 
-// packages/server/src/vault/read-session.ts
-var MAX_POLLS = 5;
-var MAX_TOTAL_POLLS = 20;
-var UnsupportedHistoryError = class extends Error {
-  constructor(label) {
-    super(`${label}: the source doesn't declare that its follower respects the local copy's limits (wholeRead)`);
+// packages/server/src/submit-message.ts
+function prepareSubmit(deps, terminalId) {
+  const submitting = deps.adapterOf(terminalId);
+  const isBlind = () => submitting !== null && deps.conversations.isBlindToApprovals(terminalId, submitting);
+  const guardsPending = submitting?.capabilities.permissionCycle?.approvesPendingOnCycle === true;
+  const blocksWhileWaiting = submitting?.capabilities.waitingBlocksSubmit === true;
+  if (submitting !== null) {
+    const launchedAt = deps.launchedAtOf(terminalId);
+    const blind = isBlind();
+    const refusal = submitRefusal({
+      label: submitting.label,
+      approvesPendingOnCycle: guardsPending,
+      waitingFor: deps.conversations.getWaitingFor(terminalId),
+      waitingBlocksSubmit: blocksWhileWaiting,
+      activity: deps.activityOf(terminalId),
+      blind,
+      openToolCall: blind && launchedAt !== null && deps.conversations.hasOpenToolCall(terminalId, launchedAt)
+    });
+    if (refusal !== null) return { refusal };
+  }
+  const approvalGuard = submitting !== null && (guardsPending || blocksWhileWaiting || isBlind()) ? async () => {
+    const current = deps.launchedAtOf(terminalId);
+    if (current === null) return true;
+    if (blocksWhileWaiting && deps.activityOf(terminalId) === "waiting") return false;
+    if (isBlind() && await deps.conversations.checkOpenToolCall(terminalId, current)) return false;
+    return !guardsPending || await deps.conversations.checkWaitingFor(terminalId) === null;
+  } : void 0;
+  const input = deps.inputOf(terminalId);
+  const startupDialog = input.startupDialog;
+  const firstMessage = startupDialog !== void 0 && (deps.sessionIdOf(terminalId) ?? "") === "";
+  let startupChecked = false;
+  let stoppedByDialog = false;
+  const pieceGuard = firstMessage || approvalGuard !== void 0 ? async () => {
+    if (firstMessage && startupDialog !== void 0 && !startupChecked) {
+      startupChecked = true;
+      const screen = deps.watchScreen(terminalId);
+      if (screen !== null) {
+        try {
+          stoppedByDialog = screenShowsDialog(await screen.lines(), startupDialog);
+        } finally {
+          screen.dispose();
+        }
+        if (stoppedByDialog) return false;
+      }
+    }
+    return approvalGuard === void 0 ? true : approvalGuard();
+  } : void 0;
+  return {
+    terminalId,
+    input,
+    label: submitting?.label ?? null,
+    blocksWhileWaiting,
+    pieceGuard,
+    stoppedByDialog: () => stoppedByDialog,
+    promptQueueSource: submitting?.promptQueue?.source ?? null,
+    hasQueuedSubmits: submitting?.queuedSubmits !== void 0
+  };
+}
+async function runSubmit(deps, plan, request) {
+  const { terminalId, input } = plan;
+  let result = { kind: "dropped" };
+  await deps.enqueue(
+    terminalId,
+    async (lane) => {
+      result = { kind: "failed" };
+      const content = await request.prepare(input);
+      if (content === null) {
+        result = { kind: "prepare-failed" };
+        return;
+      }
+      const { fullText, imagePaths } = content;
+      const pieces = buildSubmissionWrites(fullText, imagePaths, input, { send: request.send });
+      if (pieces === null) {
+        result = { kind: "nothing" };
+        return;
+      }
+      deps.noteSubmitted(terminalId, fullText);
+      const startAfterMs = submitStartDelayMs(deps.launchedAtOf(terminalId), deps.now(), input.readyAfterLaunchMs ?? 0);
+      const outcome = await lane.writePieces(pieces, input.pieceGapMs, request.write, plan.pieceGuard, { startAfterMs });
+      request.onWritten?.(outcome);
+      if (outcome === "written" && request.send && plan.promptQueueSource === "app" && deps.activityOf(terminalId) === "busy" && !request.text.trimStart().startsWith("/")) {
+        deps.conversations.noteQueued(terminalId, { text: request.text, images: request.imageCount, at: deps.now() });
+      }
+      if (outcome === "written" && request.send && plan.hasQueuedSubmits) {
+        deps.queuedSubmits.note(terminalId, submissionPayload(fullText, imagePaths, input.imageReference) ?? fullText, deps.now(), fullText);
+      }
+      if (outcome === "written") result = { kind: "written" };
+      else if (outcome === "refused") result = { kind: "refused" };
+      else if (outcome === "interrupted") result = { kind: "interrupted" };
+      else {
+        result = {
+          kind: "blocked",
+          byDialog: plan.stoppedByDialog(),
+          waitingNow: plan.blocksWhileWaiting && deps.activityOf(terminalId) === "waiting"
+        };
+      }
+    },
+    // Descartado por una interrupcion antes de empezar: queda `dropped`.
+    { onDropped: () => void 0 }
+  );
+  return result;
+}
+
+// packages/server/src/vault/read-session.ts
+var MAX_POLLS = 5;
+var MAX_TOTAL_POLLS = 20;
+var UnsupportedHistoryError = class extends Error {
+  constructor(label) {
+    super(`${label}: the source doesn't declare that its follower respects the local copy's limits (wholeRead)`);
     this.name = "UnsupportedHistoryError";
   }
 };
@@ -23685,14 +24458,14 @@ var TerminalWriteQueue = class {
 };
 
 // packages/server/src/vault/service.ts
-import { mkdir as mkdir18, stat as stat42 } from "node:fs/promises";
+import { mkdir as mkdir20, stat as stat43 } from "node:fs/promises";
 import { homedir as homedir15 } from "node:os";
-import path64 from "node:path";
+import path66 from "node:path";
 
 // packages/server/src/vault/move.ts
 import { constants as constants2 } from "node:fs";
-import { copyFile as copyFile2, lstat as lstat2, mkdir as mkdir16, readdir as readdir16, rm as rm5, stat as stat39, utimes, writeFile as writeFile10 } from "node:fs/promises";
-import path61 from "node:path";
+import { copyFile as copyFile2, lstat as lstat2, mkdir as mkdir18, readdir as readdir18, rm as rm7, stat as stat40, utimes, writeFile as writeFile11 } from "node:fs/promises";
+import path63 from "node:path";
 var MOVED_ENTRIES = ["vault.json", "sessions", "memory"];
 var OWN_TEMP_FILE = /\.\d+\.[0-9a-f]{12}\.tmp$/;
 async function copyTree(source, target, result) {
@@ -23703,14 +24476,14 @@ async function copyTree(source, target, result) {
     return;
   }
   if (info.isDirectory()) {
-    await mkdir16(target, { recursive: true });
-    for (const name of await readdir16(source)) {
-      await copyTree(path61.join(source, name), path61.join(target, name), result);
+    await mkdir18(target, { recursive: true });
+    for (const name of await readdir18(source)) {
+      await copyTree(path63.join(source, name), path63.join(target, name), result);
     }
     return;
   }
   if (!info.isFile() || OWN_TEMP_FILE.test(source)) return;
-  await mkdir16(path61.dirname(target), { recursive: true });
+  await mkdir18(path63.dirname(target), { recursive: true });
   try {
     await copyFile2(source, target, constants2.COPYFILE_EXCL);
   } catch (error) {
@@ -23725,9 +24498,9 @@ async function copyTree(source, target, result) {
 }
 async function moveVault(from, to) {
   const result = { copied: 0, skipped: 0 };
-  await mkdir16(to, { recursive: true });
+  await mkdir18(to, { recursive: true });
   for (const entry of MOVED_ENTRIES) {
-    await copyTree(path61.join(from, entry), path61.join(to, entry), result);
+    await copyTree(path63.join(from, entry), path63.join(to, entry), result);
   }
   return result;
 }
@@ -23759,16 +24532,16 @@ function checkVaultTarget(current, target, options) {
   return { kind: "ok" };
 }
 async function canWriteInto(dir) {
-  const probe = temporaryPathFor(path61.join(dir, ".escritura"));
+  const probe = temporaryPathFor(path63.join(dir, ".escritura"));
   try {
-    await mkdir16(dir, { recursive: true });
-    if (!(await stat39(dir)).isDirectory()) return false;
-    await writeFile10(probe, "");
+    await mkdir18(dir, { recursive: true });
+    if (!(await stat40(dir)).isDirectory()) return false;
+    await writeFile11(probe, "");
     return true;
   } catch {
     return false;
   } finally {
-    await rm5(probe, { force: true }).catch(() => void 0);
+    await rm7(probe, { force: true }).catch(() => void 0);
   }
 }
 
@@ -23865,12 +24638,12 @@ function serializeSession(input) {
 }
 
 // packages/server/src/vault/writer.ts
-import { readdir as readdir18, rm as rm6, stat as stat41 } from "node:fs/promises";
-import path63 from "node:path";
+import { readdir as readdir20, rm as rm8, stat as stat42 } from "node:fs/promises";
+import path65 from "node:path";
 
 // packages/server/src/vault/memory-copy.ts
-import { mkdir as mkdir17, readdir as readdir17, readFile as readFile27, stat as stat40, utimes as utimes2 } from "node:fs/promises";
-import path62 from "node:path";
+import { mkdir as mkdir19, readdir as readdir19, readFile as readFile28, stat as stat41, utimes as utimes2 } from "node:fs/promises";
+import path64 from "node:path";
 var MEMORY_FILE_MAX_BYTES = 1024 * 1024;
 var MEMORY_MAX_FILES = 500;
 var MEMORY_SOURCE_FILE = "source.json";
@@ -23885,7 +24658,7 @@ async function listMemoryNotes(cwd) {
   }
   let entries;
   try {
-    entries = await readdir17(folder, { withFileTypes: true });
+    entries = await readdir19(folder, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -23895,7 +24668,7 @@ async function listMemoryNotes(cwd) {
     let absolute;
     try {
       absolute = await resolveInside(cwd, `${MEMORY_DIR}/${name}`, { mustExist: true });
-      const info = await stat40(absolute);
+      const info = await stat41(absolute);
       if (!info.isFile() || info.size > MEMORY_FILE_MAX_BYTES) continue;
       notes.push({ name, absolute, size: info.size, mtimeMs: info.mtimeMs });
     } catch {
@@ -23909,7 +24682,7 @@ async function measureProjectMemory(cwd) {
 }
 async function isUpToDate(target, note) {
   try {
-    const info = await stat40(target);
+    const info = await stat41(target);
     return info.isFile() && info.size === note.size && Math.abs(info.mtimeMs - note.mtimeMs) < SAME_MTIME_MS;
   } catch {
     return false;
@@ -23917,7 +24690,7 @@ async function isUpToDate(target, note) {
 }
 async function exists3(file) {
   try {
-    await stat40(file);
+    await stat41(file);
     return true;
   } catch {
     return false;
@@ -23933,14 +24706,14 @@ async function copyProjectMemory(dir, cwd, platform, deps = DEFAULT_WRITE_DEPS)
     if (prepared) return;
     prepared = true;
     await ensureVaultMarker(dir, deps);
-    await mkdir17(target, { recursive: true });
+    await mkdir19(target, { recursive: true });
   };
   for (const note of notes) {
-    const destination = path62.join(target, note.name);
+    const destination = path64.join(target, note.name);
     if (await isUpToDate(destination, note)) continue;
     let content;
     try {
-      content = await readFile27(note.absolute);
+      content = await readFile28(note.absolute);
     } catch {
       continue;
     }
@@ -23952,7 +24725,7 @@ async function copyProjectMemory(dir, cwd, platform, deps = DEFAULT_WRITE_DEPS)
     result.files += 1;
     result.bytes += content.length;
   }
-  const source = path62.join(target, MEMORY_SOURCE_FILE);
+  const source = path64.join(target, MEMORY_SOURCE_FILE);
   if (result.files > 0 || !await exists3(source)) {
     await prepare();
     await writeFileAtomic(source, `${JSON.stringify({ cwd, copiedAt: deps.now() })}
@@ -24446,7 +25219,7 @@ var VaultWriter = class {
   }
   async assetOnDisk(dir, agent, sessionId, asset, bytes) {
     try {
-      const info = await stat41(assetFile(dir, agent, sessionId, asset));
+      const info = await stat42(assetFile(dir, agent, sessionId, asset));
       return info.isFile() && info.size === bytes;
     } catch {
       return false;
@@ -24546,30 +25319,30 @@ var VaultWriter = class {
     const folders = [dir];
     const subfolders = async (parent) => {
       try {
-        return (await readdir18(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path63.join(parent, entry.name));
+        return (await readdir20(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path65.join(parent, entry.name));
       } catch {
         return [];
       }
     };
     for (const agentDir of await subfolders(sessionsRoot2(dir))) {
-      if (!SESSION_AGENT_IDS.includes(path63.basename(agentDir))) continue;
+      if (!SESSION_AGENT_IDS.includes(path65.basename(agentDir))) continue;
       folders.push(agentDir);
       folders.push(...(await subfolders(agentDir)).filter((folder) => folder.endsWith(".assets")));
     }
-    folders.push(...await subfolders(path63.join(dir, "memory")));
+    folders.push(...await subfolders(path65.join(dir, "memory")));
     for (const folder of folders) {
       let names;
       try {
-        names = await readdir18(folder);
+        names = await readdir20(folder);
       } catch {
         continue;
       }
       for (const name of names) {
         if (!OWN_TEMP_FILE2.test(name)) continue;
-        const file = path63.join(folder, name);
+        const file = path65.join(folder, name);
         try {
-          const info = await stat41(file);
-          if (info.isFile() && now - info.mtimeMs > TEMP_MAX_AGE_MS) await rm6(file, { force: true });
+          const info = await stat42(file);
+          if (info.isFile() && now - info.mtimeMs > TEMP_MAX_AGE_MS) await rm8(file, { force: true });
         } catch {
         }
       }
@@ -24756,14 +25529,14 @@ var VaultService = class {
   async setDir(target) {
     const { platform, agents, settings: settings2, catalog } = this.options;
     const current = this.dir();
-    const protectedDirs = [...agents.protectedDirs(), path64.join(this.options.homeDir ?? homedir15(), ".gemini")];
+    const protectedDirs = [...agents.protectedDirs(), path66.join(this.options.homeDir ?? homedir15(), ".gemini")];
     const check = checkVaultTarget(current, target, { protectedDirs, platform });
     if (check.kind === "refused") throw new VaultError(check.text);
     if (check.kind === "same") return;
     try {
       await this.writer.exclusive("moving", async () => {
         if (!await canWriteInto(target)) throw new VaultError(serverText("vaultCannotWrite"));
-        const hadCopy = await stat42(vaultMarkerFile(current)).then(
+        const hadCopy = await stat43(vaultMarkerFile(current)).then(
           () => true,
           () => false
         );
@@ -24797,7 +25570,7 @@ var VaultService = class {
   /** Abre la carpeta de la copia con el explorador del sistema. */
   async reveal() {
     const dir = this.activeDir();
-    const isFolder = await stat42(dir).then(
+    const isFolder = await stat43(dir).then(
       (info) => info.isDirectory(),
       () => false
     );
@@ -24821,7 +25594,7 @@ var VaultService = class {
       fromCopy: true
     });
     const file = sessionExportFile(dir, agent, sessionId);
-    await mkdir18(path64.dirname(file), { recursive: true });
+    await mkdir20(path66.dirname(file), { recursive: true });
     await writeFileAtomic(file, text, this.writeDeps);
     this.openWithSystem(file);
     return file;
@@ -24908,7 +25681,7 @@ var VaultService = class {
     const project = this.options.index.getProjects().find((candidate) => candidate.key === projectKey);
     if (project === void 0) throw new VaultError(serverText("vaultProjectGone"));
     const folder = projectExportDirFor(this.activeDir(), project, this.options.platform);
-    await mkdir18(folder, { recursive: true });
+    await mkdir20(folder, { recursive: true });
     const entries = [];
     const names = /* @__PURE__ */ new Set();
     let skipped = 0;
@@ -24925,7 +25698,7 @@ var VaultService = class {
         continue;
       }
       const fileName = this.exportFileName(summary, names);
-      await writeFileAtomic(path64.join(folder, fileName), text, this.writeDeps);
+      await writeFileAtomic(path66.join(folder, fileName), text, this.writeDeps);
       entries.push({
         updatedAt: summary.updatedAt,
         agentLabel: this.labelOf(summary.agent),
@@ -24936,9 +25709,9 @@ var VaultService = class {
       });
       await nextTurn3();
     }
-    const name = project.cwd.length > 0 ? path64.basename(project.cwd) || project.cwd : project.fallbackName;
+    const name = project.cwd.length > 0 ? path66.basename(project.cwd) || project.cwd : project.fallbackName;
     const index = renderProjectIndex({ name, cwd: project.cwd, exportedAt: this.now(), entries, skipped });
-    await writeFileAtomic(path64.join(folder, "index.md"), index, this.writeDeps);
+    await writeFileAtomic(path66.join(folder, "index.md"), index, this.writeDeps);
     this.openWithSystem(folder);
     return { sessions: entries.length, skipped, folder };
   }
@@ -25076,14 +25849,14 @@ var VaultService = class {
 // packages/server/src/worktrees/service.ts
 import { randomBytes as randomBytes6, randomUUID as randomUUID7 } from "node:crypto";
 import { EventEmitter as EventEmitter7 } from "node:events";
-import { lstat as lstat5, mkdir as mkdir22, rename as rename7, rm as rm10, rmdir, stat as stat45 } from "node:fs/promises";
-import path72 from "node:path";
+import { lstat as lstat5, mkdir as mkdir24, rename as rename7, rm as rm12, rmdir, stat as stat46 } from "node:fs/promises";
+import path74 from "node:path";
 
 // packages/server/src/worktrees/git.ts
 import { execFile as execFile6 } from "node:child_process";
-import { mkdtemp, rm as rm7, stat as stat43 } from "node:fs/promises";
+import { mkdtemp, rm as rm9, stat as stat44 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
-import path65 from "node:path";
+import path67 from "node:path";
 var READ_TIMEOUT_MS = 15e3;
 var WRITE_TIMEOUT_MS = 12e4;
 var MAX_BUFFER = 32 * 1024 * 1024;
@@ -25129,10 +25902,10 @@ async function repoLayout(cwd) {
   if (result.code !== 0) return null;
   const [toplevel, gitDir, commonDir] = result.stdout.split(/\r?\n/).map((line) => line.trim());
   if (!toplevel || !gitDir || !commonDir) return null;
-  const absoluteCommon = path65.resolve(cwd, commonDir);
-  const linked = path65.resolve(gitDir).toLowerCase() !== absoluteCommon.toLowerCase();
-  const mainRoot = path65.basename(absoluteCommon).toLowerCase() === ".git" ? path65.dirname(absoluteCommon) : null;
-  return { toplevel: path65.resolve(toplevel), mainRoot, linked };
+  const absoluteCommon = path67.resolve(cwd, commonDir);
+  const linked = path67.resolve(gitDir).toLowerCase() !== absoluteCommon.toLowerCase();
+  const mainRoot = path67.basename(absoluteCommon).toLowerCase() === ".git" ? path67.dirname(absoluteCommon) : null;
+  return { toplevel: path67.resolve(toplevel), mainRoot, linked };
 }
 async function currentBranch(cwd) {
   const result = await read(cwd, ["symbolic-ref", "--quiet", "HEAD"]);
@@ -25171,18 +25944,18 @@ async function uncommittedPaths(cwd) {
 async function hasLoadedSubmodule(cwd) {
   const [modules, staged] = await Promise.all([read(cwd, ["rev-parse", "--git-path", "modules"]), read(cwd, ["ls-files", "--stage", "-z"])]);
   if (modules.code !== 0 || staged.code !== 0) return null;
-  if (await isDirectory4(path65.resolve(cwd, modules.stdout.trim()))) return true;
+  if (await isDirectory4(path67.resolve(cwd, modules.stdout.trim()))) return true;
   const submodules = staged.stdout.split("\0").filter((line) => line.startsWith("160000 ")).map((line) => line.slice(line.indexOf("	") + 1));
   for (const submodule of submodules) {
-    if (await exists4(path65.join(cwd, submodule, ".git"))) return true;
+    if (await exists4(path67.join(cwd, submodule, ".git"))) return true;
   }
   return false;
 }
 async function isDirectory4(candidate) {
-  return (await stat43(candidate).catch(() => null))?.isDirectory() === true;
+  return (await stat44(candidate).catch(() => null))?.isDirectory() === true;
 }
 async function exists4(candidate) {
-  return await stat43(candidate).catch(() => null) !== null;
+  return await stat44(candidate).catch(() => null) !== null;
 }
 async function isIntegrated(cwd, branch, base) {
   const result = await read(cwd, ["merge-base", "--is-ancestor", `refs/heads/${branch}`, `refs/heads/${base}`]);
@@ -25330,7 +26103,7 @@ async function branchFileDiff(cwd, base, branch, file, oldPath) {
 async function objectsDir(mainRoot) {
   const result = await read(mainRoot, ["rev-parse", "--git-path", "objects"]);
   const answer = result.stdout.trim();
-  return result.code === 0 && answer.length > 0 ? path65.resolve(mainRoot, answer) : null;
+  return result.code === 0 && answer.length > 0 ? path67.resolve(mainRoot, answer) : null;
 }
 function alternatesValue(folder, platform = process.platform) {
   const separator = platform === "win32" ? ";" : ":";
@@ -25340,7 +26113,7 @@ function alternatesValue(folder, platform = process.platform) {
 async function mergeTreeCheck(mainRoot, base, branch) {
   const objects = await objectsDir(mainRoot);
   if (objects === null) return null;
-  const scratch = await mkdtemp(path65.join(tmpdir5(), "aw-merge-tree-")).catch(() => null);
+  const scratch = await mkdtemp(path67.join(tmpdir5(), "aw-merge-tree-")).catch(() => null);
   if (scratch === null) return null;
   try {
     const result = await read(
@@ -25351,7 +26124,7 @@ async function mergeTreeCheck(mainRoot, base, branch) {
     );
     return parseMergeTree(result);
   } finally {
-    await rm7(scratch, { recursive: true, force: true, maxRetries: 3 }).catch(() => void 0);
+    await rm9(scratch, { recursive: true, force: true, maxRetries: 3 }).catch(() => void 0);
   }
 }
 function parseMergeTree(result) {
@@ -25392,7 +26165,7 @@ function fastForward(baseFolder, target) {
 
 // packages/server/src/worktrees/holders.ts
 import { spawn as spawn4 } from "node:child_process";
-import path66 from "node:path";
+import path68 from "node:path";
 var SCAN_MAX_ENTRIES = 2e5;
 var SCAN_MAX_MS = 4e3;
 var HOLDERS_TIMEOUT_MS = 15e3;
@@ -25545,7 +26318,7 @@ public static class AwFolderHolders {
 }
 `;
 function longPath(folder) {
-  const absolute = path66.win32.resolve(folder);
+  const absolute = path68.win32.resolve(folder);
   if (absolute.startsWith("\\\\?\\")) return absolute;
   return absolute.startsWith("\\\\") ? `\\\\?\\UNC\\${absolute.slice(2)}` : `\\\\?\\${absolute}`;
 }
@@ -25580,7 +26353,7 @@ function parseHoldersOutput(output, selfPid) {
 }
 function powershellPath() {
   const systemRoot = process.env["SystemRoot"] ?? process.env["windir"] ?? "C:\\Windows";
-  return path66.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  return path68.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
 }
 function runPowerShell(script) {
   return new Promise((resolve) => {
@@ -25629,8 +26402,8 @@ async function folderHolders(folder) {
 
 // packages/server/src/worktrees/include.ts
 import { createHash as createHash6 } from "node:crypto";
-import { lstat as lstat3, mkdir as mkdir19, readdir as readdir19, readFile as readFile28, writeFile as writeFile11 } from "node:fs/promises";
-import path67 from "node:path";
+import { lstat as lstat3, mkdir as mkdir21, readdir as readdir21, readFile as readFile29, writeFile as writeFile12 } from "node:fs/promises";
+import path69 from "node:path";
 
 // packages/server/src/worktrees/merge-notes.ts
 var MERGE_MAX_EDITS = 2e3;
@@ -25806,7 +26579,7 @@ var CLI_CONFIG_DIRS = /* @__PURE__ */ new Set([".claude", ".codex", ".gemini", "
 var CLI_CONFIG_FILES = /* @__PURE__ */ new Set([".mcp.json", "opencode.json", "opencode.jsonc"]);
 var INCLUDE_FILE = ".worktreeinclude";
 var INCLUDE_FILE_MAX_BYTES = 64 * 1024;
-var toPosix2 = (value) => value.split(path67.sep).join("/");
+var toPosix2 = (value) => value.split(path69.sep).join("/");
 function hashOf(content) {
   return createHash6("sha256").update(content).digest("hex");
 }
@@ -25857,7 +26630,7 @@ async function walkEntry(mainRoot, relative, out, budget) {
   if (!info.isDirectory()) return;
   let names;
   try {
-    names = (await readdir19(absolute)).sort();
+    names = (await readdir21(absolute)).sort();
   } catch {
     return;
   }
@@ -25911,10 +26684,10 @@ async function copyToWorktree(mainRoot, folder, files, bases) {
       const source = await resolveInside(mainRoot, file.path, { mustExist: true });
       const info = await lstat3(source);
       if (!info.isFile()) continue;
-      content = await readFile28(source);
+      content = await readFile29(source);
       const target = await resolveInside(folder, file.path);
-      await mkdir19(path67.dirname(target), { recursive: true });
-      await writeFile11(target, content, { flag: "wx" });
+      await mkdir21(path69.dirname(target), { recursive: true });
+      await writeFile12(target, content, { flag: "wx" });
       copied.push({ path: file.path, hash: hashOf(content) });
     } catch (error) {
       console.warn(`[worktrees] ${file.path} wasn't copied to the branch folder:`, error);
@@ -25931,7 +26704,7 @@ async function readInside(root, relative) {
     const absolute = await resolveInside(root, relative, { mustExist: true });
     const info = await lstat3(absolute);
     if (!info.isFile()) return null;
-    return await readFile28(absolute);
+    return await readFile29(absolute);
   } catch {
     return null;
   }
@@ -26000,7 +26773,7 @@ async function filesUnder(folder, relative, out) {
     return;
   }
   if (!info.isDirectory()) return;
-  for (const name of (await readdir19(absolute).catch(() => [])).sort()) {
+  for (const name of (await readdir21(absolute).catch(() => [])).sort()) {
     await filesUnder(folder, `${relative}/${name}`, out);
   }
 }
@@ -26053,7 +26826,7 @@ async function returnNotes(mainRoot, folder, files, bases, options = {}) {
         result.skipped.push(file);
         continue;
       }
-      await mkdir19(path67.dirname(target), { recursive: true });
+      await mkdir21(path69.dirname(target), { recursive: true });
       await writeAtomically(target, outcome.content, {
         beforeRename: async () => {
           const now = await readInside(mainRoot, file);
@@ -26075,15 +26848,15 @@ async function returnNotes(mainRoot, folder, files, bases, options = {}) {
 }
 
 // packages/server/src/worktrees/names.ts
-import path68 from "node:path";
-function worktreeFolderFor(mainRoot, branch, pathApi = path68) {
+import path70 from "node:path";
+function worktreeFolderFor(mainRoot, branch, pathApi = path70) {
   const parent = pathApi.dirname(mainRoot);
   return pathApi.join(parent, worktreesDirName(pathApi.basename(mainRoot)), worktreeFolderName(branch));
 }
-function worktreesParentFor(mainRoot, pathApi = path68) {
+function worktreesParentFor(mainRoot, pathApi = path70) {
   return pathApi.join(pathApi.dirname(mainRoot), worktreesDirName(pathApi.basename(mainRoot)));
 }
-function mainRootFromShape(folder, pathApi = path68) {
+function mainRootFromShape(folder, pathApi = path70) {
   const parent = pathApi.dirname(folder);
   const parentName = pathApi.basename(parent);
   if (parentName.length > ".worktrees".length && parentName.toLowerCase().endsWith(".worktrees")) {
@@ -26098,8 +26871,8 @@ function mainRootFromShape(folder, pathApi = path68) {
 
 // packages/server/src/worktrees/note-bases.ts
 import { createHash as createHash7 } from "node:crypto";
-import { mkdir as mkdir20, readdir as readdir20, readFile as readFile29, rm as rm8, stat as stat44, utimes as utimes3 } from "node:fs/promises";
-import path69 from "node:path";
+import { mkdir as mkdir22, readdir as readdir22, readFile as readFile30, rm as rm10, stat as stat45, utimes as utimes3 } from "node:fs/promises";
+import path71 from "node:path";
 var TEXT_NOTE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".markdown", ".txt", ".rst", ".adoc"]);
 var NOTE_BASE_MAX_BYTES = 2 * 1024 * 1024;
 var PRUNE_GRACE_MS = 10 * 6e4;
@@ -26108,7 +26881,7 @@ function hashOf2(content) {
   return createHash7("sha256").update(content).digest("hex");
 }
 function keepsNoteBase(relative, content) {
-  return TEXT_NOTE_EXTENSIONS.has(path69.posix.extname(relative).toLowerCase()) && content.length <= NOTE_BASE_MAX_BYTES && !content.subarray(0, 8e3).includes(0);
+  return TEXT_NOTE_EXTENSIONS.has(path71.posix.extname(relative).toLowerCase()) && content.length <= NOTE_BASE_MAX_BYTES && !content.subarray(0, 8e3).includes(0);
 }
 var NoteBases = class {
   constructor(dir = worktreeNotesDir(), options = {}) {
@@ -26128,21 +26901,21 @@ var NoteBases = class {
   async save(relative, content) {
     if (!keepsNoteBase(relative, content)) return;
     const hash = hashOf2(content);
-    const file = path69.join(this.dir, hash);
-    const current = await readFile29(file).catch(() => null);
+    const file = path71.join(this.dir, hash);
+    const current = await readFile30(file).catch(() => null);
     if (current !== null && hashOf2(current) === hash) {
       const now = new Date(this.now());
       await utimes3(file, now, now).catch(() => void 0);
       return;
     }
-    await mkdir20(this.dir, { recursive: true });
+    await mkdir22(this.dir, { recursive: true });
     await writeAtomically(file, content);
   }
   /** La copia de origen con esa huella, o null si no hay (o lo que hay no es eso). */
   async load(hash) {
     if (!HASH.test(hash)) return null;
     try {
-      const content = await readFile29(path69.join(this.dir, hash));
+      const content = await readFile30(path71.join(this.dir, hash));
       return hashOf2(content) === hash ? content : null;
     } catch {
       return null;
@@ -26152,18 +26925,18 @@ var NoteBases = class {
   async prune(keep) {
     let names;
     try {
-      names = await readdir20(this.dir);
+      names = await readdir22(this.dir);
     } catch {
       return;
     }
     const now = this.now();
     for (const name of names) {
       if (!HASH.test(name) || keep.has(name)) continue;
-      const file = path69.join(this.dir, name);
+      const file = path71.join(this.dir, name);
       try {
-        const info = await stat44(file);
+        const info = await stat45(file);
         if (!info.isFile() || now - info.mtimeMs < this.graceMs) continue;
-        await rm8(file, { force: true });
+        await rm10(file, { force: true });
       } catch {
       }
     }
@@ -26248,9 +27021,9 @@ function readVerdict(reply) {
 }
 
 // packages/server/src/worktrees/store.ts
-import { mkdir as mkdir21, readFile as readFile30 } from "node:fs/promises";
-import path70 from "node:path";
-var STATE_VERSION5 = 1;
+import { mkdir as mkdir23, readFile as readFile31 } from "node:fs/promises";
+import path72 from "node:path";
+var STATE_VERSION6 = 1;
 var MAX_REMOVED = 300;
 var MAX_REVIEW_SESSIONS = 20;
 function parseNoteRequest(value) {
@@ -26330,7 +27103,7 @@ function parseWorktreeRecord(value) {
 function parseWorktreesState(raw) {
   try {
     const parsed = asRecord(JSON.parse(raw));
-    if (parsed === null || parsed["version"] !== STATE_VERSION5) return [];
+    if (parsed === null || parsed["version"] !== STATE_VERSION6) return [];
     return asArrayFiltered(parsed["worktrees"], parseWorktreeRecord) ?? [];
   } catch {
     return [];
@@ -26345,7 +27118,7 @@ var WorktreeStore = class {
   writing = Promise.resolve();
   async load() {
     try {
-      this.records = parseWorktreesState(await readFile30(this.file, "utf8"));
+      this.records = parseWorktreesState(await readFile31(this.file, "utf8"));
     } catch {
       this.records = [];
     }
@@ -26385,9 +27158,9 @@ var WorktreeStore = class {
       );
       this.records = this.records.filter((record) => !forget.has(record.id));
     }
-    const content = Buffer.from(JSON.stringify({ version: STATE_VERSION5, worktrees: this.records }, null, 2), "utf8");
+    const content = Buffer.from(JSON.stringify({ version: STATE_VERSION6, worktrees: this.records }, null, 2), "utf8");
     this.writing = this.writing.catch(() => void 0).then(async () => {
-      await mkdir21(path70.dirname(this.file), { recursive: true });
+      await mkdir23(path72.dirname(this.file), { recursive: true });
       await writeAtomically(this.file, content);
     });
     return this.writing;
@@ -26396,8 +27169,8 @@ var WorktreeStore = class {
 
 // packages/server/src/worktrees/untracked.ts
 import { createHash as createHash8 } from "node:crypto";
-import { lstat as lstat4, readdir as readdir21, realpath as realpath7, rm as rm9 } from "node:fs/promises";
-import path71 from "node:path";
+import { lstat as lstat4, readdir as readdir23, realpath as realpath7, rm as rm11 } from "node:fs/promises";
+import path73 from "node:path";
 var sameName = (a, b) => a.toLowerCase() === b.toLowerCase();
 function cleanEntry(entry) {
   const clean = entry.replace(/\/+$/, "");
@@ -26414,9 +27187,9 @@ async function scanUntracked(folder, entries, maxFiles = WORKTREE_UNTRACKED_MAX_
     let target;
     let real;
     try {
-      const parent = await resolveInside(folder, path71.posix.dirname(clean), { mustExist: true });
-      target = path71.join(parent, path71.posix.basename(clean));
-      real = path71.join(await realpath7(parent), path71.posix.basename(clean));
+      const parent = await resolveInside(folder, path73.posix.dirname(clean), { mustExist: true });
+      target = path73.join(parent, path73.posix.basename(clean));
+      real = path73.join(await realpath7(parent), path73.posix.basename(clean));
     } catch {
       return null;
     }
@@ -26452,7 +27225,7 @@ async function visit(absolute, real, relative, walk2) {
 `);
   let names;
   try {
-    names = (await readdir21(absolute)).sort();
+    names = (await readdir23(absolute)).sort();
   } catch {
     walk2.hash.update(`${relative}\0!
 `);
@@ -26463,14 +27236,14 @@ async function visit(absolute, real, relative, walk2) {
     return;
   }
   for (const name of names) {
-    await visit(path71.join(absolute, name), path71.join(real, name), `${relative}/${name}`, walk2);
+    await visit(path73.join(absolute, name), path73.join(real, name), `${relative}/${name}`, walk2);
     if (walk2.blocked !== null) return;
   }
 }
 async function deleteUntracked(targets) {
   for (const target of targets) {
     try {
-      await rm9(target, { recursive: true, maxRetries: 3 });
+      await rm11(target, { recursive: true, maxRetries: 3 });
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
@@ -26496,19 +27269,19 @@ var REPLY_EVENTS = 300;
 var REPLY_CACHE_MAX = 50;
 var REVIEW_ACTIVITY_DELAY_MS = 1e3;
 async function leftWithoutGit(folder) {
-  return await exists5(folder) && await lstat5(path72.join(folder, ".git")).catch(() => null) === null;
+  return await exists5(folder) && await lstat5(path74.join(folder, ".git")).catch(() => null) === null;
 }
 async function exists5(candidate) {
   try {
-    await stat45(candidate);
+    await stat46(candidate);
     return true;
   } catch {
     return false;
   }
 }
 function isInside4(outer, inner) {
-  const relative = path72.relative(path72.resolve(outer), path72.resolve(inner));
-  return relative.length === 0 || !relative.startsWith("..") && !path72.isAbsolute(relative);
+  const relative = path74.relative(path74.resolve(outer), path74.resolve(inner));
+  return relative.length === 0 || !relative.startsWith("..") && !path74.isAbsolute(relative);
 }
 function displayCommand(args) {
   return ["git", ...args].map((arg) => /[\s"]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg).join(" ");
@@ -26583,7 +27356,7 @@ var WorktreeService = class extends EventEmitter7 {
     return {
       mainRoot,
       parentDir: worktreesParentFor(mainRoot),
-      separator: path72.sep,
+      separator: path74.sep,
       currentBranch: current,
       branches: branches.map((name) => ({ name, checkedOut: checkedOut.has(name) })),
       mainChanges: changes?.length ?? 0,
@@ -26607,7 +27380,7 @@ var WorktreeService = class extends EventEmitter7 {
     const folder = worktreeFolderFor(mainRoot, branch);
     if (await exists5(folder)) throw new WorktreeError(serverText("worktreeFolderExists", { folder }));
     const copy = await planCopy(mainRoot);
-    await mkdir22(path72.dirname(folder), { recursive: true });
+    await mkdir24(path74.dirname(folder), { recursive: true });
     const added = await addWorktree(mainRoot, folder, branch, mode === "new" ? base : null);
     if (added.code !== 0) throw new WorktreeError(serverText("worktreeGitFailed", { detail: gitFailureText(added) }));
     const { copied, copiedDirs } = await this.copyInto(mainRoot, folder, copy, request.copyNotes);
@@ -26658,7 +27431,7 @@ var WorktreeService = class extends EventEmitter7 {
     const mainRoot = layout.mainRoot;
     const tips = await branchTips(mainRoot);
     const tipsStamp = [...tips].map(([branch, commit]) => `${branch}\0${commit}`).join("\n");
-    const cacheKey2 = path72.resolve(mainRoot).toLowerCase();
+    const cacheKey2 = path74.resolve(mainRoot).toLowerCase();
     const cached = this.rowsCache.get(cacheKey2);
     const fresh = cached !== void 0 && cached.tips === tipsStamp && this.now() - cached.at < ROWS_TTL_MS;
     const generation = this.rowsGeneration;
@@ -26719,7 +27492,7 @@ var WorktreeService = class extends EventEmitter7 {
     const baseTip = tips.get(base);
     const branchTip = tips.get(branch);
     if (baseTip === void 0 || branchTip === void 0) return Promise.resolve(null);
-    const key = [path72.resolve(mainRoot).toLowerCase(), base, branch, baseTip, branchTip].join("\0");
+    const key = [path74.resolve(mainRoot).toLowerCase(), base, branch, baseTip, branchTip].join("\0");
     const cached = this.pairs.get(key);
     if (cached !== void 0) {
       this.pairs.delete(key);
@@ -26769,7 +27542,7 @@ var WorktreeService = class extends EventEmitter7 {
   }
   /** Las pestañas y consolas abiertas dentro de la carpeta de la rama. */
   tabsIn(folder) {
-    return this.deps.registry.list().filter((tab) => isInside4(folder, tab.cwd)).map((tab) => ({ terminalId: tab.terminalId, kind: tab.kind, label: tab.label || path72.basename(tab.cwd) }));
+    return this.deps.registry.list().filter((tab) => isInside4(folder, tab.cwd)).map((tab) => ({ terminalId: tab.terminalId, kind: tab.kind, label: tab.label || path74.basename(tab.cwd) }));
   }
   /**
    * Las pestañas de una carpeta de trabajo, sin las de otra que viva adentro
@@ -26802,7 +27575,7 @@ var WorktreeService = class extends EventEmitter7 {
     });
     const copied = [];
     for (const file of record.copied) {
-      if (entryOf(file.path) && await exists5(path72.join(record.path, file.path))) copied.push(file.path);
+      if (entryOf(file.path) && await exists5(path74.join(record.path, file.path))) copied.push(file.path);
     }
     if (copied.length > 0) {
       const ignored = await ignoredAmong(record.path, copied);
@@ -26950,11 +27723,11 @@ var WorktreeService = class extends EventEmitter7 {
    * contenga, ni una carpeta que git todavía tenga registrada.
    */
   async removeLeftovers(record) {
-    const folder = path72.resolve(record.path);
+    const folder = path74.resolve(record.path);
     if (!await exists5(folder)) return this.removeEmptyParent(folder);
-    if (isInside4(folder, record.mainRoot) || path72.dirname(folder) === folder) return;
+    if (isInside4(folder, record.mainRoot) || path74.dirname(folder) === folder) return;
     if ((await listWorktrees(record.mainRoot)).some((entry) => samePathShape(entry.path, folder))) return;
-    await rm10(folder, { recursive: true, maxRetries: 3 });
+    await rm12(folder, { recursive: true, maxRetries: 3 });
     await this.removeEmptyParent(folder);
   }
   /**
@@ -26977,13 +27750,13 @@ var WorktreeService = class extends EventEmitter7 {
     for (const record of this.deps.store.list()) {
       if (record.removedAt !== null || !samePathShape(record.mainRoot, mainRoot)) continue;
       if (listed.some((entry) => samePathShape(entry.path, record.path)) || !await leftWithoutGit(record.path)) continue;
-      released.push({ path: path72.resolve(record.path), branch: record.branch, isMain: false, bare: false, locked: false, prunable: true });
+      released.push({ path: path74.resolve(record.path), branch: record.branch, isMain: false, bare: false, locked: false, prunable: true });
     }
     return released;
   }
   /** La carpeta `<proyecto>.worktrees`, sólo si quedó vacía. */
   async removeEmptyParent(folder) {
-    await rmdir(path72.dirname(folder)).catch(() => void 0);
+    await rmdir(path74.dirname(folder)).catch(() => void 0);
   }
   /**
    * Vuelve a abrir la rama de una sesión cuya carpeta se quitó: la saca otra
@@ -27007,7 +27780,7 @@ var WorktreeService = class extends EventEmitter7 {
       throw new WorktreeError(serverText("worktreeBranchInUse", { branch: record.branch }));
     }
     const copy = await planCopy(record.mainRoot);
-    await mkdir22(path72.dirname(record.path), { recursive: true });
+    await mkdir24(path74.dirname(record.path), { recursive: true });
     const added = await addWorktree(record.mainRoot, record.path, record.branch, recreateAt);
     if (added.code !== 0) throw new WorktreeError(serverText("worktreeGitFailed", { detail: gitFailureText(added) }));
     const { copied, copiedDirs } = await this.copyInto(record.mainRoot, record.path, copy, record.copyNotes);
@@ -27094,11 +27867,11 @@ var WorktreeService = class extends EventEmitter7 {
     return { branch: plan.branch };
   }
   removedRecordAbove(cwd) {
-    let current = path72.resolve(cwd);
+    let current = path74.resolve(cwd);
     for (let depth = 0; depth < 24; depth += 1) {
       const record = this.deps.store.byPath(current);
       if (record !== null) return record.removedAt === null ? null : record;
-      const parent = path72.dirname(current);
+      const parent = path74.dirname(current);
       if (parent === current) return null;
       current = parent;
     }
@@ -27207,8 +27980,8 @@ var WorktreeService = class extends EventEmitter7 {
    * reanudada; y si tampoco hay, una nueva en la carpeta de la rama.
    */
   async authorTarget(record) {
-    const open9 = this.authorTab(record);
-    if (open9 !== null) return { terminal: open9, opened: false };
+    const open10 = this.authorTab(record);
+    if (open10 !== null) return { terminal: open10, opened: false };
     const session = this.authorSession(record);
     if (session !== null && isAgentId(session.agent) && session.cwd.length > 0 && await exists5(session.cwd)) {
       const terminal = await this.deps.registry.open({ cwd: session.cwd, agent: session.agent, resumeSessionId: session.sessionId });
@@ -27547,6 +28320,549 @@ var WorktreeService = class extends EventEmitter7 {
   }
 };
 
+// packages/server/src/scheduled-messages/scheduler.ts
+import { randomUUID as randomUUID8 } from "node:crypto";
+var SCHEDULER_TICK_MS = 3e4;
+var SCHEDULER_NUDGE_MS = 300;
+var SCHEDULED_DELIVERY_TIMEOUT_MS = 6e4;
+var SCHEDULED_COOLDOWN_MS = 1e4;
+var SCHEDULED_OTHER_INSTANCE_GRACE_MS = 6e4;
+function scheduleCreateRefusal(input) {
+  if (!input.enabled) return serverText("scheduleOff");
+  if (input.owner === null || input.agentLabel === null) return serverText("scheduleNoConversation");
+  if (!input.capable) return serverText("scheduleUnsupported", { label: input.agentLabel });
+  if (input.text.trim().length === 0) return serverText("scheduleEmpty");
+  if (input.text.length > MAX_SCHEDULED_TEXT_CHARS) return serverText("scheduleTooLong", { max: MAX_SCHEDULED_TEXT_CHARS });
+  const problem = scheduleTimeProblem(input.sendAt, input.now);
+  if (problem === "past") return serverText("schedulePast");
+  if (problem === "too-far") return serverText("scheduleTooFar", { days: Math.round(MAX_SCHEDULE_AHEAD_MS / 864e5) });
+  if (input.count >= MAX_SCHEDULED_MESSAGES) return serverText("scheduleTooMany", { max: MAX_SCHEDULED_MESSAGES });
+  return null;
+}
+function scheduledFailureFor(outcome) {
+  switch (outcome.kind) {
+    case "unconfirmed":
+      return serverText("scheduledUnconfirmed");
+    case "sent":
+    case "nothing":
+      return null;
+    case "gone":
+    case "no-agent":
+      return serverText("scheduledNoTab");
+    case "no-session":
+    case "no-ready-signal":
+    case "no-images":
+    case "not-ready":
+    case "image-failed":
+      return serverText("scheduledCliNotReady");
+    case "interrupted":
+    case "refused":
+      return serverText("scheduledUncertainWrite");
+  }
+}
+var defaultTimer2 = (callback, ms) => {
+  const timer = setTimeout(callback, ms);
+  timer.unref();
+  return () => clearTimeout(timer);
+};
+var MessageScheduler = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.setTimer = deps.setTimer ?? defaultTimer2;
+  }
+  deps;
+  /** Lo que esta pasando con cada mensaje en este proceso: esperando, mandandose. No se guarda. */
+  runtime = /* @__PURE__ */ new Map();
+  /** La primera vez que este proceso vio vencido cada mensaje: de ahi cuenta la hora de margen. */
+  firstDue = /* @__PURE__ */ new Map();
+  /** Los que se estan mandando ahora, desde este proceso. */
+  inFlight = /* @__PURE__ */ new Set();
+  /** La pestana de cada uno que se esta mandando: de a uno por pestana. */
+  inFlightTabs = /* @__PURE__ */ new Map();
+  /** Hasta cuando no se le manda otro a cada pestana (`SCHEDULED_COOLDOWN_MS`). */
+  cooldownUntil = /* @__PURE__ */ new Map();
+  /** Hito 52. Hasta cuando espera cada mensaje a la otra instancia (`SCHEDULED_OTHER_INSTANCE_GRACE_MS`). */
+  graceUntil = /* @__PURE__ */ new Map();
+  ticking = false;
+  again = false;
+  stopped = true;
+  cancelTimer = null;
+  timerAt = Number.POSITIVE_INFINITY;
+  lastPublished = "";
+  setTimer;
+  /** Arranca: despues de restaurar las pestanas, o no sabria cual es la de cada mensaje. */
+  start() {
+    if (!this.stopped) return;
+    this.stopped = false;
+    void this.tick();
+  }
+  /** Para el reloj y suelta lo reservado: una instancia que se apaga no se queda con nada. */
+  async stop() {
+    this.stopped = true;
+    this.cancelTimer?.();
+    this.cancelTimer = null;
+    this.timerAt = Number.POSITIVE_INFINITY;
+    await this.deps.store.releaseReserved();
+  }
+  /** Algo cambio (el agente quedo libre, se toco un ajuste): una vuelta pronto. */
+  nudge() {
+    if (this.stopped) return;
+    this.schedule(SCHEDULER_NUDGE_MS);
+  }
+  /** La lista tal como va a las ventanas, con la pestana de hoy de cada conversacion. */
+  snapshot() {
+    const tabs = this.deps.tabs();
+    const now = this.deps.now();
+    const enabled2 = this.deps.enabled();
+    return this.deps.store.list().sort((a, b) => a.sendAt - b.sendAt || a.createdAt - b.createdAt).map((message) => {
+      const tab = tabs.find((entry) => entry.agent === message.agent && entry.sessionId === message.sessionId);
+      const running = this.runtime.get(message.id);
+      let state;
+      let note = null;
+      if (message.failure !== void 0) {
+        state = "failed";
+        note = message.failure;
+      } else if (this.inFlight.has(message.id)) {
+        state = "sending";
+      } else if (!enabled2) {
+        state = "paused";
+      } else if (running !== void 0) {
+        state = running.state;
+        note = running.note;
+      } else {
+        state = now < message.sendAt ? "scheduled" : "waiting";
+      }
+      return {
+        id: message.id,
+        agent: message.agent,
+        sessionId: message.sessionId,
+        terminalId: tab?.terminalId ?? null,
+        text: message.text,
+        sendAt: message.sendAt,
+        createdAt: message.createdAt,
+        state,
+        note
+      };
+    });
+  }
+  /** Avisa la lista si cambio desde la ultima vez. Tambien cuando cambian las pestanas: cambia la de cada uno. */
+  publish() {
+    const list = this.snapshot();
+    const key = JSON.stringify(list);
+    if (key === this.lastPublished) return;
+    this.lastPublished = key;
+    this.deps.onChange(list);
+  }
+  async create(owner, agent, text, sendAt) {
+    const message = {
+      id: randomUUID8(),
+      agent,
+      sessionId: owner.sessionId,
+      text,
+      sendAt,
+      createdAt: this.deps.now()
+    };
+    await this.deps.store.add(message);
+    this.publish();
+    this.nudge();
+    return message;
+  }
+  /** Lo saca, si no se esta mandando. Su texto vuelve al cuadro: lo hace quien llama. */
+  async cancel(id) {
+    await this.deps.store.refresh();
+    if (this.deps.store.get(id) === null) return { kind: "gone" };
+    if (this.inFlight.has(id)) return { kind: "sending" };
+    const claim = await this.deps.store.claimOf(id);
+    if (claim !== null && !claim.mine && claim.alive && claim.phase === "writing") return { kind: "sending" };
+    const removed = await this.deps.store.remove(id);
+    if (removed === null) return { kind: "gone" };
+    await this.deps.store.release(id);
+    this.forget(id);
+    this.publish();
+    return { kind: "removed", message: removed };
+  }
+  /** Lo pone a la hora de ahora y le borra la falla: se manda con las reglas de siempre. */
+  async sendNow(id) {
+    if (!this.deps.enabled()) return "off";
+    await this.deps.store.refresh();
+    if (this.deps.store.get(id) === null) return "gone";
+    if (this.inFlight.has(id)) return "sending";
+    const claim = await this.deps.store.claimOf(id);
+    if (claim !== null && !claim.mine && claim.alive && claim.phase === "writing") return "sending";
+    const updated = await this.deps.store.update(id, { sendAt: this.deps.now(), failure: null });
+    if (updated === null) return "gone";
+    this.forget(id);
+    this.publish();
+    this.nudge();
+    return "ok";
+  }
+  /** Se cerro la pestana: lo de su conversacion se cancela (la web lo pregunto antes). */
+  async dropOwner(owner) {
+    const removed = await this.deps.store.removeOwner(owner);
+    for (const message of removed) {
+      if (!this.inFlight.has(message.id)) await this.deps.store.release(message.id);
+      this.forget(message.id);
+    }
+    if (removed.length > 0) this.publish();
+  }
+  /** La pestana cambio de conversacion: lo programado va con ella, como el borrador. */
+  async moveOwner(from, to) {
+    if (await this.deps.store.move(from, to) > 0) {
+      this.publish();
+      this.nudge();
+    }
+  }
+  /** Una vuelta. Nunca dos a la vez: la que llega mientras corre otra se hace despues. */
+  async tick() {
+    if (this.stopped) return;
+    if (this.ticking) {
+      this.again = true;
+      return;
+    }
+    this.ticking = true;
+    try {
+      await this.pass();
+    } catch (error) {
+      this.deps.log?.(`[scheduled] a pass failed: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      this.ticking = false;
+      this.publish();
+      if (this.again) {
+        this.again = false;
+        this.schedule(0);
+      } else {
+        this.scheduleNext();
+      }
+    }
+  }
+  // ---- por dentro ----
+  forget(id) {
+    this.runtime.delete(id);
+    this.firstDue.delete(id);
+    this.graceUntil.delete(id);
+  }
+  set(id, state, note) {
+    this.runtime.set(id, { state, note });
+  }
+  /** true si a esa pestana ya se le esta mandando uno, o se le mando hace muy poco. */
+  tabCooling(terminalId, now) {
+    if ((this.cooldownUntil.get(terminalId) ?? 0) > now) return true;
+    for (const tab of this.inFlightTabs.values()) {
+      if (tab === terminalId) return true;
+    }
+    return false;
+  }
+  async fail(id, note) {
+    await this.deps.store.update(id, { failure: note });
+    await this.deps.store.release(id);
+    this.set(id, "failed", note);
+    this.firstDue.delete(id);
+  }
+  /** Una vuelta dentro de `ms`, salvo que ya haya una antes. */
+  schedule(ms) {
+    if (this.stopped) return;
+    const at = this.deps.now() + ms;
+    if (this.cancelTimer !== null && this.timerAt <= at) return;
+    this.cancelTimer?.();
+    this.timerAt = at;
+    this.cancelTimer = this.setTimer(() => {
+      this.cancelTimer = null;
+      this.timerAt = Number.POSITIVE_INFINITY;
+      void this.tick();
+    }, ms);
+  }
+  /** La proxima vuelta: a la hora del proximo mensaje, o a los 30 s, lo que llegue antes. */
+  scheduleNext() {
+    const now = this.deps.now();
+    let wait = SCHEDULER_TICK_MS;
+    if (this.deps.enabled()) {
+      for (const message of this.deps.store.list()) {
+        if (message.failure !== void 0 || message.sendAt <= now) continue;
+        wait = Math.min(wait, message.sendAt - now + 20);
+      }
+      for (const until of this.cooldownUntil.values()) {
+        if (until > now) wait = Math.min(wait, until - now + 20);
+      }
+      for (const until of this.graceUntil.values()) {
+        if (until > now) wait = Math.min(wait, until - now + 20);
+      }
+    }
+    this.schedule(Math.max(0, wait));
+  }
+  async pass() {
+    const { store } = this.deps;
+    await store.refresh();
+    await this.deps.refreshEnabled?.();
+    const messages = store.list().sort((a, b) => a.sendAt - b.sendAt || a.createdAt - b.createdAt);
+    const present = new Set(messages.map((message) => message.id));
+    for (const id of [...this.runtime.keys()]) {
+      if (!present.has(id)) this.forget(id);
+    }
+    for (const id of await store.claimedIds()) {
+      if (present.has(id) || this.inFlight.has(id)) continue;
+      await store.release(id);
+      await store.discardOrphan(id);
+    }
+    const tabs = this.deps.tabs();
+    for (const message of messages) {
+      if (this.stopped) return;
+      if (this.inFlight.has(message.id)) continue;
+      await this.consider(message, tabs);
+    }
+  }
+  async consider(message, tabs) {
+    const { store } = this.deps;
+    const { id } = message;
+    const now = this.deps.now();
+    if (message.failure !== void 0) {
+      this.set(id, "failed", message.failure);
+      return;
+    }
+    if (!this.deps.enabled()) {
+      this.firstDue.delete(id);
+      await store.release(id);
+      this.set(id, "paused", null);
+      return;
+    }
+    if (now < message.sendAt) {
+      this.firstDue.delete(id);
+      this.set(id, "scheduled", null);
+      return;
+    }
+    const firstDue = this.firstDue.get(id) ?? now;
+    this.firstDue.set(id, firstDue);
+    const claim = await store.claimOf(id);
+    if (claim !== null && !claim.mine) {
+      if (claim.alive) {
+        this.set(id, "waiting", serverText("scheduledWaitOtherInstance"));
+        return;
+      }
+      if (claim.phase === "writing") {
+        await this.fail(id, serverText("scheduledUncertain"));
+        await store.discardOrphan(id);
+        return;
+      }
+    }
+    const mine = claim?.mine === true;
+    if (!mine && firstDue - message.sendAt > SCHEDULE_LATE_LIMIT_MS) {
+      await this.fail(id, serverText("scheduledMissed"));
+      return;
+    }
+    const overdue = now - message.sendAt > SCHEDULE_LATE_LIMIT_MS;
+    const tab = tabs.find((entry) => entry.agent === message.agent && entry.sessionId === message.sessionId) ?? null;
+    if (tab === null) {
+      if (mine) await store.release(id);
+      if (overdue) await this.fail(id, serverText("scheduledNoTab"));
+      else this.set(id, "waiting", serverText("scheduledWaitNoTab"));
+      return;
+    }
+    const agent = this.deps.agentOf(tab.agent);
+    if (agent === null || !agent.scheduledSend) {
+      await this.fail(id, serverText("scheduleUnsupported", { label: agent?.label ?? tab.agent }));
+      return;
+    }
+    if (tab.alive) {
+      if (await store.claim(id) !== "mine") {
+        this.set(id, "waiting", serverText("scheduledWaitOtherInstance"));
+        return;
+      }
+      const free = await this.freeNow(tab);
+      if (free === "idle" && !this.tabCooling(tab.terminalId, now)) {
+        this.startDelivery(message, tab, false);
+        return;
+      }
+      this.set(id, "waiting", free === "waiting" ? serverText("scheduledWaitAnswer") : serverText("scheduledWaitBusy"));
+      return;
+    }
+    if (this.tabCooling(tab.terminalId, now)) {
+      this.set(id, "waiting", serverText("scheduledWaitBusy"));
+      return;
+    }
+    if (!mine && this.deps.tellsOpenElsewhere?.(tab.agent) === false && await this.deps.othersRunning?.() === true) {
+      const graceEnd = firstDue + SCHEDULED_OTHER_INSTANCE_GRACE_MS;
+      if (now < graceEnd) {
+        this.graceUntil.set(id, graceEnd);
+        this.set(id, "waiting", serverText("scheduledWaitGrace"));
+        return;
+      }
+    }
+    this.graceUntil.delete(id);
+    if (await this.deps.isOpenElsewhere(tab.agent, tab.sessionId)) {
+      if (mine) await store.release(id);
+      if (overdue) await this.fail(id, serverText("scheduledElsewhereTimeout"));
+      else this.set(id, "waiting", serverText("scheduledWaitElsewhere"));
+      return;
+    }
+    const claimed = await store.claim(id);
+    if (claimed === "orphan-writing") {
+      await this.fail(id, serverText("scheduledUncertain"));
+      await store.discardOrphan(id);
+      return;
+    }
+    if (claimed !== "mine") {
+      this.set(id, "waiting", serverText("scheduledWaitOtherInstance"));
+      return;
+    }
+    this.startDelivery(message, tab, true);
+  }
+  /** Si la CLI de la pestana esta libre: `freeNow`, o la actividad del registro. */
+  async freeNow(tab) {
+    if (this.deps.freeNow !== void 0) return this.deps.freeNow(tab);
+    const activity = this.deps.activityOf(tab.terminalId);
+    return activity === "idle" || activity === "busy" || activity === "waiting" ? activity : "unknown";
+  }
+  startDelivery(message, tab, wake) {
+    const { store } = this.deps;
+    const { id } = message;
+    this.inFlight.add(id);
+    this.inFlightTabs.set(id, tab.terminalId);
+    this.runtime.delete(id);
+    this.publish();
+    void (async () => {
+      let failure = null;
+      let delivered = false;
+      let cancelled = false;
+      let stillBusy = false;
+      try {
+        await store.refresh();
+        if (store.get(id) === null) {
+          cancelled = true;
+        } else {
+          await store.setPhase(id, "writing");
+          if (wake && !await this.deps.wake(tab.terminalId)) failure = serverText("scheduledNoTab");
+          if (failure === null) {
+            const outcome = await this.deps.deliver(tab.terminalId, message.text);
+            if (outcome.kind === "busy") {
+              stillBusy = true;
+            } else {
+              failure = scheduledFailureFor(outcome);
+              delivered = failure === null;
+            }
+          }
+        }
+      } catch (error) {
+        this.deps.log?.(`[scheduled] couldn't open the CLI for ${id.slice(0, 8)}: ${error instanceof Error ? error.message : String(error)}`);
+        failure = serverText("scheduledCliOpenFailed");
+      }
+      try {
+        if (delivered) await store.remove(id);
+        else if (!cancelled && failure !== null) await store.update(id, { failure });
+      } catch (error) {
+        this.deps.log?.(`[scheduled] couldn't save what happened to ${id.slice(0, 8)}: ${error instanceof Error ? error.message : String(error)}`);
+      } finally {
+        await store.release(id).catch(() => void 0);
+        this.inFlight.delete(id);
+        this.inFlightTabs.delete(id);
+        if (!cancelled) this.cooldownUntil.set(tab.terminalId, this.deps.now() + SCHEDULED_COOLDOWN_MS);
+        this.forget(id);
+        if (stillBusy) this.set(id, "waiting", serverText("scheduledWaitBusy"));
+        this.publish();
+        this.nudge();
+      }
+    })();
+  }
+};
+
+// packages/server/src/scheduled-messages/delivery.ts
+var SCHEDULED_POLL_MS = 250;
+function normalized(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function isUserMessageWith(event2, text) {
+  if (event2.role !== "user") return false;
+  const said = normalized(event2.parts.map((part) => part.kind === "text" ? part.text : "").join(" "));
+  const sent = normalized(text);
+  if (said.length === 0 || sent.length === 0) return false;
+  const head = sent.slice(0, 200);
+  return said === sent || said.includes(head) || said.length >= 40 && sent.startsWith(said.slice(0, 200));
+}
+async function freenessOf(hasStatus, activity, follower, launchedAt) {
+  if (hasStatus) {
+    if (activity === "idle") return "idle";
+    if (activity === "busy") return "busy";
+    if (activity === "waiting") return "waiting";
+    return "unknown";
+  }
+  if (follower === null || launchedAt === null) return "unknown";
+  await follower.poll().catch(() => null);
+  if (follower.hasOpenTurn?.(launchedAt) === true || follower.hasOpenToolCall(launchedAt)) return "busy";
+  return "idle";
+}
+async function deliverScheduled(deps, request) {
+  const { terminalId, text, support } = request;
+  const pollMs = request.pollMs ?? SCHEDULED_POLL_MS;
+  const first = deps.tab(terminalId);
+  if (first === null) return { kind: "gone" };
+  if (!first.alive || first.sessionId.length === 0) return { kind: "not-ready" };
+  const target = { cwd: first.cwd, sessionId: first.sessionId };
+  const follower = deps.follow(target);
+  await follower.start();
+  await follower.poll().catch(() => null);
+  const screen = support.kind === "screen" ? deps.screen(terminalId) : null;
+  if (support.kind === "screen" && screen === null) return { kind: "not-ready" };
+  try {
+    const deadline = deps.now() + request.readyTimeoutMs;
+    let previous = null;
+    let last = "unknown";
+    for (; ; ) {
+      const tab = deps.tab(terminalId);
+      if (tab === null) return { kind: "gone" };
+      if (!tab.alive || tab.sessionId !== target.sessionId) return { kind: "not-ready" };
+      last = await freenessOf(request.hasStatus, deps.activityOf(terminalId), follower, tab.launchedAt);
+      if (last === "idle") {
+        if (screen === null) break;
+        const lines = await screen.lines();
+        const key = lines.join("\n");
+        if (support.kind === "screen" && support.readyScreen(lines)) {
+          if (key === previous) break;
+          previous = key;
+        } else {
+          previous = null;
+        }
+      } else {
+        previous = null;
+      }
+      if (deps.now() >= deadline) return last === "busy" || last === "waiting" ? { kind: "busy" } : { kind: "not-ready" };
+      await deps.wait(pollMs);
+    }
+  } finally {
+    screen?.dispose();
+  }
+  const writtenAt = deps.now();
+  if (support.kind === "api") {
+    const outcome = await support.deliver(target, text).catch(() => "failed");
+    if (outcome === "not-sent") return { kind: "not-ready" };
+  } else {
+    const result = await deps.submit(terminalId, text);
+    switch (result.kind) {
+      case "written":
+        break;
+      case "refusal":
+      case "prepare-failed":
+      case "dropped":
+        return { kind: "not-ready" };
+      case "nothing":
+        return { kind: "nothing" };
+      case "refused":
+        return { kind: "refused" };
+      case "blocked":
+      case "interrupted":
+      case "failed":
+        return { kind: "interrupted" };
+    }
+  }
+  const confirmDeadline = deps.now() + support.confirmTimeoutMs;
+  for (; ; ) {
+    const read2 = await follower.poll().catch(() => null);
+    if (read2 !== null && read2.added.some((event2) => (event2.at === 0 || event2.at >= writtenAt - 5e3) && isUserMessageWith(event2, text))) {
+      return { kind: "sent" };
+    }
+    if (request.hasStatus && deps.activityOf(terminalId) === "busy") return { kind: "sent" };
+    if (deps.now() >= confirmDeadline) return { kind: "unconfirmed" };
+    await deps.wait(pollMs);
+  }
+}
+
 // packages/server/src/terminal-socket.ts
 var NOTE_SEND_TIMEOUT_MS = 15e3;
 var REWIND_EXTRA_STEPS = 30;
@@ -27593,7 +28909,8 @@ function attachTerminalSocket(options) {
     defaultCwd,
     vault,
     remote,
-    worktrees
+    worktrees,
+    scheduled
   } = options;
   const pasteStore = options.pasteStore ?? new PasteStore();
   const writeQueue = new TerminalWriteQueue();
@@ -27658,12 +28975,12 @@ function attachTerminalSocket(options) {
     agents: agents.list(),
     defaultAgent: agents.defaultAgent()
   });
-  const writeToTerminal = (socket, terminalId, data) => {
+  const writeToTerminal = (socket, terminalId, data, refusedAs) => {
     if (registry.write(terminalId, data)) return true;
     if (registry.get(terminalId) === null) {
-      sendError(socket, "unknown-terminal", serverText("terminalGone"));
+      sendError(socket, refusedAs ?? "unknown-terminal", serverText("terminalGone"));
     } else {
-      sendError(socket, "terminal-asleep", serverText("terminalAsleep"));
+      sendError(socket, refusedAs ?? "terminal-asleep", serverText("terminalAsleep"));
     }
     return false;
   };
@@ -27676,6 +28993,13 @@ function attachTerminalSocket(options) {
     for (const { from, to } of moved) drafts.move(from, to);
     const entries = draftEntriesOf(appeared, drafts).filter((entry) => !isEmptyComposerDraft(entry.draft));
     if (entries.length > 0) broadcast({ type: "composer.drafts", drafts: entries });
+    for (const { from, to } of moved) {
+      void scheduler.moveOwner(from, to).catch((error) => {
+        console.warn("[scheduled] couldn't move the messages of a tab:", error);
+      });
+    }
+    scheduler.publish();
+    scheduler.nudge();
   };
   const onRegistryExit = (terminalId, exitCode, signal) => broadcast({ type: "terminal.exit", terminalId, exitCode, signal });
   const onRegistryActivity = (terminalId, activity, offlineReason) => {
@@ -27684,6 +29008,7 @@ function attachTerminalSocket(options) {
       offlineReason === null ? { type: "terminal.activity", terminalId, activity } : { type: "terminal.activity", terminalId, activity, offlineReason }
     );
     if (registry.get(terminalId)?.review === true) worktrees.reviewActivity();
+    scheduler.nudge();
   };
   const onIndexStatus = (status) => broadcast({ type: "index.status", status });
   const onIndexProjects = (projects, replace) => broadcast({ type: "index.projects", projects, replace });
@@ -27719,7 +29044,7 @@ function attachTerminalSocket(options) {
   const onConversationState = (terminalId, state) => broadcast({ type: "conversation.state", terminalId, state });
   const onConversationMode = (terminalId, mode) => broadcast({ type: "conversation.mode", terminalId, mode });
   const onConversationWaiting = (terminalId, waitingFor) => broadcast({ type: "conversation.waiting", terminalId, waitingFor });
-  const onConversationToolCall = (terminalId, open9) => broadcast({ type: "conversation.toolCall", terminalId, open: open9 });
+  const onConversationToolCall = (terminalId, open10) => broadcast({ type: "conversation.toolCall", terminalId, open: open10 });
   const onConversationSubagents = (terminalId, subagents) => broadcast({ type: "conversation.subagents", terminalId, subagents });
   const onConversationLiveQuestion = (terminalId, question) => broadcast({ type: "conversation.liveQuestion", terminalId, question });
   const onConversationQueue = (terminalId, queue) => broadcast({ type: "conversation.queue", terminalId, queue });
@@ -27733,6 +29058,7 @@ function attachTerminalSocket(options) {
     return await adapter.defaults(descriptor.cwd, sessionModel) ?? NO_DEFAULTS;
   };
   const pieceWriter = (socket, terminalId) => (piece) => writeToTerminal(socket, terminalId, piece);
+  const answerWriter = (socket, terminalId) => (piece) => writeToTerminal(socket, terminalId, piece, "answer-failed");
   const interruptAgent = (socket, terminalId, options2) => {
     writeQueue.interrupt(terminalId);
     const [first, ...rest] = buildInterruptKeys(inputOf(terminalId).interruptPresses);
@@ -27807,6 +29133,12 @@ function attachTerminalSocket(options) {
     const draftOwner = draftOwnerOf(registry.get(terminalId));
     if (!registry.close(terminalId)) return false;
     if (draftOwner !== null) drafts.delete(draftOwner);
+    turnProbes.delete(terminalId);
+    if (draftOwner !== null) {
+      void scheduler.dropOwner(draftOwner).catch((error) => {
+        console.warn("[scheduled] couldn't cancel the messages of a closed tab:", error);
+      });
+    }
     conversations.drop(terminalId);
     repos.drop(terminalId);
     memory.drop(terminalId);
@@ -27828,6 +29160,111 @@ function attachTerminalSocket(options) {
     noteSubmitted: (terminalId, text) => registry.noteSubmitted(terminalId, text),
     enqueue: (terminalId, job, enqueueOptions) => writeQueue.enqueue(terminalId, job, enqueueOptions)
   };
+  const submitDeps = {
+    adapterOf,
+    inputOf,
+    launchedAtOf: (terminalId) => registry.launchedAtOf(terminalId),
+    activityOf: (terminalId) => registry.activityOf(terminalId),
+    sessionIdOf: (terminalId) => registry.get(terminalId)?.sessionId ?? null,
+    watchScreen: (terminalId) => registry.watchScreen(terminalId),
+    noteSubmitted: (terminalId, text) => registry.noteSubmitted(terminalId, text),
+    conversations,
+    queuedSubmits,
+    enqueue: (terminalId, job, enqueueOptions) => writeQueue.enqueue(terminalId, job, enqueueOptions),
+    now: Date.now
+  };
+  const turnProbes = /* @__PURE__ */ new Map();
+  const probeFor = (terminalId, follow, sessionId) => {
+    const known = turnProbes.get(terminalId);
+    if (known !== void 0 && known.sessionId === sessionId) return known;
+    const follower = follow();
+    const probe = { sessionId, follower, started: follower.start() };
+    turnProbes.set(terminalId, probe);
+    return probe;
+  };
+  const scheduledDeliveryDeps = (follow) => ({
+    tab: (terminalId) => {
+      const tab = registry.get(terminalId);
+      if (tab === null) return null;
+      return { alive: tab.alive, sessionId: tab.sessionId, cwd: tab.cwd, launchedAt: registry.launchedAtOf(terminalId) };
+    },
+    activityOf: (terminalId) => registry.activityOf(terminalId),
+    screen: (terminalId) => registry.watchScreen(terminalId),
+    // El camino del cuadro, con sus guardas, solo texto.
+    submit: async (terminalId, text) => {
+      const plan = prepareSubmit(submitDeps, terminalId);
+      if ("refusal" in plan) return { kind: "refusal" };
+      return runSubmit(submitDeps, plan, {
+        text,
+        imageCount: 0,
+        send: true,
+        prepare: () => Promise.resolve({ fullText: text, imagePaths: [] }),
+        write: (piece) => registry.write(terminalId, piece)
+      });
+    },
+    follow,
+    now: Date.now,
+    wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+  });
+  const scheduler = new MessageScheduler({
+    store: scheduled,
+    now: Date.now,
+    enabled: () => appSettings.scheduledMessagesEnabled(),
+    refreshEnabled: () => appSettings.refreshScheduledMessages(),
+    tabs: () => registry.list().flatMap(
+      (tab) => tab.kind === "agent" && tab.agent !== null && tab.sessionId.length > 0 ? [{ terminalId: tab.terminalId, agent: tab.agent, sessionId: tab.sessionId, alive: tab.alive }] : []
+    ),
+    activityOf: (terminalId) => registry.activityOf(terminalId),
+    freeNow: async (tab) => {
+      const adapter = agents.get(tab.agent)?.adapter ?? null;
+      if (adapter === null) return "unknown";
+      if (adapter.status !== null) {
+        const activity = registry.activityOf(tab.terminalId);
+        return activity === "idle" || activity === "busy" || activity === "waiting" ? activity : "unknown";
+      }
+      const tabNow = registry.get(tab.terminalId);
+      if (tabNow === null) return "unknown";
+      const probe = probeFor(tab.terminalId, () => adapter.history.follow({ cwd: tabNow.cwd, sessionId: tab.sessionId }), tab.sessionId);
+      await probe.started;
+      return freenessOf(false, null, probe.follower, registry.launchedAtOf(tab.terminalId));
+    },
+    othersRunning: () => options.instances?.othersRunning() ?? Promise.resolve(false),
+    tellsOpenElsewhere: (agent) => agents.get(agent)?.adapter.status?.isOpen !== void 0,
+    agentOf: (agent) => {
+      const registered = agents.get(agent);
+      if (registered === null) return null;
+      return {
+        label: registered.adapter.label,
+        scheduledSend: registered.adapter.capabilities.scheduledSend && registered.location !== null
+      };
+    },
+    isOpenElsewhere: async (agent, sessionId) => await agents.get(agent)?.adapter.status?.isOpen?.(sessionId) === true,
+    wake: async (terminalId) => await registry.wake(terminalId) !== null,
+    deliver: (terminalId, text) => {
+      const adapter = adapterOf(terminalId);
+      if (adapter?.scheduled !== void 0) {
+        const follow = (target) => adapter.history.follow(target);
+        return deliverScheduled(scheduledDeliveryDeps(follow), {
+          terminalId,
+          text,
+          support: adapter.scheduled,
+          hasStatus: adapter.status !== null,
+          readyTimeoutMs: SCHEDULED_DELIVERY_TIMEOUT_MS
+        });
+      }
+      return deliverWhenReady(deliverDeps, {
+        terminalId,
+        text,
+        images: [],
+        timeoutMs: SCHEDULED_DELIVERY_TIMEOUT_MS,
+        write: (piece) => registry.write(terminalId, piece)
+      });
+    },
+    onChange: (messages) => broadcast({ type: "schedule.list", messages }),
+    log: (line) => console.warn(line)
+  });
+  const startScheduler = () => scheduler.start();
+  void options.restored.then(startScheduler, startScheduler);
   const continueDeps = {
     registry,
     closeTab: (terminalId) => {
@@ -27896,7 +29333,11 @@ function attachTerminalSocket(options) {
   const stopRemoteStatus = remote.onChange(
     () => broadcastToHost({ type: "remote.status", status: remote.status() })
   );
-  const onAppSettingsStatus = (settings2) => broadcast({ type: "settings.status", settings: settings2 });
+  const onAppSettingsStatus = (settings2) => {
+    broadcast({ type: "settings.status", settings: settings2 });
+    scheduler.publish();
+    scheduler.nudge();
+  };
   appSettings.on("status", onAppSettingsStatus);
   const stopRemoteRevoked = remote.onRevoked((deviceId) => {
     for (const [socket, id] of remoteSockets) {
@@ -28024,6 +29465,7 @@ function attachTerminalSocket(options) {
     send(socket, { type: "index.projects", projects: index.getProjects(), replace: true });
     send(socket, { type: "notes.list", notes: notes.list() });
     send(socket, { type: "composer.drafts", drafts: draftEntriesOf(registry.list(), drafts) });
+    send(socket, { type: "schedule.list", messages: scheduler.snapshot() });
     send(socket, { type: "vault.status", status: vault.status() });
     if (deviceId === null) send(socket, { type: "remote.status", status: remote.status() });
     send(socket, { type: "settings.status", settings: appSettings.status() });
@@ -28105,58 +29547,19 @@ function attachTerminalSocket(options) {
             break;
           }
           const submitting = adapterOf(terminalId);
-          const isBlind = () => submitting !== null && conversations.isBlindToApprovals(terminalId, submitting);
-          const guardsPending = submitting?.capabilities.permissionCycle?.approvesPendingOnCycle === true;
-          const blocksWhileWaiting = submitting?.capabilities.waitingBlocksSubmit === true;
-          if (submitting !== null) {
-            const launchedAt = registry.launchedAtOf(terminalId);
-            const blind = isBlind();
-            const refusal2 = submitRefusal({
-              label: submitting.label,
-              approvesPendingOnCycle: guardsPending,
-              waitingFor: conversations.getWaitingFor(terminalId),
-              waitingBlocksSubmit: blocksWhileWaiting,
-              activity: registry.activityOf(terminalId),
-              blind,
-              openToolCall: blind && launchedAt !== null && conversations.hasOpenToolCall(terminalId, launchedAt)
-            });
-            if (refusal2 !== null) {
-              sendError(socket, "submit-failed", refusal2);
-              settle(false);
-              break;
-            }
+          const plan = prepareSubmit(submitDeps, terminalId);
+          if ("refusal" in plan) {
+            sendError(socket, "submit-failed", plan.refusal);
+            settle(false);
+            break;
           }
-          const approvalGuard = submitting !== null && (guardsPending || blocksWhileWaiting || isBlind()) ? async () => {
-            const current = registry.launchedAtOf(terminalId);
-            if (current === null) return true;
-            if (blocksWhileWaiting && registry.activityOf(terminalId) === "waiting") return false;
-            if (isBlind() && await conversations.checkOpenToolCall(terminalId, current)) return false;
-            return !guardsPending || await conversations.checkWaitingFor(terminalId) === null;
-          } : void 0;
-          const input = inputOf(terminalId);
-          const startupDialog = input.startupDialog;
-          const firstMessage = startupDialog !== void 0 && (registry.get(terminalId)?.sessionId ?? "") === "";
-          let startupChecked = false;
-          let stoppedByDialog = false;
-          const pieceGuard = firstMessage || approvalGuard !== void 0 ? async () => {
-            if (firstMessage && startupDialog !== void 0 && !startupChecked) {
-              startupChecked = true;
-              const screen = registry.watchScreen(terminalId);
-              if (screen !== null) {
-                try {
-                  stoppedByDialog = screenShowsDialog(await screen.lines(), startupDialog);
-                } finally {
-                  screen.dispose();
-                }
-                if (stoppedByDialog) return false;
-              }
-            }
-            return approvalGuard === void 0 ? true : approvalGuard();
-          } : void 0;
-          const interrupted = () => sendError(socket, "submit-failed", serverText("submitInterrupted"));
-          void writeQueue.enqueue(
-            terminalId,
-            async (lane) => {
+          void runSubmit(submitDeps, plan, {
+            text: text2,
+            imageCount: images.length,
+            send: message.send !== false,
+            write: pieceWriter(socket, terminalId),
+            onWritten: (outcome) => settle(outcome === "written"),
+            prepare: async (input) => {
               const imagePaths = [];
               try {
                 for (const image of images) {
@@ -28171,7 +29574,7 @@ function attachTerminalSocket(options) {
                   error instanceof PasteImageError ? error.text : serverText("pasteImageFailed"),
                   detail
                 );
-                return;
+                return null;
               }
               const attachmentLines = [];
               try {
@@ -28189,55 +29592,25 @@ function attachTerminalSocket(options) {
                   error instanceof PasteFileError ? error.text : serverText("attachmentSaveFailed"),
                   detail
                 );
-                return;
+                return null;
               }
-              const fullText = textWithAttachments(text2, attachmentLines);
-              const pieces = buildSubmissionWrites(fullText, imagePaths, input, {
-                send: message.send !== false
-              });
-              if (pieces === null) return;
-              registry.noteSubmitted(terminalId, fullText);
-              const startAfterMs = submitStartDelayMs(
-                registry.launchedAtOf(terminalId),
-                Date.now(),
-                input.readyAfterLaunchMs ?? 0
-              );
-              const outcome = await lane.writePieces(
-                pieces,
-                input.pieceGapMs,
-                pieceWriter(socket, terminalId),
-                pieceGuard,
-                { startAfterMs }
+              return { fullText: textWithAttachments(text2, attachmentLines), imagePaths };
+            }
+          }).then((result) => {
+            if (result.kind === "dropped" || result.kind === "interrupted") {
+              sendError(socket, "submit-failed", serverText("submitInterrupted"));
+            }
+            if (result.kind === "blocked" && result.byDialog) {
+              sendError(socket, "submit-failed", serverText("submitStartupDialog", { label: submitting?.label ?? "" }));
+              if (clearsDraft) send(socket, { type: "composer.prefill", terminalId, text: text2, reason: "not-ready" });
+            } else if (result.kind === "blocked") {
+              sendError(
+                socket,
+                "submit-failed",
+                result.waitingNow ? submitting === null ? serverText("submitStoppedWaitingNoLabel") : serverText("submitStoppedWaiting", { label: submitting.label }) : submitting === null ? serverText("submitStoppedToolNoLabel") : serverText("submitStoppedTool", { label: submitting.label })
               );
-              settle(outcome === "written");
-              if (outcome === "written" && message.send !== false && submitting?.promptQueue?.source === "app" && registry.activityOf(terminalId) === "busy" && !text2.trimStart().startsWith("/")) {
-                conversations.noteQueued(terminalId, { text: text2, images: images.length, at: Date.now() });
-              }
-              if (outcome === "written" && message.send !== false && submitting?.queuedSubmits !== void 0) {
-                queuedSubmits.note(
-                  terminalId,
-                  submissionPayload(fullText, imagePaths, input.imageReference) ?? fullText,
-                  Date.now(),
-                  fullText
-                );
-              }
-              if (outcome === "interrupted") interrupted();
-              if (outcome === "blocked" && stoppedByDialog) {
-                sendError(socket, "submit-failed", serverText("submitStartupDialog", { label: submitting?.label ?? "" }));
-                if (clearsDraft) send(socket, { type: "composer.prefill", terminalId, text: text2, reason: "not-ready" });
-                return;
-              }
-              if (outcome === "blocked") {
-                const waitingNow = blocksWhileWaiting && registry.activityOf(terminalId) === "waiting";
-                sendError(
-                  socket,
-                  "submit-failed",
-                  waitingNow ? submitting === null ? serverText("submitStoppedWaitingNoLabel") : serverText("submitStoppedWaiting", { label: submitting.label }) : submitting === null ? serverText("submitStoppedToolNoLabel") : serverText("submitStoppedTool", { label: submitting.label })
-                );
-              }
-            },
-            { onDropped: interrupted }
-          ).then(() => settle(false));
+            }
+          }).finally(() => settle(false));
           break;
         }
         /*
@@ -28311,7 +29684,7 @@ function attachTerminalSocket(options) {
                   sendError(socket, "answer-failed", check === "gone" ? ANSWER_NOT_PENDING_TEXT : ANSWER_MENU_CHANGED_TEXT);
                   return;
                 }
-                const outcome = await lane.writePieces(keys, ANSWER_KEY_INTERVAL_MS, pieceWriter(socket, message.terminalId));
+                const outcome = await lane.writePieces(keys, ANSWER_KEY_INTERVAL_MS, answerWriter(socket, message.terminalId));
                 if (outcome === "interrupted") interruptedAnswer();
               },
               { onDropped: interruptedAnswer }
@@ -28343,7 +29716,7 @@ function attachTerminalSocket(options) {
               const outcome = await lane.writePieces(
                 keys,
                 ANSWER_KEY_INTERVAL_MS,
-                pieceWriter(socket, message.terminalId)
+                answerWriter(socket, message.terminalId)
               );
               if (outcome === "interrupted") interruptedAnswer();
             },
@@ -28409,10 +29782,10 @@ function attachTerminalSocket(options) {
                   nunca esconde nada.
                 */
         case "session.archive": {
-          const open9 = new Set(
+          const open10 = new Set(
             registry.list().map((terminal) => terminal.sessionId).filter((id) => id.length > 0)
           );
-          const targets = message.archived ? message.sessionIds.filter((id) => !open9.has(id)) : message.sessionIds;
+          const targets = message.archived ? message.sessionIds.filter((id) => !open10.has(id)) : message.sessionIds;
           if (archived.set(targets, message.archived)) index.refresh();
           if (message.archived && targets.length < message.sessionIds.length) {
             sendError(
@@ -29667,6 +31040,88 @@ ${seen.join("\n-----\n")}`);
           );
           break;
         }
+        /*
+          Programar lo escrito en el cuadro (hito 51, §6.39). La pestana dice de
+          que conversacion es; el servidor revisa todo antes de guardar. Si no lo
+          acepta, el texto vuelve al cuadro, que ya se habia vaciado al mandarlo.
+          Guardado, el borrador se vacia como con Enviar (§6.29).
+        */
+        case "schedule.create": {
+          const { requestId, terminalId, text: text2, sendAt } = message;
+          const giveBack = () => {
+            if (text2.trim().length > 0) send(socket, { type: "composer.prefill", terminalId, text: text2, reason: "unscheduled" });
+          };
+          const descriptor = registry.get(terminalId);
+          if (descriptor === null) {
+            sendError(socket, "unknown-terminal", serverText("terminalGone"), void 0, requestId);
+            break;
+          }
+          const owner = draftOwnerOf(descriptor);
+          const scheduling = adapterOf(terminalId);
+          const refusal2 = scheduleCreateRefusal({
+            enabled: appSettings.scheduledMessagesEnabled(),
+            owner,
+            agentLabel: scheduling?.label ?? null,
+            capable: scheduling?.capabilities.scheduledSend === true,
+            text: text2,
+            sendAt,
+            now: Date.now(),
+            count: scheduled.size
+          });
+          if (refusal2 !== null || owner === null || descriptor.agent === null) {
+            sendError(socket, "schedule-failed", refusal2 ?? serverText("scheduleNoConversation"), void 0, requestId);
+            giveBack();
+            break;
+          }
+          const agent = descriptor.agent;
+          void (async () => {
+            try {
+              const created = await scheduler.create(owner, agent, text2, sendAt);
+              drafts.delete(owner);
+              broadcast({ type: "composer.drafts", drafts: draftEntriesOf(registry.list(), drafts, owner) });
+              send(socket, { type: "schedule.created", requestId, id: created.id });
+            } catch (error) {
+              const detail = error instanceof Error ? error.message : String(error);
+              console.warn("[scheduled] couldn't save a scheduled message:", detail);
+              sendError(socket, "schedule-failed", serverText("scheduleSaveFailed"), detail, requestId);
+              giveBack();
+            }
+          })();
+          break;
+        }
+        /* Sacarlo: su texto vuelve al cuadro de su pestana, en esta ventana. */
+        case "schedule.cancel": {
+          void (async () => {
+            const outcome = await scheduler.cancel(message.id);
+            if (outcome.kind === "gone") {
+              sendError(socket, "schedule-failed", serverText("scheduleGone"));
+              return;
+            }
+            if (outcome.kind === "sending") {
+              sendError(socket, "schedule-failed", serverText("scheduleSending"));
+              return;
+            }
+            const { agent, sessionId, text: text2 } = outcome.message;
+            const tab = registry.list().find((entry) => entry.kind === "agent" && entry.agent === agent && entry.sessionId === sessionId);
+            if (tab !== void 0) send(socket, { type: "composer.prefill", terminalId: tab.terminalId, text: text2, reason: "unscheduled" });
+          })().catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            sendError(socket, "schedule-failed", serverText("scheduleSaveFailed"), detail);
+          });
+          break;
+        }
+        /* Mandarlo ya, con las reglas de siempre: si el agente trabaja, espera. */
+        case "schedule.sendNow": {
+          void scheduler.sendNow(message.id).then((outcome) => {
+            if (outcome === "off") sendError(socket, "schedule-failed", serverText("scheduleOff"));
+            else if (outcome === "gone") sendError(socket, "schedule-failed", serverText("scheduleGone"));
+            else if (outcome === "sending") sendError(socket, "schedule-failed", serverText("scheduleSending"));
+          }).catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            sendError(socket, "schedule-failed", serverText("scheduleSaveFailed"), detail);
+          });
+          break;
+        }
         /*
           Ajustes (Hito 41, §6.32). Una consola que ya no esta, o un disco que no
           deja escribir, se dicen; lo demas lo valido el parser. A una ventana
@@ -29799,14 +31254,15 @@ ${seen.join("\n-----\n")}`);
     appSettings.off("status", onAppSettingsStatus);
     stopRemoteStatus();
     stopRemoteRevoked();
+    void scheduler.stop();
     for (const client of wss.clients) client.terminate();
     wss.close();
   };
 }
 
 // packages/server/src/vault/catalog.ts
-import { open as open8, readdir as readdir22, stat as stat46 } from "node:fs/promises";
-import path73 from "node:path";
+import { open as open9, readdir as readdir24, stat as stat47 } from "node:fs/promises";
+import path75 from "node:path";
 import { createInterface as createInterface4 } from "node:readline";
 var HEADER_MAX_BYTES = 64 * 1024;
 var LOAD_CONCURRENCY = 16;
@@ -29818,7 +31274,7 @@ async function assetBytesOf(dir, agent, sessionId) {
   const folder = assetsDir(dir, agent, sessionId);
   let names;
   try {
-    names = await readdir22(folder);
+    names = await readdir24(folder);
   } catch {
     return 0;
   }
@@ -29826,7 +31282,7 @@ async function assetBytesOf(dir, agent, sessionId) {
   for (const name of names) {
     if (!VAULT_ASSET_NAME_PATTERN.test(name)) continue;
     try {
-      const info = await stat46(path73.join(folder, name));
+      const info = await stat47(path75.join(folder, name));
       if (info.isFile()) total += info.size;
     } catch {
     }
@@ -29837,7 +31293,7 @@ async function readEntry2(dir, agent, sessionId) {
   const file = sessionFile(dir, agent, sessionId);
   let sizeBytes;
   try {
-    const info = await stat46(file);
+    const info = await stat47(file);
     if (!info.isFile()) return { kind: "absent" };
     sizeBytes = info.size;
   } catch {
@@ -29894,7 +31350,7 @@ var VaultCatalog = class {
     const keys = [];
     let agentFolders = [];
     try {
-      agentFolders = await readdir22(sessionsRoot2(dir));
+      agentFolders = await readdir24(sessionsRoot2(dir));
     } catch {
       agentFolders = [];
     }
@@ -29902,7 +31358,7 @@ var VaultCatalog = class {
       if (!isSessionAgentId2(folder)) continue;
       let names;
       try {
-        names = await readdir22(agentSessionsDir(dir, folder));
+        names = await readdir24(agentSessionsDir(dir, folder));
       } catch {
         continue;
       }
@@ -29991,7 +31447,7 @@ var VaultCatalog = class {
   async *bodyLines(agent, sessionId) {
     const dir = this.dir;
     if (dir === null || !this.entries.has(keyOf3(agent, sessionId))) return;
-    const handle = await open8(sessionFile(dir, agent, sessionId), "r").catch(() => null);
+    const handle = await open9(sessionFile(dir, agent, sessionId), "r").catch(() => null);
     if (handle === null) return;
     const input = handle.createReadStream({ encoding: "utf8" });
     const lines = createInterface4({ input, crlfDelay: Number.POSITIVE_INFINITY });
@@ -30046,22 +31502,22 @@ var VaultCatalog = class {
 };
 
 // packages/server/src/worktrees/links.ts
-import { stat as stat47 } from "node:fs/promises";
-import path74 from "node:path";
+import { stat as stat48 } from "node:fs/promises";
+import path76 from "node:path";
 async function exists6(candidate) {
   try {
-    await stat47(candidate);
+    await stat48(candidate);
     return true;
   } catch {
     return false;
   }
 }
 function recordAbove(registry, cwd) {
-  let current = path74.resolve(cwd);
+  let current = path76.resolve(cwd);
   for (let depth = 0; depth < 24; depth += 1) {
     const record = registry.byPath(current);
-    if (record !== null) return { record, inner: path74.relative(current, path74.resolve(cwd)) };
-    const parent = path74.dirname(current);
+    if (record !== null) return { record, inner: path76.relative(current, path76.resolve(cwd)) };
+    const parent = path76.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -30082,7 +31538,7 @@ var WorktreeLinks = class {
       return {
         mainCwd: mainCwdFor(cwd, checkout),
         worktree: {
-          branch: checkout.branch ?? record?.branch ?? path74.basename(checkout.root),
+          branch: checkout.branch ?? record?.branch ?? path76.basename(checkout.root),
           exists: true,
           reopenable: false
         }
@@ -30092,13 +31548,13 @@ var WorktreeLinks = class {
     if (found !== null) {
       const { record, inner } = found;
       return {
-        mainCwd: inner.length === 0 ? record.mainRoot : path74.join(record.mainRoot, inner),
+        mainCwd: inner.length === 0 ? record.mainRoot : path76.join(record.mainRoot, inner),
         worktree: { branch: record.branch, exists: false, reopenable: await this.reopenable(record) }
       };
     }
-    const mainRoot = mainRootFromShape(path74.resolve(cwd));
+    const mainRoot = mainRootFromShape(path76.resolve(cwd));
     if (mainRoot === null) return null;
-    return { mainCwd: mainRoot, worktree: { branch: path74.basename(cwd), exists: false, reopenable: false } };
+    return { mainCwd: mainRoot, worktree: { branch: path76.basename(cwd), exists: false, reopenable: false } };
   }
   /**
    * Se puede volver a abrir una rama quitada si la creó la app, su carpeta no
@@ -30128,15 +31584,15 @@ var WorktreeLinks = class {
 };
 
 // packages/server/src/index.ts
-var serverDir = path75.dirname(fileURLToPath2(import.meta.url));
+var serverDir = path77.dirname(fileURLToPath2(import.meta.url));
 var isPackaged = true;
-var webRoot = isPackaged ? serverDir : path75.resolve(serverDir, "../../web");
-var webDist = isPackaged ? path75.join(serverDir, "web") : path75.join(webRoot, "dist");
-var repoRoot = path75.resolve(serverDir, "../../..");
+var webRoot = isPackaged ? serverDir : path77.resolve(serverDir, "../../web");
+var webDist = isPackaged ? path77.join(serverDir, "web") : path77.join(webRoot, "dist");
+var repoRoot = path77.resolve(serverDir, "../../..");
 var isProduction = isPackaged || process.argv.includes("--prod");
 function resolveDefaultCwd() {
   const override = process.env["AGENT_WORKBENCH_CWD"];
-  if (override !== void 0 && override.length > 0) return path75.resolve(override);
+  if (override !== void 0 && override.length > 0) return path77.resolve(override);
   if (isPackaged) return process.cwd();
   return repoRoot;
 }
@@ -30211,7 +31667,7 @@ async function mountDevUi(app, httpServer) {
 }
 var LOOKS_LIKE_FILE = /\.[a-zA-Z0-9]{1,8}$/;
 function mountBuiltUi(app) {
-  const indexHtml = path75.join(webDist, "index.html");
+  const indexHtml = path77.join(webDist, "index.html");
   if (!existsSync4(indexHtml)) {
     throw new Error(
       `There's no compiled interface in ${webDist}.
@@ -30299,11 +31755,11 @@ async function main() {
     findSession: (agent, sessionId) => index.find(agent, sessionId),
     // Hito 49: las conversaciones de una rama (para dejarle un pedido a su autor) y la respuesta del revisor.
     sessionsUnder: (folder) => {
-      const root = path75.resolve(folder);
+      const root = path77.resolve(folder);
       return index.getProjects().flatMap((project) => project.sessions).filter((session) => {
         if (session.archived || session.cwd.length === 0) return false;
-        const relative = path75.relative(root, path75.resolve(session.cwd));
-        return relative.length === 0 || !relative.startsWith("..") && !path75.isAbsolute(relative);
+        const relative = path77.relative(root, path77.resolve(session.cwd));
+        return relative.length === 0 || !relative.startsWith("..") && !path77.isAbsolute(relative);
       });
     },
     history: (agent) => agents.get(agent)?.adapter.history ?? null
@@ -30327,6 +31783,14 @@ async function main() {
   await notes.load();
   const drafts = new DraftStore();
   await drafts.load();
+  const scheduled = new ScheduledMessageStore();
+  await scheduled.load();
+  const instances = new RunningInstances();
+  await instances.register();
+  let markRestored = () => void 0;
+  const restored = new Promise((resolve) => {
+    markRestored = resolve;
+  });
   const conversations = new ConversationHub(registry, agents);
   const repos = new RepoHub(registry);
   const memory = new MemoryHub(registry);
@@ -30378,21 +31842,30 @@ async function main() {
     defaultCwd,
     vault,
     remote,
-    worktrees
+    worktrees,
+    scheduled,
+    restored,
+    instances
   });
   void pasteStore.purgeStale();
   void index.start();
   const stopWatching = watchSessions(index, conversations, agents);
   conversations.on("historyGrew", (agent, filePath) => void index.refreshPath(agent, filePath));
   if (process.env["AGENT_WORKBENCH_NO_RESTORE"] !== "1") {
-    void store.load().then((state) => {
-      drafts.retainOnly(workspaceDraftOwners(state));
+    void store.load().then(async (state) => {
+      const owners = workspaceDraftOwners(state);
+      drafts.retainOnly(owners);
+      await scheduled.retainOnly(owners).catch((error) => {
+        console.warn("[scheduled] couldn't drop the messages of closed tabs:", error);
+      });
       if (state.tabs.length === 0 && state.foreignTabs.length === 0) return;
       if (agents.anyAvailable()) {
         console.log(`Restoring ${state.tabs.length} tab(s) from the previous run...`);
       }
       return registry.restore(state);
-    });
+    }).finally(markRestored);
+  } else {
+    markRestored();
   }
   const url = `http://${LOOPBACK_HOST}:${port}/?${TOKEN_QUERY_PARAM}=${token}`;
   const remoteStatus = remote.status();
@@ -30423,6 +31896,9 @@ async function main() {
       archived.flush(),
       notes.flush(),
       drafts.flush(),
+      // Lo que esta instancia tenia reservado sin haber escrito nada lo puede tomar otra (hito 51).
+      scheduled.flush().then(() => scheduled.releaseReserved()),
+      instances.unregister(),
       remote.flush(),
       worktreeStore.flush(),
       agentsDisposed