agent-workbench 0.8.0 → 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 path73 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) {
@@ -144,20 +165,25 @@ var WORKTREE_COPY_MAX_FILES = 2e3;
 var WORKTREE_COPY_MAX_BYTES = 50 * 1024 * 1024;
 var WORKTREE_COPY_SAMPLE = 8;
 var WORKTREE_CREATE_MODES = ["new", "existing"];
+var WORKTREE_HOLDERS_MAX = 8;
 var WORKTREE_PLAN_PATHS_MAX = 20;
+var WORKTREE_UNTRACKED_MAX_FILES = 2e4;
 var WORKTREE_ROW_FILES_MAX = 8;
 var WORKTREE_CHANGES_COMMITS_MAX = 50;
 var WORKTREE_CHANGES_FILES_MAX = 2e3;
 function asCommitId(value) {
   return typeof value === "string" && /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(value) ? value : null;
 }
+function asUntrackedStamp(value) {
+  return typeof value === "string" && /^[0-9a-f]{64}$/.test(value) ? value : null;
+}
 function parseSessionWorktree(value) {
   const record = asRecord(value);
   if (record === null) return null;
   const branch = asNonEmptyString(record["branch"]);
-  const exists6 = asBoolean(record["exists"]);
-  if (branch === null || exists6 === null) return null;
-  return { branch, exists: exists6, reopenable: record["reopenable"] === true };
+  const exists7 = asBoolean(record["exists"]);
+  if (branch === null || exists7 === null) return null;
+  return { branch, exists: exists7, reopenable: record["reopenable"] === true };
 }
 function parseWorktreeSource(value) {
   const record = asRecord(value);
@@ -172,6 +198,16 @@ function parseWorktreeSource(value) {
   }
   return null;
 }
+var HOLDER_TEXT_MAX = 255;
+function parseWorktreeHolder(value) {
+  const record = asRecord(value);
+  if (record === null) return null;
+  const pid = asPositiveInt(record["pid"]);
+  const name = asNonEmptyString(record["name"]);
+  if (pid === null || name === null || name.length > HOLDER_TEXT_MAX) return null;
+  const description = asString(record["description"])?.trim() ?? "";
+  return { pid, name, description: description.length > 0 && description.length <= HOLDER_TEXT_MAX ? description : null };
+}
 
 // packages/shared/src/models.ts
 var SESSION_TITLE_SOURCES = [
@@ -226,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",
@@ -483,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";
@@ -842,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 } : {}
   };
 }
 
@@ -1285,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 };
@@ -1326,7 +1394,10 @@ function parseClientMessage(raw) {
       const requestId = asNonEmptyString(record["requestId"]);
       const worktreeId = asNonEmptyString(record["worktreeId"]);
       const discardConflicts = asBoolean(record["discardConflicts"]);
-      return requestId === null || worktreeId === null || discardConflicts === null ? null : { type: "worktree.remove", requestId, worktreeId, discardConflicts };
+      if (requestId === null || worktreeId === null || discardConflicts === null) return null;
+      const message = { type: "worktree.remove", requestId, worktreeId, discardConflicts };
+      const discardUntracked = asUntrackedStamp(record["discardUntracked"]);
+      return discardUntracked === null ? message : { ...message, discardUntracked };
     }
     case "worktree.reopen": {
       const requestId = asNonEmptyString(record["requestId"]);
@@ -1364,8 +1435,8 @@ function parseClientMessage(raw) {
     case "worktree.changesDiff": {
       const requestId = asNonEmptyString(record["requestId"]);
       const worktreeId = asNonEmptyString(record["worktreeId"]);
-      const path74 = asNonEmptyString(record["path"]);
-      return requestId === null || worktreeId === null || path74 === null ? null : { type: "worktree.changesDiff", requestId, worktreeId, path: path74 };
+      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"]);
@@ -1503,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");
 }
@@ -2952,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
@@ -3222,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();
@@ -4050,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;
@@ -4634,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
@@ -4645,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,
@@ -4840,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(),
     /**
@@ -5069,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";
@@ -5109,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;
@@ -5158,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();
@@ -5196,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);
     }
@@ -5878,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;
@@ -5962,18 +6111,18 @@ var BranchTracker = class {
   }
   /** La linea y todas las de las que cuelga. */
   pathFrom(leaf) {
-    const path74 = /* @__PURE__ */ new Set();
+    const path78 = /* @__PURE__ */ new Set();
     let current = leaf;
-    while (current !== null && !path74.has(current)) {
+    while (current !== null && !path78.has(current)) {
       const node = this.nodes.get(current);
       if (node === void 0) break;
-      path74.add(current);
+      path78.add(current);
       current = node.parent;
     }
-    return path74;
+    return path78;
   }
   recompute() {
-    const path74 = 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;
@@ -5982,9 +6131,9 @@ var BranchTracker = class {
       else list.push(uuid);
     }
     const roots = [];
-    for (const uuid of children.get(null) ?? []) if (!path74.has(uuid)) roots.push(uuid);
-    for (const uuid of path74) {
-      for (const child of children.get(uuid) ?? []) if (!path74.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) {
@@ -8001,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
@@ -8034,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()
   };
 }
@@ -8654,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);
       }
     };
@@ -9071,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;
@@ -9096,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;
@@ -9178,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;
@@ -9199,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;
@@ -9432,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();
   }
@@ -9579,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";
@@ -9614,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
@@ -9700,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),
     /**
@@ -10361,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"] },
@@ -11228,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
@@ -12268,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/";
@@ -12318,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
@@ -12443,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:
@@ -13068,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);
 }
@@ -14068,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";
@@ -14190,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;
@@ -14362,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" }
 };
@@ -14471,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,
@@ -15196,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;
@@ -15290,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
@@ -15741,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
@@ -15774,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) {
@@ -15783,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;
@@ -18081,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;
     }
@@ -19299,8 +19610,8 @@ function buildContinuationMessage(input) {
   }
   return sanitizeForPaste(lines.join("\n"));
 }
-function transcriptReferenceFor(path74, style) {
-  return style === "at-quoted" ? fileReference(path74, "at-quoted") : `"${path74}"`;
+function transcriptReferenceFor(path78, style) {
+  return style === "at-quoted" ? fileReference(path78, "at-quoted") : `"${path78}"`;
 }
 function planTranscript(input) {
   const turns = splitTurns(input.events);
@@ -20241,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) {
@@ -20263,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;
@@ -20286,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 {
@@ -20342,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 {
@@ -20363,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;
@@ -20383,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) {
@@ -20942,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);
@@ -20963,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));
@@ -21008,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"]]) {
@@ -21057,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)) {
@@ -21068,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);
@@ -21080,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;
   }
@@ -21145,9 +21833,9 @@ function watchSessions(index, hub, agents, options = {}) {
     const probe = setInterval(() => {
       if (checking) return;
       checking = true;
-      void isDirectory3(root.path).then((exists6) => {
+      void isDirectory3(root.path).then((exists7) => {
         checking = false;
-        if (!exists6 || stopped || !probes.has(probe)) return;
+        if (!exists7 || stopped || !probes.has(probe)) return;
         clearInterval(probe);
         probes.delete(probe);
         watchRoot(agent, root, true);
@@ -21162,9 +21850,9 @@ function watchSessions(index, hub, agents, options = {}) {
         subscribeRoot(adapter.id, root, root.watch);
         continue;
       }
-      void isDirectory3(root.path).then((exists6) => {
+      void isDirectory3(root.path).then((exists7) => {
         if (stopped) return;
-        if (exists6) watchRoot(adapter.id, root, false);
+        if (exists7) watchRoot(adapter.id, root, false);
         else probeRoot(adapter.id, root);
       });
     }
@@ -21189,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 {
@@ -21490,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) {
@@ -21556,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 = [];
@@ -21594,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) {
@@ -21618,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();
@@ -21648,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) {
@@ -21919,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 }));
     }
@@ -22377,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;
@@ -22411,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;
@@ -22463,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"));
     }
@@ -22510,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(
@@ -22546,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 {
@@ -22559,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
     };
   }
@@ -22619,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);
@@ -22631,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 {
@@ -22654,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;
@@ -22718,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) {
@@ -22755,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 {
@@ -22781,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 = [];
@@ -22789,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,
@@ -22806,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(),
@@ -22821,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;
@@ -22883,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 {
@@ -22915,16 +23603,19 @@ async function searchFiles(cwd, query, folders, options = {}) {
     truncated: truncated || found.length > SEARCH_MAX_RESULTS
   };
 }
-async function existingFiles(cwd, relativePaths, folders) {
-  const existing = [];
+async function existingPaths(cwd, relativePaths, folders) {
+  const files = [];
+  const directories = [];
   for (const relativePath of relativePaths) {
     try {
       const absolute = await resolveForFiles(cwd, relativePath, folders);
-      if ((await stat37(absolute)).isFile()) existing.push(relativePath);
+      const info = await stat38(absolute);
+      if (info.isFile()) files.push(relativePath);
+      else if (info.isDirectory()) directories.push(relativePath);
     } catch {
     }
   }
-  return existing;
+  return { files, directories };
 }
 function contentHash(content) {
   return createHash4("sha256").update(content).digest("hex");
@@ -22934,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,
@@ -22965,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) {
@@ -22990,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) };
   }
@@ -23302,6 +23993,109 @@ function prefillReasonFor(outcome) {
   }
 }
 
+// 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;
@@ -23664,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) {
@@ -23682,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) {
@@ -23704,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;
 }
@@ -23738,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);
   }
 }
 
@@ -23844,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";
@@ -23864,7 +24658,7 @@ async function listMemoryNotes(cwd) {
   }
   let entries;
   try {
-    entries = await readdir17(folder, { withFileTypes: true });
+    entries = await readdir19(folder, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -23874,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 {
@@ -23888,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;
@@ -23896,7 +24690,7 @@ async function isUpToDate(target, note) {
 }
 async function exists3(file) {
   try {
-    await stat40(file);
+    await stat41(file);
     return true;
   } catch {
     return false;
@@ -23912,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;
     }
@@ -23931,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() })}
@@ -24425,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;
@@ -24525,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 {
         }
       }
@@ -24735,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
         );
@@ -24776,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
     );
@@ -24800,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;
@@ -24887,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;
@@ -24904,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),
@@ -24915,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 };
   }
@@ -25055,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 { mkdir as mkdir22, rename as rename7, rm as rm9, rmdir, stat as stat44 } from "node:fs/promises";
-import path70 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 } 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;
@@ -25073,7 +25867,7 @@ function run(cwd, args, options) {
   return new Promise((resolve, reject) => {
     const child = execFile6(
       "git",
-      ["-c", "core.quotepath=false", ...options.write ? [] : ["--no-optional-locks"], ...args],
+      ["-c", "core.quotepath=false", "-c", "core.longpaths=true", ...options.write ? [] : ["--no-optional-locks"], ...args],
       {
         cwd,
         timeout: options.write ? WRITE_TIMEOUT_MS : READ_TIMEOUT_MS,
@@ -25108,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"]);
@@ -25126,15 +25920,42 @@ async function localBranches(cwd) {
   return result.stdout.split(/\r?\n/).map((line) => branchOfRef(line.trim())).filter((branch) => branch !== null);
 }
 async function listWorktrees(cwd) {
+  return await readWorktreeList(cwd) ?? [];
+}
+async function readWorktreeList(cwd) {
   const result = await read(cwd, ["worktree", "list", "--porcelain", "-z"]);
-  return result.code === 0 ? parseWorktreeListZ(result.stdout) : [];
+  return result.code === 0 ? parseWorktreeListZ(result.stdout) : null;
 }
-async function uncommittedPaths(cwd) {
+async function uncommittedChanges(cwd) {
   const result = await read(cwd, ["status", "--porcelain=v2", "-z", "--untracked-files=normal"]);
   if (result.code !== 0) return null;
+  const parsed = parsePorcelainV2(result.stdout);
   const seen = /* @__PURE__ */ new Set();
-  for (const change of parsePorcelainV2(result.stdout).changes) seen.add(change.path);
-  return [...seen];
+  const untracked = [];
+  for (const change of parsed.changes) {
+    seen.add(change.path);
+    if (change.kind === "untracked") untracked.push(change.path);
+  }
+  return { paths: [...seen], untracked, complete: !parsed.truncated };
+}
+async function uncommittedPaths(cwd) {
+  return (await uncommittedChanges(cwd))?.paths ?? null;
+}
+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(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(path67.join(cwd, submodule, ".git"))) return true;
+  }
+  return false;
+}
+async function isDirectory4(candidate) {
+  return (await stat44(candidate).catch(() => null))?.isDirectory() === true;
+}
+async function exists4(candidate) {
+  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}`]);
@@ -25282,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" ? ";" : ":";
@@ -25292,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(
@@ -25303,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) {
@@ -25342,10 +26163,247 @@ function fastForward(baseFolder, target) {
   return run(baseFolder, fastForwardArgs(target), { write: true });
 }
 
+// packages/server/src/worktrees/holders.ts
+import { spawn as spawn4 } from "node:child_process";
+import path68 from "node:path";
+var SCAN_MAX_ENTRIES = 2e5;
+var SCAN_MAX_MS = 4e3;
+var HOLDERS_TIMEOUT_MS = 15e3;
+var OUTPUT_MAX_CHARS = 256 * 1024;
+var CSHARP = String.raw`
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using Microsoft.Win32.SafeHandles;
+
+public static class AwFolderHolders {
+  [StructLayout(LayoutKind.Sequential)]
+  struct IoStatus { public IntPtr Status; public IntPtr Information; }
+
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  struct FindData {
+    public uint Attributes;
+    public uint Created1, Created2, Accessed1, Accessed2, Written1, Written2;
+    public uint SizeHigh, SizeLow, Reserved0, Reserved1;
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] public string Name;
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] public string ShortName;
+  }
+
+  [DllImport("ntdll.dll")]
+  static extern int NtQueryInformationFile(SafeFileHandle file, out IoStatus status, IntPtr buffer, int length, int infoClass);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern SafeFileHandle CreateFileW(string name, uint access, uint share, IntPtr security, uint disposition, uint flags, IntPtr template);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern IntPtr FindFirstFileExW(string name, int level, out FindData data, int search, IntPtr filter, int flags);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern bool FindNextFileW(IntPtr find, out FindData data);
+  [DllImport("kernel32.dll")]
+  static extern bool FindClose(IntPtr find);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern bool QueryFullProcessImageNameW(IntPtr process, int flags, StringBuilder name, ref int size);
+  [DllImport("kernel32.dll")]
+  static extern bool CloseHandle(IntPtr handle);
+
+  const uint ReadData = 0x1, ReadAttributes = 0x80, Delete = 0x10000, ShareAll = 7, OpenExisting = 3;
+  /* BACKUP_SEMANTICS abre carpetas; OPEN_REPARSE_POINT abre el enlace y no su destino. */
+  const uint OpenFlags = 0x02000000 | 0x00200000;
+  const int ProcessIdsUsingFile = 47, QueryLimited = 0x1000, MaxNamed = 32;
+  static readonly IntPtr NoFind = new IntPtr(-1);
+
+  static bool Taken(string path, bool top) {
+    using (SafeFileHandle file = CreateFileW(path, top ? Delete : ReadData, top ? ShareAll : 0, IntPtr.Zero, OpenExisting, OpenFlags, IntPtr.Zero)) {
+      if (!file.IsInvalid) return false;
+      int error = Marshal.GetLastWin32Error();
+      return error != 2 && error != 3;
+    }
+  }
+
+  static void Collect(string path, HashSet<int> seen, List<int> found, int self) {
+    using (SafeFileHandle file = CreateFileW(path, ReadAttributes, ShareAll, IntPtr.Zero, OpenExisting, OpenFlags, IntPtr.Zero)) {
+      if (file.IsInvalid) return;
+      for (int size = 4096; size <= 1 << 20; size *= 4) {
+        IntPtr buffer = Marshal.AllocHGlobal(size);
+        try {
+          IoStatus status;
+          int code = NtQueryInformationFile(file, out status, buffer, size, ProcessIdsUsingFile);
+          if (code == unchecked((int)0xC0000004) || code == unchecked((int)0x80000005)) continue;
+          if (code != 0) return;
+          int count = Marshal.ReadInt32(buffer);
+          if (IntPtr.Size * (count + 1) > size) continue;
+          for (int i = 0; i < count; i++) {
+            int pid = (int)Marshal.ReadIntPtr(buffer, IntPtr.Size * (i + 1)).ToInt64();
+            if (pid != self && seen.Add(pid)) found.Add(pid);
+          }
+          return;
+        } finally { Marshal.FreeHGlobal(buffer); }
+      }
+    }
+  }
+
+  static string Json(string value) {
+    if (value == null) return "null";
+    StringBuilder text = new StringBuilder("\"");
+    foreach (char c in value) {
+      if (c == '"' || c == '\\') text.Append('\\').Append(c);
+      else if (c < 0x20 || c > 0x7E) text.Append("\\u").Append(((int)c).ToString("x4"));
+      else text.Append(c);
+    }
+    return text.Append('"').ToString();
+  }
+
+  public static string Scan(string root, int maxEntries, int maxMs) {
+    Stopwatch clock = Stopwatch.StartNew();
+    int self = Process.GetCurrentProcess().Id;
+    HashSet<int> seen = new HashSet<int>();
+    List<int> found = new List<int>();
+    List<string> files = new List<string>();
+    Queue<string> dirs = new Queue<string>();
+    bool complete = true;
+    int entries = 0;
+    if (Taken(root, true)) Collect(root, seen, found, self);
+    dirs.Enqueue(root);
+    while (dirs.Count > 0) {
+      if (++entries > maxEntries || clock.ElapsedMilliseconds > maxMs) { complete = false; break; }
+      string dir = dirs.Dequeue();
+      if (dir != root && Taken(dir, false)) Collect(dir, seen, found, self);
+      FindData data;
+      IntPtr find = FindFirstFileExW(dir + "\\*", 1, out data, 0, IntPtr.Zero, 2);
+      if (find == NoFind) continue;
+      try {
+        do {
+          if (data.Name == "." || data.Name == "..") continue;
+          string child = dir + "\\" + data.Name;
+          if ((data.Attributes & 0x10) != 0 && (data.Attributes & 0x400) == 0) dirs.Enqueue(child);
+          else if (files.Count < maxEntries) files.Add(child);
+        } while (FindNextFileW(find, out data));
+      } finally { FindClose(find); }
+    }
+    if (complete) {
+      foreach (string file in files) {
+        if (++entries > maxEntries || clock.ElapsedMilliseconds > maxMs) { complete = false; break; }
+        if (Taken(file, false)) Collect(file, seen, found, self);
+      }
+    }
+    StringBuilder json = new StringBuilder("{\"complete\":");
+    json.Append(complete ? "true" : "false").Append(",\"ms\":").Append(clock.ElapsedMilliseconds).Append(",\"holders\":[");
+    int named = 0;
+    foreach (int pid in found) {
+      if (named >= MaxNamed) break;
+      string name = null, description = null;
+      IntPtr process = OpenProcess(QueryLimited, false, pid);
+      if (process != IntPtr.Zero) {
+        try {
+          StringBuilder image = new StringBuilder(32768);
+          int length = image.Capacity;
+          if (QueryFullProcessImageNameW(process, 0, image, ref length)) {
+            string full = image.ToString(0, length);
+            name = Path.GetFileName(full);
+            try { description = FileVersionInfo.GetVersionInfo(full).FileDescription; } catch { }
+          }
+        } finally { CloseHandle(process); }
+      }
+      if (name == null) {
+        try { name = pid == 4 ? "System" : Process.GetProcessById(pid).ProcessName + ".exe"; } catch { continue; }
+      }
+      json.Append(named++ == 0 ? "" : ",").Append("{\"pid\":").Append(pid).Append(",\"name\":").Append(Json(name))
+        .Append(",\"description\":").Append(Json(description)).Append('}');
+    }
+    return json.Append("]}").ToString();
+  }
+}
+`;
+function longPath(folder) {
+  const absolute = path68.win32.resolve(folder);
+  if (absolute.startsWith("\\\\?\\")) return absolute;
+  return absolute.startsWith("\\\\") ? `\\\\?\\UNC\\${absolute.slice(2)}` : `\\\\?\\${absolute}`;
+}
+function holdersScript(folder) {
+  const encoded = Buffer.from(longPath(folder), "utf8").toString("base64");
+  return [
+    "$ErrorActionPreference = 'Stop'",
+    `$source = @'
+${CSHARP}
+'@`,
+    "Add-Type -TypeDefinition $source",
+    `$root = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encoded}'))`,
+    `[Console]::Out.WriteLine([AwFolderHolders]::Scan($root, ${SCAN_MAX_ENTRIES}, ${SCAN_MAX_MS}))`,
+    // Con `-Command -`, la última línea corre recién con la línea en blanco de después.
+    "",
+    ""
+  ].join("\n");
+}
+function parseHoldersOutput(output, selfPid) {
+  const line = output.split(/\r?\n/).map((candidate) => candidate.trim()).find((candidate) => candidate.startsWith('{"complete":'));
+  const record = line === void 0 ? null : asRecord(parseJson(line));
+  if (record === null || typeof record["complete"] !== "boolean" || !Array.isArray(record["holders"])) return null;
+  const holders = [];
+  let self = false;
+  for (const item of record["holders"]) {
+    const holder = parseWorktreeHolder(item);
+    if (holder === null || holders.some((other) => other.pid === holder.pid)) continue;
+    if (holder.pid === selfPid) self = true;
+    else if (holders.length < WORKTREE_HOLDERS_MAX) holders.push(holder);
+  }
+  return { holders, complete: record["complete"], self };
+}
+function powershellPath() {
+  const systemRoot = process.env["SystemRoot"] ?? process.env["windir"] ?? "C:\\Windows";
+  return path68.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+}
+function runPowerShell(script) {
+  return new Promise((resolve) => {
+    const child = spawn4(powershellPath(), ["-NoProfile", "-NonInteractive", "-Command", "-"], {
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
+    });
+    let output = "";
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      child.kill();
+      finish(null);
+    }, HOLDERS_TIMEOUT_MS);
+    timer.unref();
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+      if (output.length <= OUTPUT_MAX_CHARS) return;
+      child.kill();
+      finish(null);
+    });
+    child.on("error", () => finish(null));
+    child.on("close", () => finish(output));
+    child.stdin.on("error", () => void 0);
+    child.stdin.end(script);
+  });
+}
+async function folderHolders(folder) {
+  if (process.platform !== "win32") return [];
+  const output = await runPowerShell(holdersScript(folder));
+  const parsed = output === null ? null : parseHoldersOutput(output, process.pid);
+  if (parsed === null) {
+    console.warn(`[worktrees] couldn't tell which programs have ${folder} open`);
+    return [];
+  }
+  if (parsed.self) console.warn(`[worktrees] this server has ${folder} open`);
+  debugLog("worktrees", `holders of ${folder}: ${parsed.holders.length}, complete ${parsed.complete}`);
+  return parsed.holders;
+}
+
 // 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 path66 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;
@@ -25521,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(path66.sep).join("/");
+var toPosix2 = (value) => value.split(path69.sep).join("/");
 function hashOf(content) {
   return createHash6("sha256").update(content).digest("hex");
 }
@@ -25572,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;
   }
@@ -25626,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(path66.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);
@@ -25646,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;
   }
@@ -25715,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);
   }
 }
@@ -25768,7 +26826,7 @@ async function returnNotes(mainRoot, folder, files, bases, options = {}) {
         result.skipped.push(file);
         continue;
       }
-      await mkdir19(path66.dirname(target), { recursive: true });
+      await mkdir21(path69.dirname(target), { recursive: true });
       await writeAtomically(target, outcome.content, {
         beforeRename: async () => {
           const now = await readInside(mainRoot, file);
@@ -25790,15 +26848,15 @@ async function returnNotes(mainRoot, folder, files, bases, options = {}) {
 }
 
 // packages/server/src/worktrees/names.ts
-import path67 from "node:path";
-function worktreeFolderFor(mainRoot, branch, pathApi = path67) {
+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 = path67) {
+function worktreesParentFor(mainRoot, pathApi = path70) {
   return pathApi.join(pathApi.dirname(mainRoot), worktreesDirName(pathApi.basename(mainRoot)));
 }
-function mainRootFromShape(folder, pathApi = path67) {
+function mainRootFromShape(folder, pathApi = path70) {
   const parent = pathApi.dirname(folder);
   const parentName = pathApi.basename(parent);
   if (parentName.length > ".worktrees".length && parentName.toLowerCase().endsWith(".worktrees")) {
@@ -25813,8 +26871,8 @@ function mainRootFromShape(folder, pathApi = path67) {
 
 // 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 stat43, utimes as utimes3 } from "node:fs/promises";
-import path68 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;
@@ -25823,7 +26881,7 @@ function hashOf2(content) {
   return createHash7("sha256").update(content).digest("hex");
 }
 function keepsNoteBase(relative, content) {
-  return TEXT_NOTE_EXTENSIONS.has(path68.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 = {}) {
@@ -25843,21 +26901,21 @@ var NoteBases = class {
   async save(relative, content) {
     if (!keepsNoteBase(relative, content)) return;
     const hash = hashOf2(content);
-    const file = path68.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(path68.join(this.dir, hash));
+      const content = await readFile30(path71.join(this.dir, hash));
       return hashOf2(content) === hash ? content : null;
     } catch {
       return null;
@@ -25867,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 = path68.join(this.dir, name);
+      const file = path71.join(this.dir, name);
       try {
-        const info = await stat43(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 {
       }
     }
@@ -25929,7 +26987,7 @@ function catchUpPrompt(base, conflicts, uncommitted) {
 }
 function commitPrompt(files, count) {
   const more = count > files.length ? ` and ${count - files.length} more` : "";
-  return `This branch folder has uncommitted changes: ${files.join(", ")}${more}. Commit them with a clear message, or tell me first if any of them should be discarded instead. Don't push.`;
+  return `This branch folder has uncommitted changes: ${files.join(", ")}${more}. Commit them with a clear message. If any of them shouldn't be committed, leave it as it is and tell me which and why. Don't push.`;
 }
 function lastReplyText(events) {
   const textOf3 = (event2) => event2.parts.flatMap((part) => part.kind === "text" ? [part.text] : []).join("\n").trim();
@@ -25963,9 +27021,9 @@ function readVerdict(reply) {
 }
 
 // packages/server/src/worktrees/store.ts
-import { mkdir as mkdir21, readFile as readFile30 } from "node:fs/promises";
-import path69 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) {
@@ -26045,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 [];
@@ -26060,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 = [];
     }
@@ -26100,18 +27158,108 @@ 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(path69.dirname(this.file), { recursive: true });
+      await mkdir23(path72.dirname(this.file), { recursive: true });
       await writeAtomically(this.file, content);
     });
     return this.writing;
   }
 };
 
+// packages/server/src/worktrees/untracked.ts
+import { createHash as createHash8 } from "node:crypto";
+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(/\/+$/, "");
+  if (clean.length === 0 || clean.includes("\\")) return null;
+  const parts = clean.split("/");
+  return parts.some((part) => part.length === 0 || part === "." || part === ".." || sameName(part, ".git")) ? null : clean;
+}
+async function scanUntracked(folder, entries, maxFiles = WORKTREE_UNTRACKED_MAX_FILES) {
+  const walk2 = { hash: createHash8("sha256"), files: 0, bytes: 0, max: maxFiles, blocked: null };
+  const targets = [];
+  for (const entry of [...entries].sort()) {
+    const clean = cleanEntry(entry);
+    if (clean === null) return null;
+    let target;
+    let real;
+    try {
+      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;
+    }
+    targets.push(target);
+    walk2.hash.update(`${clean}\0`);
+    await visit(target, real, clean, walk2);
+    if (walk2.blocked !== null) return { files: walk2.files, bytes: walk2.bytes, stamp: null, blocked: walk2.blocked, targets: [] };
+  }
+  return { files: walk2.files, bytes: walk2.bytes, stamp: walk2.hash.digest("hex"), blocked: null, targets };
+}
+async function visit(absolute, real, relative, walk2) {
+  if (walk2.files >= walk2.max) {
+    walk2.blocked = "too-many";
+    return;
+  }
+  let info;
+  try {
+    info = await lstat4(absolute);
+  } catch {
+    walk2.hash.update(`${relative}\0?
+`);
+    return;
+  }
+  const linked = !info.isDirectory() || !sameName(await realpath7(absolute).catch(() => ""), real);
+  if (linked) {
+    walk2.files += 1;
+    walk2.bytes += info.size;
+    walk2.hash.update(`${relative}\0${info.isSymbolicLink() || info.isDirectory() ? "l" : "f"}\0${info.size}\0${info.mtimeMs}
+`);
+    return;
+  }
+  walk2.hash.update(`${relative}\0d
+`);
+  let names;
+  try {
+    names = (await readdir23(absolute)).sort();
+  } catch {
+    walk2.hash.update(`${relative}\0!
+`);
+    return;
+  }
+  if (names.some((name) => sameName(name, ".git"))) {
+    walk2.blocked = "nested-repo";
+    return;
+  }
+  for (const name of names) {
+    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 rm11(target, { recursive: true, maxRetries: 3 });
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+}
+
 // packages/server/src/worktrees/service.ts
 var WorktreeError = class extends ServerTextError {
 };
+var WorktreeInUseError = class extends WorktreeError {
+  constructor(plan) {
+    super(serverText("worktreeInUse"));
+    this.plan = plan;
+  }
+  plan;
+};
 var ROWS_TTL_MS = 5e3;
 var RELEASE_TIMEOUT_MS = 5e3;
 var RELEASE_POLL_MS = 100;
@@ -26120,17 +27268,20 @@ var REPLY_LIMITS = { textMaxChars: 2e5, toolInputMaxChars: 200, toolResultMaxCha
 var REPLY_EVENTS = 300;
 var REPLY_CACHE_MAX = 50;
 var REVIEW_ACTIVITY_DELAY_MS = 1e3;
-async function exists4(candidate) {
+async function leftWithoutGit(folder) {
+  return await exists5(folder) && await lstat5(path74.join(folder, ".git")).catch(() => null) === null;
+}
+async function exists5(candidate) {
   try {
-    await stat44(candidate);
+    await stat46(candidate);
     return true;
   } catch {
     return false;
   }
 }
 function isInside4(outer, inner) {
-  const relative = path70.relative(path70.resolve(outer), path70.resolve(inner));
-  return relative.length === 0 || !relative.startsWith("..") && !path70.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(" ");
@@ -26186,7 +27337,7 @@ var WorktreeService = class extends EventEmitter7 {
   /** La carpeta principal del repo de un proyecto o de una pestaña. */
   async mainRootOf(source) {
     const cwd = source.kind === "terminal" ? this.deps.registry.get(source.terminalId)?.cwd ?? null : this.deps.projectCwd(source.projectKey);
-    if (cwd === null || !await exists4(cwd)) throw new WorktreeError(serverText("worktreeProjectUnknown"));
+    if (cwd === null || !await exists5(cwd)) throw new WorktreeError(serverText("worktreeProjectUnknown"));
     const layout = await repoLayout(cwd);
     if (layout === null || layout.mainRoot === null) throw new WorktreeError(serverText("worktreeNotRepo"));
     return layout.mainRoot;
@@ -26205,7 +27356,7 @@ var WorktreeService = class extends EventEmitter7 {
     return {
       mainRoot,
       parentDir: worktreesParentFor(mainRoot),
-      separator: path70.sep,
+      separator: path74.sep,
       currentBranch: current,
       branches: branches.map((name) => ({ name, checkedOut: checkedOut.has(name) })),
       mainChanges: changes?.length ?? 0,
@@ -26227,9 +27378,9 @@ var WorktreeService = class extends EventEmitter7 {
       throw new WorktreeError(serverText("worktreeBranchInUse", { branch }));
     }
     const folder = worktreeFolderFor(mainRoot, branch);
-    if (await exists4(folder)) throw new WorktreeError(serverText("worktreeFolderExists", { folder }));
+    if (await exists5(folder)) throw new WorktreeError(serverText("worktreeFolderExists", { folder }));
     const copy = await planCopy(mainRoot);
-    await mkdir22(path70.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);
@@ -26274,13 +27425,13 @@ var WorktreeService = class extends EventEmitter7 {
   /** Las filas de "Ramas aparte" para la pestaña que pregunta. Vacío fuera de git. */
   async rows(terminalId) {
     const descriptor = this.deps.registry.get(terminalId);
-    if (descriptor === null || !await exists4(descriptor.cwd)) return [];
+    if (descriptor === null || !await exists5(descriptor.cwd)) return [];
     const layout = await repoLayout(descriptor.cwd);
     if (layout === null || layout.mainRoot === null) return [];
     const mainRoot = layout.mainRoot;
     const tips = await branchTips(mainRoot);
     const tipsStamp = [...tips].map(([branch, commit]) => `${branch}\0${commit}`).join("\n");
-    const cacheKey2 = path70.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;
@@ -26289,7 +27440,12 @@ var WorktreeService = class extends EventEmitter7 {
     return rows.map((row) => ({ ...row, isCurrent: samePathShape(row.path, layout.toplevel) }));
   }
   async readRows(mainRoot, tips) {
-    const entries = (await listWorktrees(mainRoot)).filter((entry) => !entry.bare);
+    const listed = await readWorktreeList(mainRoot);
+    const entries = [
+      ...(listed ?? []).filter((entry) => !entry.bare),
+      // Las que git soltó a medias: sin su fila, no había cómo terminar de quitarlas.
+      ...listed === null ? [] : await this.releasedEntries(mainRoot, listed)
+    ];
     const mainBranch = entries.find((entry) => entry.isMain)?.branch ?? null;
     const read2 = await Promise.all(
       entries.map(async (entry) => {
@@ -26336,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 = [path70.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);
@@ -26381,12 +27537,12 @@ var WorktreeService = class extends EventEmitter7 {
   /** Una rama aparte que existe en disco, para lo que la lee o le deja un pedido. */
   async presentRecordOrThrow(id) {
     const record = this.recordOrThrow(id);
-    if (!await exists4(record.path)) throw new WorktreeError(serverText("worktreeUnknown"));
+    if (!await exists5(record.path)) throw new WorktreeError(serverText("worktreeUnknown"));
     return record;
   }
   /** 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 || path70.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
@@ -26399,17 +27555,70 @@ var WorktreeService = class extends EventEmitter7 {
       return !nested.some((inner) => isInside4(inner, cwd));
     });
   }
+  /**
+   * Los archivos nuevos que se pueden perder al quitar la rama (23-10-2026):
+   * sólo si todo lo que no está commiteado es nuevo y git lo listó entero. null
+   * si no; si git se va a negar a quitarla igual, bloqueada o con un submódulo
+   * cargado (no se borra nada antes de saberlo); o si una entrada no se puede
+   * borrar sin salir de la carpeta. Con algo adentro que la app copió de la
+   * principal y la rama no ignora, no se ofrece (`copied`): no vuelve como una
+   * nota, y se perdería lo que la rama le cambió.
+   */
+  async untrackedIn(record, changes) {
+    const onlyNew = changes.complete && changes.paths.length > 0 && changes.untracked.length === changes.paths.length;
+    if (!onlyNew) return null;
+    const [entries, submodule] = await Promise.all([listWorktrees(record.mainRoot), hasLoadedSubmodule(record.path)]);
+    if (submodule !== false || entries.some((entry) => entry.locked && samePathShape(entry.path, record.path))) return null;
+    const entryOf = (file) => changes.untracked.some((entry) => {
+      const clean = entry.replace(/\/+$/, "").toLowerCase();
+      return file.toLowerCase() === clean || file.toLowerCase().startsWith(`${clean}/`);
+    });
+    const copied = [];
+    for (const file of record.copied) {
+      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);
+      if (ignored === null || copied.some((file) => !ignored.has(file))) return { files: 0, bytes: 0, stamp: null, blocked: "copied", targets: [] };
+    }
+    return scanUntracked(record.path, changes.untracked);
+  }
+  /**
+   * Borra los archivos nuevos que el usuario eligió perder, si siguen siendo
+   * los que vio: se mira justo antes, con las pestañas de la rama cerradas y
+   * las notas ya de vuelta. Si desaparecieron solos, no hay nada que borrar.
+   * Devuelve cuántos archivos se perdieron.
+   */
+  async discardNew(record, stamp2) {
+    const changes = await uncommittedChanges(record.path);
+    if (changes === null) throw new WorktreeError(serverText("worktreeGitFailed", { detail: "git status" }));
+    if (changes.paths.length === 0) return 0;
+    const scan = await this.untrackedIn(record, changes);
+    if (scan === null || scan.stamp === null || scan.stamp !== stamp2) throw new WorktreeError(serverText("worktreeUntrackedChanged"));
+    try {
+      await deleteUntracked(scan.targets);
+    } catch (error) {
+      throw new WorktreeError(serverText("worktreeDiscardFailed", { detail: error instanceof Error ? error.message : String(error) }));
+    }
+    return scan.files;
+  }
   async planFor(record) {
-    const present = await exists4(record.path);
-    const [uncommitted, notes, integrated] = await Promise.all([
-      present ? uncommittedPaths(record.path) : Promise.resolve([]),
+    const onDisk = await exists5(record.path);
+    const present = onDisk && !await this.releasedByGit(record);
+    const [changes, notes, integrated] = await Promise.all([
+      present ? uncommittedChanges(record.path) : Promise.resolve({ paths: [], untracked: [], complete: true }),
       present ? reviewNotes(record.mainRoot, record.path, record, this.loadNoteBase) : Promise.resolve({ returning: [], merging: [], resolved: [], conflicts: [] }),
       record.createdBranch ? isIntegrated(record.mainRoot, record.branch, record.base) : Promise.resolve(false)
     ]);
-    if (uncommitted === null) throw new WorktreeError(serverText("worktreeGitFailed", { detail: "git status" }));
+    if (changes === null) throw new WorktreeError(serverText("worktreeGitFailed", { detail: "git status" }));
+    const uncommitted = changes.paths;
+    const untracked = await this.untrackedIn(record, changes);
     const tabs = this.tabsIn(record.path);
     const deletesBranch = integrated === true;
     const branchUnused = deletesBranch && stillAtStart(record, await branchCommit(record.mainRoot, record.branch) ?? void 0);
+    let inUse = !onDisk ? false : tabs.length > 0 ? null : await folderInUse(record.path);
+    const holders = inUse === true ? await this.holdersOf(record.path) : [];
+    if (inUse === true && holders.length === 0) inUse = await folderInUse(record.path);
     return {
       id: record.id,
       branch: record.branch,
@@ -26420,13 +27629,15 @@ var WorktreeService = class extends EventEmitter7 {
       ],
       uncommitted: uncommitted.slice(0, WORKTREE_PLAN_PATHS_MAX),
       uncommittedCount: uncommitted.length,
+      // Sin las rutas absolutas de `targets`: al cliente le basta con lo que muestra y la huella.
+      untracked: untracked === null ? null : { files: untracked.files, bytes: untracked.bytes, stamp: untracked.stamp, blocked: untracked.blocked },
       tabs,
       returning: notes.returning,
       merging: notes.merging,
       resolved: notes.resolved,
       conflicts: notes.conflicts,
-      // Con pestañas de la app adentro, la prueba daría "en uso" por ellas mismas: se mira al confirmar.
-      inUse: !present ? false : tabs.length > 0 ? null : await folderInUse(record.path),
+      inUse,
+      holders,
       deletesBranch,
       branchUnused,
       createdBranch: record.createdBranch
@@ -26439,34 +27650,46 @@ var WorktreeService = class extends EventEmitter7 {
   /**
    * Quita la rama aparte. Rehace el plan y se detiene en el primer "no" (ver
    * el principio del archivo). `closeTab` cierra una pestaña como lo hace el
-   * socket, soltando todo lo que la seguía.
+   * socket, soltando todo lo que la seguía. `discardUntracked` es la huella de
+   * los archivos nuevos que el usuario eligió perder (23-10-2026).
    */
-  async remove(id, discardConflicts, closeTab) {
+  async remove(id, discardConflicts, closeTab, discardUntracked = null) {
     const record = this.recordOrThrow(id);
     const plan = await this.planFor(record);
     if (plan.uncommittedCount > 0) {
-      throw new WorktreeError(serverText("worktreeUncommitted", { count: plan.uncommittedCount }));
+      if (plan.untracked === null || plan.untracked.stamp === null || discardUntracked === null) {
+        throw new WorktreeError(serverText("worktreeUncommitted", { count: plan.uncommittedCount }));
+      }
+      if (plan.untracked.stamp !== discardUntracked) throw new WorktreeError(serverText("worktreeUntrackedChanged"));
     }
     if (plan.conflicts.length > 0 && !discardConflicts) {
       throw new WorktreeError(serverText("worktreeNotesConflict", { count: plan.conflicts.length }));
     }
-    if (plan.inUse === true) throw new WorktreeError(serverText("worktreeInUse"));
+    if (plan.inUse === true) throw new WorktreeInUseError(plan);
     let returned = 0;
-    if (await exists4(record.path)) {
+    let discardedFiles = 0;
+    if (await exists5(record.path)) {
       for (const tab of plan.tabs) closeTab(tab.terminalId);
-      if (!await this.waitUntilFree(record.path)) throw new WorktreeError(serverText("worktreeInUse"));
-      const bases = new Map(record.copied.map((file) => [file.path, file.hash]));
-      try {
-        returned = (await returnNotes(record.mainRoot, record.path, plan.returning, bases, {
-          loadBase: this.loadNoteBase,
-          onWritten: (file, branch) => this.noteReturned(record.id, file, branch),
-          notesAsked: record.notesAsked
-        })).returned.length;
-      } catch (error) {
-        throw new WorktreeError(serverText("worktreeNotesFailed", { detail: error instanceof Error ? error.message : String(error) }));
+      if (!await this.waitUntilFree(record.path)) {
+        throw new WorktreeInUseError({ ...plan, tabs: [], inUse: true, holders: await this.holdersOf(record.path) });
+      }
+      if (!await this.releasedByGit(record)) {
+        const bases = new Map(record.copied.map((file) => [file.path, file.hash]));
+        try {
+          returned = (await returnNotes(record.mainRoot, record.path, plan.returning, bases, {
+            loadBase: this.loadNoteBase,
+            onWritten: (file, branch) => this.noteReturned(record.id, file, branch),
+            notesAsked: record.notesAsked
+          })).returned.length;
+        } catch (error) {
+          throw new WorktreeError(serverText("worktreeNotesFailed", { detail: error instanceof Error ? error.message : String(error) }));
+        }
+        if (plan.uncommittedCount > 0) discardedFiles = await this.discardNew(record, discardUntracked);
+        const removed = await removeWorktree(record.mainRoot, record.path);
+        if (removed.code !== 0 && !await this.releasedByGit(record)) {
+          throw new WorktreeError(serverText("worktreeGitFailed", { detail: gitFailureText(removed) }));
+        }
       }
-      const removed = await removeWorktree(record.mainRoot, record.path);
-      if (removed.code !== 0) throw new WorktreeError(serverText("worktreeGitFailed", { detail: gitFailureText(removed) }));
       await this.removeLeftovers(record);
     }
     const endCommit = await branchCommit(record.mainRoot, record.branch);
@@ -26474,7 +27697,15 @@ var WorktreeService = class extends EventEmitter7 {
     await this.deps.store.update(id, { removedAt: this.now(), endCommit: endCommit ?? record.endCommit });
     await this.pruneNoteBases();
     this.changed();
-    return { branchDeleted, returned, discarded: discardConflicts ? plan.conflicts.length : 0 };
+    return { branchDeleted, returned, discarded: discardConflicts ? plan.conflicts.length : 0, discardedFiles };
+  }
+  /** Los programas que tienen la carpeta, para el diálogo. Sin saberlo, ninguno: el diálogo dice lo de antes. */
+  async holdersOf(folder) {
+    try {
+      return await (this.deps.folderHolders ?? folderHolders)(folder);
+    } catch {
+      return [];
+    }
   }
   /** Espera, con tope, a que ningún proceso tenga la carpeta. */
   async waitUntilFree(folder) {
@@ -26492,16 +27723,40 @@ var WorktreeService = class extends EventEmitter7 {
    * contenga, ni una carpeta que git todavía tenga registrada.
    */
   async removeLeftovers(record) {
-    const folder = path70.resolve(record.path);
-    if (!await exists4(folder)) return this.removeEmptyParent(folder);
-    if (isInside4(folder, record.mainRoot) || path70.dirname(folder) === folder) return;
+    const folder = path74.resolve(record.path);
+    if (!await exists5(folder)) return this.removeEmptyParent(folder);
+    if (isInside4(folder, record.mainRoot) || path74.dirname(folder) === folder) return;
     if ((await listWorktrees(record.mainRoot)).some((entry) => samePathShape(entry.path, folder))) return;
-    await rm9(folder, { recursive: true, maxRetries: 3 });
+    await rm12(folder, { recursive: true, maxRetries: 3 });
     await this.removeEmptyParent(folder);
   }
+  /**
+   * true si git ya soltó la rama sin terminar de borrar su carpeta
+   * (23-10-2026). `worktree remove` borra después de sus controles y, si algo
+   * no se deja borrar a mitad de camino, quita su registro igual (medido con git
+   * 2.56: una ruta de más de 260 caracteres sin `core.longpaths`, o un nombre
+   * terminado en punto). Lo que quedó ya pasó esos controles, y lo termina de
+   * borrar la app. Sólo sin `.git` adentro, y si git contesta que no la tiene:
+   * una carpeta con su `.git` puede tener trabajo aunque git ya no la conozca.
+   */
+  async releasedByGit(record) {
+    if (!await leftWithoutGit(record.path)) return false;
+    const entries = await readWorktreeList(record.mainRoot);
+    return entries !== null && !entries.some((entry) => samePathShape(entry.path, record.path));
+  }
+  /** Las ramas de la app que git soltó a medias (`releasedByGit`), como si git las listara. */
+  async releasedEntries(mainRoot, listed) {
+    const released = [];
+    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: 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(path70.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
@@ -26513,7 +27768,7 @@ var WorktreeService = class extends EventEmitter7 {
     const session = this.deps.findSession(agent, sessionId);
     if (session === null || session.cwd.length === 0) throw new WorktreeError(serverText("worktreeUnknown"));
     const record = this.removedRecordAbove(session.cwd);
-    if (record === null || await exists4(record.path) || !await exists4(record.mainRoot)) {
+    if (record === null || await exists5(record.path) || !await exists5(record.mainRoot)) {
       throw new WorktreeError(serverText("worktreeUnknown"));
     }
     const branchExists = await branchCommit(record.mainRoot, record.branch) !== null;
@@ -26525,7 +27780,7 @@ var WorktreeService = class extends EventEmitter7 {
       throw new WorktreeError(serverText("worktreeBranchInUse", { branch: record.branch }));
     }
     const copy = await planCopy(record.mainRoot);
-    await mkdir22(path70.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);
@@ -26541,7 +27796,7 @@ var WorktreeService = class extends EventEmitter7 {
    */
   async keptBranches(terminalId) {
     const descriptor = this.deps.registry.get(terminalId);
-    if (descriptor === null || !await exists4(descriptor.cwd)) return [];
+    if (descriptor === null || !await exists5(descriptor.cwd)) return [];
     const layout = await repoLayout(descriptor.cwd);
     if (layout === null || layout.mainRoot === null) return [];
     const mainRoot = layout.mainRoot;
@@ -26612,11 +27867,11 @@ var WorktreeService = class extends EventEmitter7 {
     return { branch: plan.branch };
   }
   removedRecordAbove(cwd) {
-    let current = path70.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 = path70.dirname(current);
+      const parent = path74.dirname(current);
       if (parent === current) return null;
       current = parent;
     }
@@ -26725,10 +27980,10 @@ 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 exists4(session.cwd)) {
+    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 });
       return { terminal, opened: true };
     }
@@ -26945,11 +28200,11 @@ var WorktreeService = class extends EventEmitter7 {
     const baseEntry = entries.find((entry) => !entry.bare && !entry.prunable && entry.branch === record.base) ?? null;
     const [baseChanges, branchChanges, target] = await Promise.all([
       baseEntry === null ? Promise.resolve([]) : uncommittedPaths(baseEntry.path),
-      await exists4(record.path) ? uncommittedPaths(record.path) : Promise.resolve([]),
+      await exists5(record.path) ? uncommittedPaths(record.path) : Promise.resolve([]),
       baseEntry === null ? Promise.resolve(`refs/heads/${record.branch}`) : mergeTarget(baseEntry.path, record.branch)
     ]);
     const localConflicts = pathsTouching(baseChanges ?? [], files);
-    const notes = baseEntry?.isMain === true && await exists4(record.path) ? await reviewNotes(mainRoot, record.path, record, this.loadNoteBase) : null;
+    const notes = baseEntry?.isMain === true && await exists5(record.path) ? await reviewNotes(mainRoot, record.path, record, this.loadNoteBase) : null;
     const blocker = pair.ahead === 0 ? "nothing" : pair.behind > 0 ? "behind" : baseEntry === null ? "no-base-folder" : localConflicts.length > 0 ? "local-changes" : null;
     const plan = {
       id: record.id,
@@ -27065,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;
@@ -27111,7 +28909,8 @@ function attachTerminalSocket(options) {
     defaultCwd,
     vault,
     remote,
-    worktrees
+    worktrees,
+    scheduled
   } = options;
   const pasteStore = options.pasteStore ?? new PasteStore();
   const writeQueue = new TerminalWriteQueue();
@@ -27176,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;
   };
@@ -27194,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) => {
@@ -27202,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 });
@@ -27237,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 });
@@ -27251,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);
@@ -27325,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);
@@ -27346,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) => {
@@ -27414,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) {
@@ -27542,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() });
@@ -27623,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) {
@@ -27689,7 +29574,7 @@ function attachTerminalSocket(options) {
                   error instanceof PasteImageError ? error.text : serverText("pasteImageFailed"),
                   detail
                 );
-                return;
+                return null;
               }
               const attachmentLines = [];
               try {
@@ -27707,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;
         }
         /*
@@ -27829,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 }
@@ -27861,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();
             },
@@ -27927,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(
@@ -28644,17 +30499,24 @@ ${seen.join("\n-----\n")}`);
           })();
           break;
         /*
-          Cuales de esas rutas son archivos del proyecto (§6.33): lo que el
-          hilo vuelve enlace. Sin error para ningun caso —una pestana que ya no
-          esta, una ruta que cae fuera—: nada existe, y el hilo queda como
+          Cuales de esas rutas son archivos o carpetas del proyecto (§6.33): lo
+          que el hilo vuelve enlace. Sin error para ningun caso (una pestana que
+          ya no esta, una ruta que cae fuera): nada existe, y el hilo queda como
           texto. Un cartel por una ruta que escribio el agente no le dice nada
           al usuario.
         */
         case "files.check":
           void (async () => {
             const cwd = cwdOf(message.terminalId);
-            const existing = cwd === null ? [] : await existingFiles(cwd, message.paths, await folders).catch(() => []);
-            send(socket, { type: "files.checked", terminalId: message.terminalId, requestId: message.requestId, existing });
+            const none = { files: [], directories: [] };
+            const { files, directories } = cwd === null ? none : await existingPaths(cwd, message.paths, await folders).catch(() => none);
+            send(socket, {
+              type: "files.checked",
+              terminalId: message.terminalId,
+              requestId: message.requestId,
+              existing: files,
+              directories
+            });
           })();
           break;
         case "files.reveal":
@@ -29024,9 +30886,11 @@ ${seen.join("\n-----\n")}`);
         }
         case "worktree.remove": {
           const { requestId, worktreeId, discardConflicts } = message;
-          void worktrees.remove(worktreeId, discardConflicts, (terminalId) => void dropTab(terminalId)).then(
+          const closeTab = (terminalId) => void dropTab(terminalId);
+          void worktrees.remove(worktreeId, discardConflicts, closeTab, message.discardUntracked ?? null).then(
             (outcome) => send(socket, { type: "worktree.removed", requestId, worktreeId, outcome }),
-            (error) => sendWorktreeError(socket, error, requestId)
+            // Otro programa tiene la carpeta: el plan otra vez, que dice cuál (23-10-2026).
+            (error) => error instanceof WorktreeInUseError ? send(socket, { type: "worktree.removePlan", requestId, plan: error.plan }) : sendWorktreeError(socket, error, requestId)
           );
           break;
         }
@@ -29176,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
@@ -29308,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 readdir21, stat as stat45 } from "node:fs/promises";
-import path71 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;
@@ -29327,7 +31274,7 @@ async function assetBytesOf(dir, agent, sessionId) {
   const folder = assetsDir(dir, agent, sessionId);
   let names;
   try {
-    names = await readdir21(folder);
+    names = await readdir24(folder);
   } catch {
     return 0;
   }
@@ -29335,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 stat45(path71.join(folder, name));
+      const info = await stat47(path75.join(folder, name));
       if (info.isFile()) total += info.size;
     } catch {
     }
@@ -29346,7 +31293,7 @@ async function readEntry2(dir, agent, sessionId) {
   const file = sessionFile(dir, agent, sessionId);
   let sizeBytes;
   try {
-    const info = await stat45(file);
+    const info = await stat47(file);
     if (!info.isFile()) return { kind: "absent" };
     sizeBytes = info.size;
   } catch {
@@ -29403,7 +31350,7 @@ var VaultCatalog = class {
     const keys = [];
     let agentFolders = [];
     try {
-      agentFolders = await readdir21(sessionsRoot2(dir));
+      agentFolders = await readdir24(sessionsRoot2(dir));
     } catch {
       agentFolders = [];
     }
@@ -29411,7 +31358,7 @@ var VaultCatalog = class {
       if (!isSessionAgentId2(folder)) continue;
       let names;
       try {
-        names = await readdir21(agentSessionsDir(dir, folder));
+        names = await readdir24(agentSessionsDir(dir, folder));
       } catch {
         continue;
       }
@@ -29500,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 });
@@ -29555,22 +31502,22 @@ var VaultCatalog = class {
 };
 
 // packages/server/src/worktrees/links.ts
-import { stat as stat46 } from "node:fs/promises";
-import path72 from "node:path";
-async function exists5(candidate) {
+import { stat as stat48 } from "node:fs/promises";
+import path76 from "node:path";
+async function exists6(candidate) {
   try {
-    await stat46(candidate);
+    await stat48(candidate);
     return true;
   } catch {
     return false;
   }
 }
 function recordAbove(registry, cwd) {
-  let current = path72.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: path72.relative(current, path72.resolve(cwd)) };
-    const parent = path72.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;
   }
@@ -29584,14 +31531,14 @@ var WorktreeLinks = class {
   /** La rama aparte de una carpeta del historial, o null si es la de un proyecto (o no es de git). */
   async sessionLink(cwd) {
     if (cwd.length === 0) return null;
-    if (await exists5(cwd)) {
+    if (await exists6(cwd)) {
       const checkout = await readCheckout(cwd);
       if (checkout === null || !checkout.linked) return null;
       const record = this.registry.byPath(checkout.root);
       return {
         mainCwd: mainCwdFor(cwd, checkout),
         worktree: {
-          branch: checkout.branch ?? record?.branch ?? path72.basename(checkout.root),
+          branch: checkout.branch ?? record?.branch ?? path76.basename(checkout.root),
           exists: true,
           reopenable: false
         }
@@ -29601,13 +31548,13 @@ var WorktreeLinks = class {
     if (found !== null) {
       const { record, inner } = found;
       return {
-        mainCwd: inner.length === 0 ? record.mainRoot : path72.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(path72.resolve(cwd));
+    const mainRoot = mainRootFromShape(path76.resolve(cwd));
     if (mainRoot === null) return null;
-    return { mainCwd: mainRoot, worktree: { branch: path72.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
@@ -29616,7 +31563,7 @@ var WorktreeLinks = class {
    */
   async reopenable(record) {
     if (record.removedAt === null) return false;
-    if (await exists5(record.path) || !await exists5(record.mainRoot)) return false;
+    if (await exists6(record.path) || !await exists6(record.mainRoot)) return false;
     try {
       if (await branchCommit(record.mainRoot, record.branch) !== null) return true;
       return record.endCommit !== null && await commitExists(record.mainRoot, record.endCommit);
@@ -29637,15 +31584,15 @@ var WorktreeLinks = class {
 };
 
 // packages/server/src/index.ts
-var serverDir = path73.dirname(fileURLToPath2(import.meta.url));
+var serverDir = path77.dirname(fileURLToPath2(import.meta.url));
 var isPackaged = true;
-var webRoot = isPackaged ? serverDir : path73.resolve(serverDir, "../../web");
-var webDist = isPackaged ? path73.join(serverDir, "web") : path73.join(webRoot, "dist");
-var repoRoot = path73.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 path73.resolve(override);
+  if (override !== void 0 && override.length > 0) return path77.resolve(override);
   if (isPackaged) return process.cwd();
   return repoRoot;
 }
@@ -29720,7 +31667,7 @@ async function mountDevUi(app, httpServer) {
 }
 var LOOKS_LIKE_FILE = /\.[a-zA-Z0-9]{1,8}$/;
 function mountBuiltUi(app) {
-  const indexHtml = path73.join(webDist, "index.html");
+  const indexHtml = path77.join(webDist, "index.html");
   if (!existsSync4(indexHtml)) {
     throw new Error(
       `There's no compiled interface in ${webDist}.
@@ -29808,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 = path73.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 = path73.relative(root, path73.resolve(session.cwd));
-        return relative.length === 0 || !relative.startsWith("..") && !path73.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
@@ -29836,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);
@@ -29887,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();
@@ -29932,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