agent-workbench 0.6.0 → 0.7.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 path59 from "node:path";
+import path62 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import express from "express";
 
@@ -172,6 +172,8 @@ function noticeText(part) {
   }
 }
 var MAX_SUBAGENT_DESCRIPTION = 120;
+var MAX_QUEUED_PROMPTS = 20;
+var MAX_QUEUED_PROMPT_CHARS = 4e3;
 var EMPTY_CONTEXT_USAGE = {
   lastRequestTokens: 0,
   lastOutputTokens: 0,
@@ -365,6 +367,11 @@ function modelFamilyOf(value, options = MODEL_OPTIONS) {
   return candidates.find((option) => value.includes(option.family))?.family ?? null;
 }
 
+// packages/shared/src/files.ts
+function isContentHash(value) {
+  return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
+}
+
 // packages/shared/src/composer-draft.ts
 var MAX_COMPOSER_DRAFT_CHARS = 1e6;
 var MAX_COMPOSER_DRAFT_PASTES = 100;
@@ -722,6 +729,7 @@ var MAX_SUBMIT_IMAGE_BYTES = 12 * 1024 * 1024;
 var MAX_SUBMIT_IMAGES = 8;
 var MAX_SUBMIT_FILE_BYTES = 10 * 1024 * 1024;
 var MAX_SUBMIT_FILES = 4;
+var REWIND_RESTORES = ["conversation", "conversation-and-code"];
 var FILES_CHECK_MAX_PATHS = 100;
 var FILES_CHECK_MAX_PATH_CHARS = 512;
 var CONTINUE_LABEL_MAX_CHARS = 120;
@@ -800,6 +808,18 @@ function parseClientMessage(raw) {
       const terminalId = asNonEmptyString(record["terminalId"]);
       return terminalId === null ? null : { type: "agent.interrupt", terminalId };
     }
+    case "agent.forceSend": {
+      const terminalId = asNonEmptyString(record["terminalId"]);
+      const requestId = asNonEmptyString(record["requestId"]);
+      return terminalId === null || requestId === null ? null : { type: "agent.forceSend", terminalId, requestId };
+    }
+    case "agent.rewind": {
+      const terminalId = asNonEmptyString(record["terminalId"]);
+      const eventId = asNonEmptyString(record["eventId"]);
+      const restore = asLiteral(record["restore"], REWIND_RESTORES);
+      const requestId = asNonEmptyString(record["requestId"]);
+      return terminalId === null || eventId === null || restore === null || requestId === null ? null : { type: "agent.rewind", terminalId, eventId, restore, requestId };
+    }
     case "resize": {
       const terminalId = asNonEmptyString(record["terminalId"]);
       const cols = asPositiveInt(record["cols"]);
@@ -934,6 +954,14 @@ function parseClientMessage(raw) {
       }
       return { type: "files.check", terminalId, requestId, paths };
     }
+    case "files.write": {
+      const terminalId = asNonEmptyString(record["terminalId"]);
+      const requestId = asNonEmptyString(record["requestId"]);
+      const writePath = asNonEmptyString(record["path"]);
+      const text = asString(record["text"]);
+      const baseHash = record["baseHash"];
+      return terminalId === null || requestId === null || writePath === null || text === null || !isContentHash(baseHash) ? null : { type: "files.write", terminalId, requestId, path: writePath, text, baseHash };
+    }
     case "plans.read": {
       const terminalId = asNonEmptyString(record["terminalId"]);
       const fileName = asNonEmptyString(record["fileName"]);
@@ -1425,10 +1453,14 @@ import { copyFile, mkdir as mkdir2, open as open2, readdir, readFile as readFile
 import path5 from "node:path";
 
 // packages/server/src/jsonl-reader.ts
-import { open } from "node:fs/promises";
+import { open, stat as stat2 } from "node:fs/promises";
 var CHUNK_SIZE = 64 * 1024;
-async function readHeadLines(filePath, options) {
-  const handle = await open(filePath, "r");
+var DISK_FILES = {
+  size: async (filePath) => (await stat2(filePath)).size,
+  open: (filePath) => open(filePath, "r")
+};
+async function readHeadLines(filePath, options, files = DISK_FILES) {
+  const handle = await files.open(filePath);
   try {
     const lines = [];
     let pending = "";
@@ -1460,8 +1492,8 @@ async function readHeadLines(filePath, options) {
     await handle.close();
   }
 }
-async function readTailLines(filePath, options) {
-  const handle = await open(filePath, "r");
+async function readTailLines(filePath, options, files = DISK_FILES) {
+  const handle = await files.open(filePath);
   try {
     const { size } = await handle.stat();
     if (size === 0) return [];
@@ -1806,14 +1838,6 @@ var ANTIGRAVITY_MODEL_OPTIONS = [
   model("gemini-3.8-flash-high", "Gemini 3.8 Flash (High)"),
   model("gemini-3.8-flash-medium", "Gemini 3.8 Flash (Medium)"),
   model("gemini-3.8-flash-low", "Gemini 3.8 Flash (Low)"),
-  model("gemini-3.7-flash-high", "Gemini 3.7 Flash (High)"),
-  model("gemini-3.7-flash-medium", "Gemini 3.7 Flash (Medium)"),
-  model("gemini-3.7-flash-low", "Gemini 3.7 Flash (Low)"),
-  model("gemini-3.6-flash-high", "Gemini 3.6 Flash (High)"),
-  model("gemini-3.6-flash-medium", "Gemini 3.6 Flash (Medium)"),
-  model("gemini-3.6-flash-low", "Gemini 3.6 Flash (Low)"),
-  model("gemini-3.1-pro-high", "Gemini 3.1 Pro (High)"),
-  model("gemini-3.1-pro-low", "Gemini 3.1 Pro (Low)"),
   model("claude-sonnet-4-6", "Claude Sonnet 4.6 (Thinking)"),
   model("claude-opus-4-6-thinking", "Claude Opus 4.6 (Thinking)"),
   model("gpt-oss-120b-medium", "GPT-OSS 120B (Medium)")
@@ -2251,7 +2275,7 @@ var AntigravityCatalog = class {
 };
 
 // packages/server/src/agents/antigravity/discovery.ts
-import { open as open3, readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { open as open3, readdir as readdir2, stat as stat3 } from "node:fs/promises";
 import path6 from "node:path";
 var CONVERSATION_LINE = /\] (?:Created|Streaming) conversation ([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\s*$/i;
 var PID_LINE = /\] Starting language server process with pid (\d+)\s*$/;
@@ -2466,7 +2490,7 @@ var LogWatcher = class {
       if (!/^cli-.*\.log$/i.test(name) || this.checked.has(name)) continue;
       const file = path6.join(root, name);
       try {
-        const info = await stat2(file);
+        const info = await stat3(file);
         if (!info.isFile() || info.mtimeMs < launchedAt - 2e3) continue;
       } catch {
         continue;
@@ -2522,7 +2546,6 @@ function withoutPastedText(raw) {
 import { stat as stat4 } from "node:fs/promises";
 
 // packages/server/src/agents/jsonl-follower.ts
-import { open as open4, stat as stat3 } from "node:fs/promises";
 var READ_CHUNK_BYTES = 256 * 1024;
 var MAX_EVENTS = 4e3;
 var NEWLINE = 10;
@@ -2537,6 +2560,8 @@ var JsonlFollower = class {
     this.path = filePath;
     this.maxEvents = options.maxEvents ?? MAX_EVENTS;
     this.fingerprintBytes = Math.max(0, Math.floor(options.fingerprintBytes ?? 0));
+    this.files = options.files ?? DISK_FILES;
+    this.isVisible = options.isVisible ?? null;
   }
   sink;
   path;
@@ -2551,6 +2576,8 @@ var JsonlFollower = class {
   fingerprintBytes;
   /** Los primeros `fingerprintBytes` del archivo leido; null sin huella o si todavia no llego a ese tamano. */
   fingerprint = null;
+  files;
+  isVisible;
   get filePath() {
     return this.path;
   }
@@ -2584,22 +2611,28 @@ var JsonlFollower = class {
   }
   /** Ultimos `limit` eventos, que es lo que se quiere ver al abrir el panel. */
   getTail(limit) {
-    const events = this.events.slice(-limit);
+    const visible = this.visibleEvents();
+    const events = visible.slice(-limit);
     return {
       events,
-      hasMore: this.events.length > events.length || this.dropped > 0
+      hasMore: visible.length > events.length || this.dropped > 0
     };
   }
   /** Tramo anterior a un evento ya entregado. Vacio si ese id ya no esta. */
   getPageBefore(beforeEventId, limit) {
-    const index = this.events.findIndex((event2) => event2.eventId === beforeEventId);
+    const visible = this.visibleEvents();
+    const index = visible.findIndex((event2) => event2.eventId === beforeEventId);
     if (index <= 0) return { events: [], hasMore: false };
     const start = Math.max(0, index - limit);
     return {
-      events: this.events.slice(start, index),
+      events: visible.slice(start, index),
       hasMore: start > 0 || this.dropped > 0
     };
   }
+  /** Los eventos que se entregan: todos, salvo los que `isVisible` deja afuera. */
+  visibleEvents() {
+    return this.isVisible === null ? this.events : this.events.filter(this.isVisible);
+  }
   /**
    * Lee lo que haya de nuevo.
    *
@@ -2614,8 +2647,7 @@ var JsonlFollower = class {
     }
     let size;
     try {
-      const info = await stat3(this.path);
-      size = info.size;
+      size = await this.files.size(this.path);
     } catch {
       if (this.events.length > 0 || this.offset > 0) {
         this.reset();
@@ -2638,7 +2670,7 @@ var JsonlFollower = class {
       return { reset: didReset, added: [] };
     }
     const added = await this.readFrom(this.path, size);
-    return { reset: didReset, added };
+    return { reset: didReset, added: this.isVisible === null ? added : added.filter(this.isVisible) };
   }
   reset() {
     this.offset = 0;
@@ -2651,7 +2683,7 @@ var JsonlFollower = class {
   }
   /** true si el archivo todavia empieza con `expected`. */
   async sameFingerprint(filePath, expected) {
-    const handle = await open4(filePath, "r");
+    const handle = await this.files.open(filePath);
     try {
       const head = Buffer.alloc(expected.length);
       const { bytesRead } = await handle.read(head, 0, expected.length, 0);
@@ -2662,7 +2694,7 @@ var JsonlFollower = class {
   }
   async readFrom(filePath, size) {
     const added = [];
-    const handle = await open4(filePath, "r");
+    const handle = await this.files.open(filePath);
     try {
       const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
       while (this.offset < size) {
@@ -4005,7 +4037,9 @@ var ANTIGRAVITY_BASE_CAPABILITIES = {
   contextWindowSource: null,
   plans: false,
   // Con la status line, su confirmacion abierta ya la frena `submitRefusal` (12.7).
-  waitingBlocksSubmit: false
+  waitingBlocksSubmit: false,
+  // Su tecla de "send immediately", Alt+M (hito 45, §12.13). Sin status line no hay cola que forzar.
+  forceSend: true
 };
 var ANTIGRAVITY_STATUS_LINE_CAPABILITIES = {
   ...ANTIGRAVITY_BASE_CAPABILITIES,
@@ -4196,6 +4230,11 @@ function createAntigravityAdapter(options = {}) {
     },
     history: createAntigravityHistory({ statusLine: createFollowerStatusLine(store, isActive) }),
     status,
+    /*
+      La cola no queda escrita en ningun lado que la app lea (hito 45, §12.13):
+      es lo que la app le mando con el agente trabajando. "Enviar ya" es Alt+M.
+    */
+    promptQueue: { source: "app", forceSend: "alt-m" },
     /**
      * El modelo de `settings.json`, provisional hasta la primera respuesta. La
      * etiqueta va entera (`Gemini 3.7 Flash (Low)`): es la familia con la que
@@ -5221,9 +5260,182 @@ function toTurnDuration(record) {
   return { eventId, durationMs };
 }
 
+// packages/server/src/agents/claude-code/branch-tracker.ts
+var BranchTracker = class {
+  nodes = /* @__PURE__ */ new Map();
+  /** La ultima linea que llego. */
+  last = null;
+  /**
+   * El mensaje desde el que se escondio lo que la CLI deshizo sin escribirlo,
+   * o null. Mientras este, la conversacion termina en su padre.
+   */
+  withdrawn = null;
+  hidden = /* @__PURE__ */ new Set();
+  /** Una linea nueva. true si cambio lo que se ve. */
+  observe(line) {
+    if (this.nodes.has(line.uuid)) return false;
+    this.nodes.set(line.uuid, { parent: line.parent, prompt: line.prompt });
+    const previous = this.last;
+    this.last = line.uuid;
+    if (this.withdrawn !== null) {
+      if (!line.speaks && this.descendsFrom(line.uuid, this.withdrawn)) return this.recompute();
+      this.withdrawn = null;
+      return this.recompute();
+    }
+    if (line.mayBranch && previous !== null && line.parent !== previous) return this.recompute();
+    return false;
+  }
+  /**
+   * Esconde desde ese mensaje en adelante: la CLI lo deshizo y todavia no
+   * escribio nada que lo diga. Solo un mensaje del usuario que esta en la
+   * conversacion que se ve. true si cambio lo que se ve.
+   */
+  withdraw(uuid) {
+    const node = this.nodes.get(uuid);
+    if (node === void 0 || !node.prompt || this.withdrawn === uuid) return false;
+    if (!this.pathFrom(this.leaf()).has(uuid)) return false;
+    this.withdrawn = uuid;
+    return this.recompute();
+  }
+  /** El mensaje desde el que se escondio, mientras la CLI no escriba otra cosa. */
+  withdrawnFrom() {
+    return this.withdrawn;
+  }
+  isHidden(uuid) {
+    return this.hidden.has(uuid);
+  }
+  /** Cuantas lineas se esconden. Para el chequeo. */
+  hiddenCount() {
+    return this.hidden.size;
+  }
+  /** El archivo encogio o se reemplazo. */
+  reset() {
+    this.nodes.clear();
+    this.last = null;
+    this.withdrawn = null;
+    this.hidden = /* @__PURE__ */ new Set();
+  }
+  /** Donde termina la conversacion que se ve. */
+  leaf() {
+    if (this.withdrawn === null) return this.last;
+    return this.nodes.get(this.withdrawn)?.parent ?? null;
+  }
+  /** true si `uuid` es `ancestor` o cuelga de el. */
+  descendsFrom(uuid, ancestor) {
+    return this.pathFrom(uuid).has(ancestor);
+  }
+  /** La linea y todas las de las que cuelga. */
+  pathFrom(leaf) {
+    const path63 = /* @__PURE__ */ new Set();
+    let current = leaf;
+    while (current !== null && !path63.has(current)) {
+      const node = this.nodes.get(current);
+      if (node === void 0) break;
+      path63.add(current);
+      current = node.parent;
+    }
+    return path63;
+  }
+  recompute() {
+    const path63 = 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;
+      const list = children.get(key);
+      if (list === void 0) children.set(key, [uuid]);
+      else list.push(uuid);
+    }
+    const roots = [];
+    for (const uuid of children.get(null) ?? []) if (!path63.has(uuid)) roots.push(uuid);
+    for (const uuid of path63) {
+      for (const child of children.get(uuid) ?? []) if (!path63.has(child)) roots.push(child);
+    }
+    const hidden = /* @__PURE__ */ new Set();
+    for (const root of roots) {
+      const subtree = [];
+      const pending = [root];
+      let hasPrompt = false;
+      while (pending.length > 0) {
+        const uuid = pending.pop();
+        subtree.push(uuid);
+        if (this.nodes.get(uuid)?.prompt === true) hasPrompt = true;
+        for (const child of children.get(uuid) ?? []) pending.push(child);
+      }
+      if (hasPrompt) for (const uuid of subtree) hidden.add(uuid);
+    }
+    const changed = hidden.size !== this.hidden.size || [...hidden].some((uuid) => !this.hidden.has(uuid));
+    this.hidden = hidden;
+    return changed;
+  }
+};
+
+// packages/server/src/agents/claude-code/prompt-queue.ts
+var MAX_TRACKED = 100;
+var AGENT_NOTICE = /^\s*<(task-notification|agent-message)\b/;
+function queuedPromptOf(content, id, at) {
+  if (AGENT_NOTICE.test(content)) return null;
+  const { text: withoutImages, images } = takePastedImages(cleanUserText(content));
+  const text = withoutImages.trim();
+  if (text.length === 0 && images.length === 0) return null;
+  return {
+    id,
+    text: text.slice(0, MAX_QUEUED_PROMPT_CHARS),
+    truncated: text.length > MAX_QUEUED_PROMPT_CHARS,
+    images: images.length,
+    at
+  };
+}
+var PromptQueueTracker = class {
+  queue = [];
+  seq = 0;
+  /** Una linea del JSONL, ya parseada. Nunca lanza: el esquema cambia. */
+  observe(record) {
+    if (record["type"] !== "queue-operation") return;
+    const operation = record["operation"];
+    const content = typeof record["content"] === "string" ? record["content"] : null;
+    if (operation === "enqueue") {
+      if (content === null) return;
+      this.seq += 1;
+      this.queue.push({ seq: this.seq, content, at: readTimestamp(record["timestamp"]) });
+      if (this.queue.length > MAX_TRACKED) this.queue.shift();
+      return;
+    }
+    if (operation === "dequeue") {
+      this.queue.shift();
+      return;
+    }
+    if (content === null) return;
+    const index = this.queue.findIndex((item) => item.content === content);
+    if (index !== -1) this.queue.splice(index, 1);
+  }
+  /**
+   * Los mensajes del usuario en cola del proceso lanzado en `launchedAt` o
+   * despues, en orden. Uno sin hora no se puede atribuir a ningun proceso y no
+   * cuenta.
+   *
+   * Lo de un proceso anterior ademas se olvida: quedo en una cola que ya no
+   * existe, y si siguiera adelante el `dequeue` del proceso de ahora sacaria
+   * ese en vez del suyo.
+   */
+  pending(launchedAt) {
+    this.queue = this.queue.filter((item) => item.at > 0 && item.at >= launchedAt);
+    const result = [];
+    for (const item of this.queue) {
+      const prompt = queuedPromptOf(item.content, `queue-${item.seq}`, item.at);
+      if (prompt !== null) result.push(prompt);
+      if (result.length >= MAX_QUEUED_PROMPTS) break;
+    }
+    return result;
+  }
+  /** El archivo se reemplazo: lo anotado era de otra lectura. */
+  reset() {
+    this.queue = [];
+  }
+};
+
 // packages/server/src/agents/claude-code/subagent-tracker.ts
 var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
-var MAX_TRACKED = 50;
+var MAX_TRACKED2 = 50;
 var NOTIFICATION = /<task-notification>([\s\S]*?)<\/task-notification>/g;
 var TOOL_USE_ID = /<tool-use-id>\s*([^<\s]+)\s*<\/tool-use-id>/;
 function labelOf(value) {
@@ -5318,7 +5530,7 @@ var SubagentTracker = class {
         background: input?.["run_in_background"] === true,
         startedAt
       });
-      if (this.pending.size > MAX_TRACKED) {
+      if (this.pending.size > MAX_TRACKED2) {
         const oldest = this.pending.keys().next();
         if (!oldest.done) this.pending.delete(oldest.value);
       }
@@ -5375,7 +5587,10 @@ var ConversationFollower = class {
     this.installVariants = installVariants;
     this.limits = options.limits ?? TRANSPORT_LIMITS;
     this.target = options.target ?? { cwd: "", sessionId: "" };
-    this.jsonl = new JsonlFollower(filePath, this, { maxEvents: options.maxEvents });
+    this.jsonl = new JsonlFollower(filePath, this, {
+      maxEvents: options.maxEvents,
+      isVisible: (event2) => !this.branch.isHidden(event2.eventId)
+    });
   }
   installVariants;
   /** La lectura del archivo. Esta clase es su sink. */
@@ -5441,8 +5656,20 @@ var ConversationFollower = class {
    * —el aviso de fin es una `queue-operation`—, asi que va antes de todo filtro.
    */
   subagents = new SubagentTracker();
+  /**
+   * Los mensajes que esperan en la cola de la CLI (hito 45, §4.4.3). Tambien
+   * son lineas que no son tarjetas (`queue-operation`): va antes de todo filtro.
+   */
+  promptQueue = new PromptQueueTracker();
   /** Los topes de cada parte. Los de transporte salvo que se lea para la copia propia. */
   limits;
+  /**
+   * Que ramas del archivo quedaron abandonadas (hito 44, §4.16): un mensaje que
+   * se deshizo no se entrega. Va antes que `jsonl`, que lo consulta.
+   */
+  branch = new BranchTracker();
+  /** true si en la lectura en curso cambio lo que se ve: el `poll` avisa un reinicio. */
+  branchChanged = false;
   /** La pestana cuyos documentos se reconocen. Ver el constructor. */
   target;
   /** La ruta que se sigue. Siempre fija: esta CLI la conoce al lanzar. */
@@ -5497,6 +5724,10 @@ var ConversationFollower = class {
   runningSubagents(launchedAt) {
     return this.subagents.running(launchedAt);
   }
+  /** Los mensajes del proceso de `launchedAt` que esperan en la cola de la CLI (§4.4.3). */
+  queuedPrompts(launchedAt) {
+    return this.promptQueue.pending(launchedAt);
+  }
   /** Ultimos `limit` eventos, que es lo que se quiere ver al abrir el panel. */
   getTail(limit) {
     return this.jsonl.getTail(limit);
@@ -5515,7 +5746,10 @@ var ConversationFollower = class {
     this.turns = [];
     this.partUpdates = [];
     this.freshPlans = [];
-    const { reset, added } = await this.jsonl.poll();
+    const read = await this.jsonl.poll();
+    const { added } = read;
+    const reset = read.reset || this.branchChanged;
+    this.branchChanged = false;
     const fresh = new Set(added.map((event2) => event2.eventId));
     const turns = this.turns.filter((turn) => !fresh.has(turn.eventId));
     const parts = [
@@ -5543,6 +5777,18 @@ var ConversationFollower = class {
     this.attachmentRoots.clear();
     this.planFiles = [];
     this.subagents.reset();
+    this.promptQueue.reset();
+    this.branch.reset();
+  }
+  /**
+   * Esconde desde ese mensaje: la CLI lo deshizo y todavia no escribio nada
+   * (hito 44). true si cambio lo que se ve; quien llama avisa el reinicio.
+   */
+  withdrawFrom(eventId) {
+    return this.branch.withdraw(eventId);
+  }
+  withdrawnFrom() {
+    return this.branch.withdrawnFrom();
   }
   /** true si la linea es la invocacion de `/model` que la CLI guarda. */
   mentionsModelCommand(record) {
@@ -5559,7 +5805,29 @@ var ConversationFollower = class {
    * los que ya guardo, para pegarle a uno anterior la duracion o una imagen.
    */
   consume(record, lineNumber, events) {
+    const event2 = this.consumeRecord(record, lineNumber, events);
+    this.observeBranch(record, event2);
+    return event2;
+  }
+  /**
+   * Anota la linea en el arbol de la conversacion (hito 44, §4.16). Solo las de
+   * la cadena principal: las de un subagente son otra conversacion.
+   */
+  observeBranch(record, event2) {
+    const uuid = record["uuid"];
+    if (typeof uuid !== "string" || uuid.length === 0 || record["isSidechain"] === true) return;
+    if (!Object.prototype.hasOwnProperty.call(record, "parentUuid")) return;
+    const parentUuid = record["parentUuid"];
+    const logicalParent = record["logicalParentUuid"];
+    const parent = typeof parentUuid === "string" && parentUuid.length > 0 ? parentUuid : typeof logicalParent === "string" && logicalParent.length > 0 ? logicalParent : null;
+    const prompt = event2 !== null && event2.role === "user" && event2.parts.some((part) => part.kind === "text" || part.kind === "image");
+    const mayBranch = record["type"] === "user" && !isToolResultRecord(record);
+    const speaks = record["type"] === "user" || record["type"] === "assistant";
+    if (this.branch.observe({ uuid, parent, prompt, mayBranch, speaks })) this.branchChanged = true;
+  }
+  consumeRecord(record, lineNumber, events) {
     this.subagents.observe(record);
+    this.promptQueue.observe(record);
     if (record["type"] === "cost-state") {
       this.sessionVariants.observeCostState(record, Date.now());
       this.recomputeModel();
@@ -5747,9 +6015,15 @@ var ConversationFollower = class {
     return model2;
   }
 };
+function isToolResultRecord(record) {
+  const message = record["message"];
+  if (typeof message !== "object" || message === null) return false;
+  const content = message["content"];
+  return Array.isArray(content) && content.some((block) => typeof block === "object" && block !== null && block["type"] === "tool_result");
+}
 
 // packages/server/src/agents/claude-code/conversation-image.ts
-import { open as open5, readFile as readFile9, stat as stat10 } from "node:fs/promises";
+import { open as open4, readFile as readFile9, stat as stat10 } from "node:fs/promises";
 import path18 from "node:path";
 
 // packages/server/src/image-signature.ts
@@ -5783,7 +6057,7 @@ var CHUNK_SIZE2 = 256 * 1024;
 var NEWLINE2 = 10;
 var MAX_IMAGE_BYTES = MAX_SUBMIT_IMAGE_BYTES;
 async function loadConversationImage(filePath, eventId, index, source = "content", pastedDir = pasteRoot()) {
-  const handle = await open5(filePath, "r").catch(() => null);
+  const handle = await open4(filePath, "r").catch(() => null);
   if (handle === null) return null;
   try {
     if (source === "pasted") return await findPastedImage(linesOf(handle), eventId, index, pastedDir);
@@ -6050,6 +6324,17 @@ var ClaudeCodeSessionFollower = class {
   runningSubagents(launchedAt) {
     return this.inner.runningSubagents(launchedAt);
   }
+  /** Los mensajes del proceso de `launchedAt` que esperan en la cola de la CLI (hito 45, §4.4.3). */
+  queuedPrompts(launchedAt) {
+    return this.inner.queuedPrompts(launchedAt);
+  }
+  /** Esconde desde un mensaje que la CLI deshizo sin escribirlo todavia (hito 44, §4.16). */
+  withdrawFrom(eventId) {
+    return this.inner.withdrawFrom(eventId);
+  }
+  withdrawnFrom() {
+    return this.inner.withdrawnFrom();
+  }
 };
 
 // packages/server/src/agents/claude-code/session-scan.ts
@@ -6293,6 +6578,328 @@ function autoAnswerResumeDialog(options) {
   return () => finish("cancelled");
 }
 
+// packages/server/src/agents/claude-code/handback.ts
+import { stat as stat13 } from "node:fs/promises";
+
+// packages/server/src/debug.ts
+var enabled = process.env["AGENT_WORKBENCH_DEBUG"] === "1";
+function debugLog(scope, message) {
+  if (!enabled) return;
+  console.log(`[${scope}] ${message}`);
+}
+
+// packages/server/src/agents/claude-code/handback.ts
+var CLAUDE_CODE_CLEAR_GAP_MS = 2e3;
+var TAIL_BYTES = 512 * 1024;
+var MAX_TAIL_BYTES = 32 * 1024 * 1024;
+var HOUR_SLACK_MS = 2e3;
+var INTERRUPTED_MARKER = "[Request interrupted by user";
+var SETTLE_WITHOUT_STAMP_MS = 800;
+var FLUSH_GRACE_MS = 3e3;
+function normalize(text) {
+  return cleanUserText(text).replace(/\s+/g, " ").trim();
+}
+function promptTextOf(record) {
+  if (record["type"] !== "user" || record["isMeta"] === true || record["isSidechain"] === true) return null;
+  const message = record["message"];
+  if (typeof message !== "object" || message === null) return null;
+  const content = message["content"];
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const texts = [];
+  for (const block of content) {
+    if (typeof block !== "object" || block === null) continue;
+    const record2 = block;
+    if (record2["type"] === "tool_result") return null;
+    if (record2["type"] === "text" && typeof record2["text"] === "string") texts.push(record2["text"]);
+  }
+  return texts.length === 0 ? null : texts.join("\n");
+}
+function findHandedBack(lines, submissions, interruptedAt) {
+  const records = lines.map((line) => parseJsonlLine(line));
+  const found = [];
+  for (const submission of submissions) {
+    const wanted = normalize(submission.text);
+    if (wanted.length === 0) continue;
+    let at = -1;
+    for (let index = records.length - 1; index >= 0; index -= 1) {
+      const record = records[index];
+      if (record === null || record === void 0) continue;
+      const text = promptTextOf(record);
+      if (text !== null && normalize(text) === wanted) {
+        at = index;
+        break;
+      }
+    }
+    if (at === -1) continue;
+    const line = records[at];
+    const uuid = line["uuid"];
+    if (typeof uuid !== "string" || uuid.length === 0) continue;
+    if (readTimestamp(line["timestamp"]) > interruptedAt + HOUR_SLACK_MS) continue;
+    const parent = records.find((record) => record !== null && record !== void 0 && record["uuid"] === line["parentUuid"]);
+    if (parent !== void 0 && parent !== null && (promptTextOf(parent) ?? "").startsWith(INTERRUPTED_MARKER)) continue;
+    let answered = false;
+    for (let index = at + 1; index < records.length; index += 1) {
+      const record = records[index];
+      if (record === null || record === void 0 || record["isSidechain"] === true) continue;
+      if (record["type"] === "assistant" || record["type"] === "user") {
+        answered = true;
+        break;
+      }
+    }
+    if (answered) continue;
+    found.push({ text: submission.original ?? submission.text, eventId: uuid });
+  }
+  return found;
+}
+function holdsTwoTurns(lines) {
+  let count = 0;
+  for (const line of lines) {
+    const record = parseJsonlLine(line);
+    if (record === null || record["isSidechain"] === true) continue;
+    if (record["type"] === "user" || record["type"] === "assistant") count += 1;
+    if (count >= 2) return true;
+  }
+  return false;
+}
+async function readLastTurns(file) {
+  const { size } = await stat13(file);
+  for (let window = TAIL_BYTES; ; window *= 4) {
+    const lines = await readTailLines(file, { maxBytes: window });
+    if (window >= size || window >= MAX_TAIL_BYTES || holdsTwoTurns(lines)) return lines;
+  }
+}
+function settledAfter(status, interruptedAt, now) {
+  if (status === null || status.status !== "idle") return false;
+  if (status.statusUpdatedAt !== null) return status.statusUpdatedAt >= interruptedAt;
+  return now - interruptedAt >= SETTLE_WITHOUT_STAMP_MS;
+}
+function createClaudeCodeHandback(deps) {
+  const now = deps.now ?? Date.now;
+  return {
+    clearGapMs: CLAUDE_CODE_CLEAR_GAP_MS,
+    returnReason: "stopped-early",
+    async check(target, submissions, interruptedAt) {
+      try {
+        const status = await deps.status(target.sessionId);
+        const lines = await readLastTurns(deps.sessionFile(target.cwd, target.sessionId));
+        const found = findHandedBack(lines, submissions, interruptedAt);
+        const settled = settledAfter(status, interruptedAt, now());
+        debugLog("write", `handback check: status ${status?.status ?? "none"}, settled ${settled}, handed back ${found.length}`);
+        return {
+          settled,
+          undelivered: found.map((each) => each.text),
+          withdrawn: found.map((each) => each.eventId),
+          // Sin la CLI libre, o sin la linea todavia en disco, no se concluye nada.
+          pending: !settled || found.length === 0 && now() - interruptedAt < FLUSH_GRACE_MS
+        };
+      } catch {
+        debugLog("write", "handback check: no session file yet");
+        return { settled: false, undelivered: [], pending: true };
+      }
+    }
+  };
+}
+
+// packages/server/src/agents/claude-code/rewind-menu.ts
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+var ESC = "\x1B";
+var UP = "\x1B[A";
+var DOWN = "\x1B[B";
+var ENTER = "\r";
+var CLEAR = "";
+var MARKER = "\u276F";
+var REWIND_OPTION_CODE_AND_CONVERSATION = "Restore code and conversation";
+var REWIND_OPTION_CONVERSATION = "Restore conversation";
+var ARROWS = /^[↑↓]\s*/;
+function readRewindScreen(lines) {
+  const header = lines.findIndex((line) => line.trim() === "Rewind");
+  if (header === -1) return { kind: "none" };
+  const rest = lines.slice(header + 1).filter((line) => line.trim().length > 0);
+  const intro = rest[0]?.trim() ?? "";
+  if (intro.startsWith("Restore the code and/or conversation")) {
+    const block = [];
+    let selected;
+    for (const raw of rest.slice(1)) {
+      const line = raw.trim();
+      if (line.startsWith("Enter to continue")) break;
+      block.push(line);
+      if (selected === void 0 && line.startsWith(MARKER)) {
+        const text = line.slice(MARKER.length).trim();
+        selected = text === "(current)" ? null : text;
+      }
+    }
+    if (selected === void 0) return { kind: "none" };
+    return { kind: "list", selected, block: block.join("\n") };
+  }
+  if (intro.startsWith("Confirm you want to restore")) {
+    const quoted = [];
+    const options = [];
+    const block = [];
+    for (const raw of rest.slice(1)) {
+      const line = raw.trim();
+      if (line.length === 0) continue;
+      block.push(line);
+      if (line.startsWith("\u2502")) {
+        const text = line.slice(1).trim();
+        if (!/^\(.*\bago\)$/.test(text)) quoted.push(text);
+        continue;
+      }
+      const selected = line.startsWith(MARKER);
+      const option = /^(\d+)\.\s+(.+)$/.exec(line.replace(MARKER, "").replace(ARROWS, "").trim());
+      if (option !== null) {
+        options.push({ number: Number(option[1]), label: (option[2] ?? "").trim(), selected });
+      }
+    }
+    return { kind: "confirm", quoted, options, block: block.join("\n") };
+  }
+  return { kind: "none" };
+}
+function comparable(text) {
+  return text.replace(/@"[^"]*"/g, " ").replace(/\[Image #\d+\]/g, " ").replace(/\s+/g, " ").trim();
+}
+function shownMatches(shown, firstLine2) {
+  const cut2 = /…\s*$/.test(shown);
+  const visible = comparable(shown.replace(/…\s*$/, ""));
+  const wanted = comparable(firstLine2);
+  if (visible.length === 0 || wanted.length === 0) return false;
+  return cut2 ? wanted.startsWith(visible) : wanted === visible;
+}
+function editorLine(lines) {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = (lines[index] ?? "").trim();
+    if (line.startsWith(MARKER)) return line.slice(MARKER.length).trim();
+  }
+  return null;
+}
+function editorHolds(lines, firstLine2) {
+  const text = editorLine(lines);
+  if (text === null || text.length === 0) return false;
+  return shownMatches(text.endsWith("\u2026") ? text : `${text}\u2026`, firstLine2) || /^\[Pasted text #\d+/.test(text);
+}
+var DEFAULT_TIMING = { keyGapMs: 150, stepTimeoutMs: 3e3, pollMs: 50 };
+async function waitForScreen(io, timing, accept) {
+  const deadline = io.now() + timing.stepTimeoutMs;
+  let candidate = null;
+  for (; ; ) {
+    const lines = await io.screen();
+    const screen = readRewindScreen(lines);
+    const key = screen.kind === "none" ? editorLine(lines) ?? "" : screen.block;
+    if (accept(screen, lines)) {
+      if (candidate === key) return { screen, lines, ok: true };
+      candidate = key;
+    } else {
+      candidate = null;
+    }
+    if (io.now() >= deadline) return { screen, lines, ok: false };
+    await io.wait(timing.pollMs);
+  }
+}
+async function closeMenu(io, timing) {
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    if (readRewindScreen(await io.screen()).kind === "none") return;
+    if (!io.write(ESC)) return;
+    await waitForScreen(io, timing, (screen) => screen.kind === "none");
+  }
+}
+async function fail(io, timing, reason2) {
+  await closeMenu(io, timing);
+  return { kind: "failed", reason: reason2 };
+}
+async function runRewind(io, request, timing = DEFAULT_TIMING) {
+  if (!io.write(ESC)) return { kind: "failed", reason: "gone" };
+  await io.wait(timing.keyGapMs);
+  if (!io.write(ESC)) return { kind: "failed", reason: "gone" };
+  let current = await waitForScreen(io, timing, (screen) => screen.kind === "list");
+  if (!current.ok) return fail(io, timing, "menu-not-open");
+  let matches2 = 0;
+  for (let step2 = 0; ; step2 += 1) {
+    if (step2 >= request.maxSteps) return fail(io, timing, "message-not-found");
+    const before = current.screen.kind === "list" ? current.screen.block : "";
+    if (!io.write(UP)) return { kind: "failed", reason: "gone" };
+    current = await waitForScreen(io, timing, (screen) => screen.kind === "list" && screen.block !== before);
+    if (!current.ok || current.screen.kind !== "list") return fail(io, timing, "message-not-found");
+    const selected = current.screen.selected;
+    if (selected !== null && shownMatches(selected, request.firstLine)) {
+      matches2 += 1;
+      if (matches2 >= request.occurrence) break;
+    }
+  }
+  if (!io.write(ENTER)) return { kind: "failed", reason: "gone" };
+  current = await waitForScreen(io, timing, (screen) => screen.kind === "confirm");
+  if (!current.ok || current.screen.kind !== "confirm") return fail(io, timing, "not-confirmed");
+  const quotedFirst = current.screen.quoted[0] ?? "";
+  if (!shownMatches(quotedFirst, request.firstLine) && !shownMatches(`${quotedFirst}\u2026`, request.firstLine)) {
+    return fail(io, timing, "message-not-found");
+  }
+  let codeRestored = request.restoreCode;
+  let wanted = current.screen.options.find(
+    (option) => option.label === (request.restoreCode ? REWIND_OPTION_CODE_AND_CONVERSATION : REWIND_OPTION_CONVERSATION)
+  );
+  if (wanted === void 0 && request.restoreCode) {
+    wanted = current.screen.options.find((option) => option.label === REWIND_OPTION_CONVERSATION);
+    codeRestored = false;
+  }
+  const marked = current.screen.options.find((option) => option.selected);
+  if (wanted === void 0 || marked === void 0) return fail(io, timing, "option-missing");
+  const key = wanted.number > marked.number ? DOWN : UP;
+  for (let moves = Math.abs(wanted.number - marked.number); moves > 0; moves -= 1) {
+    const before = current.screen.kind === "confirm" ? current.screen.block : "";
+    if (!io.write(key)) return { kind: "failed", reason: "gone" };
+    current = await waitForScreen(io, timing, (screen) => screen.kind === "confirm" && screen.block !== before);
+    if (!current.ok || current.screen.kind !== "confirm") return fail(io, timing, "option-missing");
+  }
+  const chosen = current.screen.kind === "confirm" ? current.screen.options.find((option) => option.selected) : void 0;
+  if (chosen === void 0 || chosen.label !== wanted.label) return fail(io, timing, "option-missing");
+  if (!io.write(ENTER)) return { kind: "failed", reason: "gone" };
+  current = await waitForScreen(io, timing, (screen) => screen.kind === "none");
+  let editorCleared = false;
+  const holding = await waitForScreen(io, timing, (_screen, lines) => editorHolds(lines, request.firstLine));
+  if (holding.ok && io.write(CLEAR)) {
+    const cleared = await waitForScreen(io, timing, (_screen, lines) => !editorHolds(lines, request.firstLine));
+    editorCleared = cleared.ok;
+  }
+  return { kind: "done", codeRestored, editorCleared };
+}
+async function readPromptText(cwd, sessionId, uuid) {
+  const stream = createReadStream(sessionFilePath(cwd, sessionId), { encoding: "utf8" });
+  const failed = new Promise((resolve) => stream.once("error", () => resolve(null)));
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  const found = (async () => {
+    try {
+      for await (const line of lines) {
+        if (!line.includes(uuid)) continue;
+        const record = parseJsonlLine(line.trim());
+        if (record === null || record["uuid"] !== uuid) continue;
+        const message = record["message"];
+        if (typeof message !== "object" || message === null) return null;
+        const content = message["content"];
+        const raw = typeof content === "string" ? content : Array.isArray(content) ? content.flatMap(
+          (block) => typeof block === "object" && block !== null && block["type"] === "text" ? [String(block["text"] ?? "")] : []
+        ).join("\n") : null;
+        if (raw === null) return null;
+        return cleanUserText(raw).replace(/@"[^"]*\.(?:png|jpe?g|gif|webp)"/gi, "").replace(/[ \t]+\n/g, "\n").trim();
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  })();
+  try {
+    return await Promise.race([found, failed]);
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+function createClaudeCodeRewind(timing = DEFAULT_TIMING) {
+  return {
+    run: (io, request) => runRewind(io, request, timing),
+    fullText: (target, eventId) => readPromptText(target.cwd, target.sessionId, eventId)
+  };
+}
+
 // packages/server/src/agents/claude-code/index.ts
 var CLAUDE_CODE_CAPABILITIES = {
   sessionIdAtLaunch: true,
@@ -6315,7 +6922,9 @@ var CLAUDE_CODE_CAPABILITIES = {
   contextWindowSource: "usage-with-variants",
   plans: true,
   // Hito 29: sin candado nuevo. Con la CLI esperando, el cuadro manda como siempre.
-  waitingBlocksSubmit: false
+  waitingBlocksSubmit: false,
+  // Su tecla de "enviar ya", Ctrl+X Ctrl+S, medida con la 2.1.301 (hito 45, §4.4.3).
+  forceSend: true
 };
 var CLAUDE_CODE_INPUT = {
   imageReference: "at-quoted",
@@ -6399,6 +7008,18 @@ function createClaudeCodeAdapter() {
     },
     history: createClaudeCodeHistory(variants),
     status,
+    /*
+      Un mensaje detenido antes de que el agente hiciera nada: la CLI lo deshace
+      y lo devuelve a su caja, y la app lo trae al cuadro (hito 44, §4.16).
+    */
+    queuedSubmits: createClaudeCodeHandback({
+      sessionFile: sessionFilePath,
+      status: (sessionId) => watcher.read(sessionId)
+    }),
+    // Volver a antes de un mensaje con el menu de rewind de la CLI (hito 44, §4.16).
+    rewind: createClaudeCodeRewind(),
+    // La cola la dice el JSONL (hito 45, §4.4.3), y "enviar ya" es su tecla.
+    promptQueue: { source: "session", forceSend: "ctrl-x-ctrl-s" },
     defaults: (cwd, sessionModel) => readAgentDefaults(cwd, sessionModel ?? null),
     /** La carpeta de la CLI. No se lista ni se entra: regla 2.1. */
     protectedDirs: () => [path21.join(homedir5(), ".claude")],
@@ -6408,19 +7029,12 @@ function createClaudeCodeAdapter() {
 
 // packages/server/src/agents/codex/index.ts
 import { homedir as homedir7 } from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 
 // packages/server/src/agents/codex/discovery.ts
-import { stat as stat13 } from "node:fs/promises";
+import { stat as stat14 } from "node:fs/promises";
 import path24 from "node:path";
 
-// packages/server/src/debug.ts
-var enabled = process.env["AGENT_WORKBENCH_DEBUG"] === "1";
-function debugLog(scope, message) {
-  if (!enabled) return;
-  console.log(`[${scope}] ${message}`);
-}
-
 // packages/server/src/agents/codex/find-rollout.ts
 import { readdir as readdir8 } from "node:fs/promises";
 import path23 from "node:path";
@@ -6464,6 +7078,10 @@ function codexArchivedRoot() {
   const home = codexHome();
   return home === null ? null : path22.join(home, "archived_sessions");
 }
+function parseCompressedRolloutFileName(name) {
+  if (!name.toLowerCase().endsWith(".jsonl.zst")) return null;
+  return parseRolloutFileName(name.slice(0, -".zst".length));
+}
 function parseRolloutFileName(name) {
   const match = ROLLOUT_FILE_PATTERN.exec(name);
   if (match === null) return null;
@@ -6520,15 +7138,18 @@ async function entriesOf(folder) {
 async function numberedFolders(folder, pattern) {
   return (await entriesOf(folder)).filter((entry) => entry.isDirectory() && pattern.test(entry.name)).map((entry) => entry.name).sort();
 }
-async function rolloutFilesIn(folder) {
-  return (await entriesOf(folder)).filter((entry) => entry.isFile() && parseRolloutFileName(entry.name) !== null).map((entry) => entry.name).sort().map((name) => path23.join(folder, name));
+async function filesIn(folder, parse) {
+  return (await entriesOf(folder)).filter((entry) => entry.isFile() && parse(entry.name) !== null).map((entry) => entry.name).sort().map((name) => path23.join(folder, name));
+}
+function rolloutFilesIn(folder) {
+  return filesIn(folder, parseRolloutFileName);
 }
-async function walkSessionFiles(root, limit = Number.POSITIVE_INFINITY) {
+async function walk(root, limit, parse) {
   const files = [];
   for (const year of await numberedFolders(root, YEAR)) {
     for (const month of await numberedFolders(path23.join(root, year), TWO_DIGITS)) {
       for (const day of await numberedFolders(path23.join(root, year, month), TWO_DIGITS)) {
-        for (const file of await rolloutFilesIn(path23.join(root, year, month, day))) {
+        for (const file of await filesIn(path23.join(root, year, month, day), parse)) {
           files.push(file);
           if (files.length >= limit) return files;
         }
@@ -6537,13 +7158,31 @@ async function walkSessionFiles(root, limit = Number.POSITIVE_INFINITY) {
   }
   return files;
 }
-function matching(files, sessionId) {
+function walkSessionFiles(root, limit = Number.POSITIVE_INFINITY) {
+  return walk(root, limit, parseRolloutFileName);
+}
+function compressedRolloutFilesIn(folder) {
+  return filesIn(folder, parseCompressedRolloutFileName);
+}
+function walkCompressedSessionFiles(root, limit = Number.POSITIVE_INFINITY) {
+  return walk(root, limit, parseCompressedRolloutFileName);
+}
+function matching(files, sessionId, parse) {
   for (const file of files) {
-    if (parseRolloutFileName(path23.basename(file))?.sessionId === sessionId) return file;
+    if (parse(path23.basename(file))?.sessionId === sessionId) return file;
   }
   return null;
 }
-async function findRollout(sessionId, roots = {}) {
+function findRollout(sessionId, roots = {}) {
+  return find(sessionId, roots, parseRolloutFileName);
+}
+function findCompressedRollout(sessionId, roots = {}) {
+  return find(sessionId, roots, parseCompressedRolloutFileName);
+}
+async function findReadableRollout(sessionId, roots = {}) {
+  return await findRollout(sessionId, roots) ?? await findCompressedRollout(sessionId, roots);
+}
+async function find(sessionId, roots, parse) {
   const id = sessionId.toLowerCase();
   if (!isUuid(id)) return null;
   const sessionsRoot3 = roots.sessionsRoot !== void 0 ? roots.sessionsRoot : codexSessionsRoot();
@@ -6551,16 +7190,16 @@ async function findRollout(sessionId, roots = {}) {
   const ms = uuidV7Millis(id);
   if (ms !== null && sessionsRoot3 !== null) {
     for (const folder of localDayFolders(sessionsRoot3, ms - DAY_MS, ms + DAY_MS)) {
-      const found = matching(await rolloutFilesIn(folder), id);
+      const found = matching(await filesIn(folder, parse), id, parse);
       if (found !== null) return found;
     }
   }
   if (archivedRoot !== null) {
-    const found = matching(await rolloutFilesIn(archivedRoot), id);
+    const found = matching(await filesIn(archivedRoot, parse), id, parse);
     if (found !== null) return found;
   }
   if (ms === null && sessionsRoot3 !== null) {
-    return matching(await walkSessionFiles(sessionsRoot3, FULL_WALK_MAX_FILES), id);
+    return matching(await walk(sessionsRoot3, FULL_WALK_MAX_FILES, parse), id, parse);
   }
   return null;
 }
@@ -6693,8 +7332,7 @@ function readToolOutput(output, maxChars = TOOL_RESULT_MAX_CHARS) {
       isError = exitCode !== null && exitCode !== 0;
     } else {
       text = output;
-      const match = /^Exit code: (\d+)/.exec(output);
-      isError = match !== null && Number(match[1]) !== 0;
+      isError = commandFailed(output);
     }
   } else if (Array.isArray(output)) {
     ({ text, imageCount } = readOutputItems(output));
@@ -6709,6 +7347,14 @@ function readToolOutput(output, maxChars = TOOL_RESULT_MAX_CHARS) {
   const limited = cut(text, maxChars);
   return { text: limited.text, truncated: limited.truncated, isError, imageCount };
 }
+function commandFailed(output) {
+  const legacy = /^Exit code: (-?\d+)/.exec(output);
+  if (legacy !== null) return Number(legacy[1]) !== 0;
+  const headerEnd = output.indexOf("\nOutput:");
+  if (headerEnd === -1) return false;
+  const unified = /^Process exited with code (-?\d+)\r?$/m.exec(output.slice(0, headerEnd));
+  return unified !== null && Number(unified[1]) !== 0;
+}
 function parseObject(raw) {
   try {
     return asRecord(JSON.parse(raw));
@@ -6907,7 +7553,7 @@ var CodexSessionDiscovery = class {
         if (this.seen.has(filePath)) continue;
         let info;
         try {
-          info = await stat13(filePath);
+          info = await stat14(filePath);
         } catch {
           continue;
         }
@@ -6994,8 +7640,76 @@ var CodexSessionDiscovery = class {
 };
 
 // packages/server/src/agents/codex/history.ts
-import { stat as stat14 } from "node:fs/promises";
-import path26 from "node:path";
+import { stat as stat16 } from "node:fs/promises";
+import path27 from "node:path";
+
+// packages/server/src/agents/codex/compressed-rollout.ts
+import { readFile as readFile10, stat as stat15 } from "node:fs/promises";
+import path25 from "node:path";
+import { Decompress } from "fzstd";
+var COMPRESSED_ROLLOUT_SUFFIX = ".zst";
+var COMPRESSED_ROLLOUT_MAX_BYTES = 64 * 1024 * 1024;
+var DECOMPRESSED_ROLLOUT_MAX_BYTES = 256 * 1024 * 1024;
+function isCompressedRollout(filePath) {
+  return filePath.toLowerCase().endsWith(`.jsonl${COMPRESSED_ROLLOUT_SUFFIX}`);
+}
+function plainRolloutPathOf(compressedPath) {
+  return compressedPath.slice(0, -COMPRESSED_ROLLOUT_SUFFIX.length);
+}
+function compressedRolloutPathOf(plainPath) {
+  return `${plainPath}${COMPRESSED_ROLLOUT_SUFFIX}`;
+}
+function decompressRolloutBytes(compressed) {
+  const chunks = [];
+  let total = 0;
+  const stream = new Decompress((chunk) => {
+    total += chunk.length;
+    if (total > DECOMPRESSED_ROLLOUT_MAX_BYTES) {
+      throw new Error(`Compressed rollout over ${DECOMPRESSED_ROLLOUT_MAX_BYTES} bytes once decompressed`);
+    }
+    chunks.push(chunk);
+  });
+  stream.push(compressed, true);
+  return Buffer.concat(chunks, total);
+}
+async function readCompressedRollout(filePath) {
+  const info = await stat15(filePath);
+  if (info.size > COMPRESSED_ROLLOUT_MAX_BYTES) {
+    throw new Error(`Compressed rollout over ${COMPRESSED_ROLLOUT_MAX_BYTES} bytes: ${path25.basename(filePath)}`);
+  }
+  return decompressRolloutBytes(await readFile10(filePath));
+}
+function memoryHandle(data) {
+  return {
+    async read(buffer, offset, length, position) {
+      const start = Math.min(Math.max(0, position), data.length);
+      const end = Math.min(data.length, start + Math.max(0, length));
+      const bytesRead = data.copy(buffer, offset, start, end);
+      return { bytesRead };
+    },
+    async stat() {
+      return { size: data.length };
+    },
+    async close() {
+    }
+  };
+}
+function createRolloutFiles() {
+  let cached = null;
+  const decompressed = async (filePath) => {
+    const info = await stat15(filePath);
+    if (cached !== null && cached.filePath === filePath && cached.mtimeMs === info.mtimeMs && cached.size === info.size) {
+      return cached.data;
+    }
+    const data = await readCompressedRollout(filePath);
+    cached = { filePath, mtimeMs: info.mtimeMs, size: info.size, data };
+    return data;
+  };
+  return {
+    size: async (filePath) => isCompressedRollout(filePath) ? (await decompressed(filePath)).length : DISK_FILES.size(filePath),
+    open: async (filePath) => isCompressedRollout(filePath) ? memoryHandle(await decompressed(filePath)) : DISK_FILES.open(filePath)
+  };
+}
 
 // packages/server/src/agents/codex/rollout-scan.ts
 var TAIL_MAX_BYTES2 = 256 * 1024;
@@ -7023,6 +7737,7 @@ function listableMeta(line, item) {
 }
 async function scanRollout(item) {
   const found = { meta: null };
+  const files = createRolloutFiles();
   const head = await readHeadLines(item.ref, {
     maxLines: ROLLOUT_HEAD_MAX_LINES,
     maxBytes: ROLLOUT_HEAD_MAX_BYTES,
@@ -7031,7 +7746,7 @@ async function scanRollout(item) {
       found.meta = listableMeta(line, item);
       return found.meta === null;
     }
-  });
+  }, files);
   const meta = found.meta;
   if (meta === null) return null;
   let title = "";
@@ -7043,7 +7758,7 @@ async function scanRollout(item) {
     break;
   }
   let resumeCwd = null;
-  const tail = await readTailLines(item.ref, { maxBytes: TAIL_MAX_BYTES2 });
+  const tail = await readTailLines(item.ref, { maxBytes: TAIL_MAX_BYTES2 }, files);
   for (let index = tail.length - 1; index >= 0; index -= 1) {
     const line = tail[index];
     const payload = line === void 0 ? null : payloadOf(line, "turn_context");
@@ -7069,11 +7784,11 @@ async function scanRollout(item) {
 }
 
 // packages/server/src/agents/codex/session-follower.ts
-import path25 from "node:path";
+import path26 from "node:path";
 
 // packages/server/src/agents/codex/rollout-image.ts
-import { createReadStream } from "node:fs";
-import { createInterface } from "node:readline";
+import { createReadStream as createReadStream2 } from "node:fs";
+import { createInterface as createInterface2 } from "node:readline";
 var MAX_IMAGE_BYTES2 = MAX_SUBMIT_IMAGE_BYTES;
 var DATA_URL = /^data:([^;,]+);base64,(.*)$/s;
 async function loadRolloutImage(filePath, contentLine, index) {
@@ -7099,9 +7814,10 @@ async function loadRolloutImage(filePath, contentLine, index) {
   return { mediaType, data };
 }
 async function readLine(filePath, lineNumber) {
-  const stream = createReadStream(filePath, { encoding: "utf8" });
+  if (isCompressedRollout(filePath)) return readCompressedLine(filePath, lineNumber);
+  const stream = createReadStream2(filePath, { encoding: "utf8" });
   const failed = new Promise((resolve) => stream.once("error", () => resolve(null)));
-  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  const lines = createInterface2({ input: stream, crlfDelay: Infinity });
   const found = (async () => {
     let current = 0;
     try {
@@ -7121,6 +7837,24 @@ async function readLine(filePath, lineNumber) {
     stream.destroy();
   }
 }
+async function readCompressedLine(filePath, lineNumber) {
+  let data;
+  try {
+    data = await readCompressedRollout(filePath);
+  } catch {
+    return null;
+  }
+  let start = 0;
+  for (let current = 1; current < lineNumber; current += 1) {
+    const newline2 = data.indexOf(10, start);
+    if (newline2 === -1) return null;
+    start = newline2 + 1;
+  }
+  if (start >= data.length) return null;
+  const newline = data.indexOf(10, start);
+  const line = data.toString("utf8", start, newline === -1 ? data.length : newline);
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
 
 // packages/server/src/agents/codex/rollout-sink.ts
 var TURN_END_TYPES = ["task_complete", "turn_complete", "turn_aborted"];
@@ -7389,20 +8123,38 @@ function prettyJson(raw) {
 
 // packages/server/src/agents/codex/session-follower.ts
 var LOOKUP_INTERVAL_MS = 2e3;
+function sessionIdOf(filePath) {
+  const name = path26.basename(filePath);
+  return (parseRolloutFileName(name) ?? parseCompressedRolloutFileName(name))?.sessionId ?? null;
+}
+function samePath(a, b) {
+  return a === b || normalizeCwdKey(a, process.platform) === normalizeCwdKey(b, process.platform);
+}
 var CodexSessionFollower = class {
   constructor(cwd, sessionId, options = {}) {
     this.cwd = cwd;
     this.sessionId = sessionId;
     this.sink = new CodexRolloutSink(sessionId, options.limits);
-    this.jsonl = new JsonlFollower(null, this.sink, { maxEvents: options.maxEvents });
+    this.maxEvents = options.maxEvents;
+    this.jsonl = this.followerFor(null);
     this.now = options.now ?? Date.now;
   }
   cwd;
   sessionId;
   sink;
   jsonl;
+  maxEvents;
   now;
   lastLookupAt = null;
+  /** Llego un aviso de la otra forma de su sesion: buscar otra vez en el proximo `poll`. */
+  relookupPending = false;
+  followerFor(filePath) {
+    return new JsonlFollower(filePath, this.sink, { maxEvents: this.maxEvents, files: createRolloutFiles() });
+  }
+  /** El rollout que lee, para que la barra se entere de lo que el watcher no ve (§10.10). */
+  get sourcePath() {
+    return this.jsonl.filePath;
+  }
   get label() {
     const filePath = this.jsonl.filePath;
     if (filePath !== null) return filePath;
@@ -7416,28 +8168,58 @@ var CodexSessionFollower = class {
       await this.lookup();
     }
     this.sink.takeTurns(/* @__PURE__ */ new Set());
-    const { reset, added } = await this.jsonl.poll();
+    let { reset, added } = await this.jsonl.poll();
+    if (await this.relookup()) {
+      ({ added } = await this.jsonl.poll());
+      reset = true;
+    }
     const fresh = new Set(added.map((event2) => event2.eventId));
     return { reset, added, turns: this.sink.takeTurns(fresh), plans: [], parts: [] };
   }
+  /**
+   * Cambia de archivo si la sesion cambio de forma. true si cambio.
+   *
+   * Se busca con un aviso de la otra forma, o si el archivo seguido ya no esta
+   * (con el mismo intervalo que la busqueda inicial: son `readdir`). El orden de
+   * los avisos no importa: si el comprimido aparece antes de que se borre el
+   * `.jsonl`, la busqueda devuelve el `.jsonl` y no se cambia nada, y cuando se
+   * borra, el archivo seguido ya no esta.
+   */
+  async relookup() {
+    const own = this.jsonl.filePath;
+    if (own === null || this.sessionId.length === 0) return false;
+    const vanished = this.jsonl.getState() === "waiting";
+    const due = this.lastLookupAt === null || this.now() - this.lastLookupAt >= LOOKUP_INTERVAL_MS;
+    if (!this.relookupPending && !(vanished && due)) return false;
+    this.relookupPending = false;
+    this.lastLookupAt = this.now();
+    const found = await findReadableRollout(this.sessionId);
+    if (found === null || samePath(found, own) || this.jsonl.filePath !== own) return false;
+    this.sink.reset();
+    this.jsonl = this.followerFor(found);
+    return true;
+  }
   async lookup() {
     if (this.sessionId.length === 0 || this.jsonl.filePath !== null) return;
     this.lastLookupAt = this.now();
-    const found = await findRollout(this.sessionId);
+    const found = await findReadableRollout(this.sessionId);
     if (found !== null && this.jsonl.filePath === null) this.jsonl.setPath(found);
   }
   /**
    * true si el aviso es de su archivo. Si todavia no tiene uno y el aviso es un
    * rollout con su id, se queda con ese: es el watcher llegando antes que el
-   * reintento de busqueda.
+   * reintento de busqueda. Si tiene uno y el aviso es la otra forma de su
+   * sesion, la busca otra vez en el proximo `poll` (§10.12).
    */
   noticeChange(filePath) {
     const own = this.jsonl.filePath;
+    if (own !== null && samePath(own, filePath)) return true;
+    if (this.sessionId.length === 0) return false;
+    if (sessionIdOf(filePath) !== this.sessionId.toLowerCase()) return false;
     if (own !== null) {
-      return own === filePath || normalizeCwdKey(own, process.platform) === normalizeCwdKey(filePath, process.platform);
+      this.relookupPending = true;
+      return true;
     }
-    if (this.sessionId.length === 0) return false;
-    if (parseRolloutFileName(path25.basename(filePath))?.sessionId !== this.sessionId.toLowerCase()) return false;
     this.jsonl.setPath(filePath);
     return true;
   }
@@ -7475,30 +8257,39 @@ var CodexSessionFollower = class {
 // packages/server/src/agents/codex/history.ts
 async function pathExists2(candidate) {
   try {
-    await stat14(candidate);
+    await stat16(candidate);
     return true;
   } catch {
     return false;
   }
 }
-var accepts = (filePath) => ROLLOUT_FILE_PATTERN.test(path26.basename(filePath));
+function rolloutNameOf(filePath) {
+  const name = path27.basename(filePath);
+  return parseRolloutFileName(name) ?? parseCompressedRolloutFileName(name);
+}
+var accepts = (filePath) => rolloutNameOf(filePath) !== null;
 var CODEX_FOLLOW_POLL_MS = 1e3;
 function isInside2(root, filePath) {
-  const relative = path26.relative(root, filePath);
-  return relative.length > 0 && !relative.startsWith("..") && !path26.isAbsolute(relative);
+  const relative = path27.relative(root, filePath);
+  return relative.length > 0 && !relative.startsWith("..") && !path27.isAbsolute(relative);
 }
 function toItem2(ref, info) {
-  const name = parseRolloutFileName(path26.basename(ref));
+  const name = rolloutNameOf(ref);
   if (name === null) return null;
   return { ref, sessionId: name.sessionId, group: name.sessionId, mtimeMs: info.mtimeMs, sizeBytes: info.size };
 }
 async function itemOf(ref) {
+  if (isCompressedRollout(ref) && await pathExists2(plainRolloutPathOf(ref))) return null;
   try {
-    return toItem2(ref, await stat14(ref));
+    return toItem2(ref, await stat16(ref));
   } catch {
     return null;
   }
 }
+function withoutPlainTwin(compressed, plain) {
+  const plainSet = new Set(plain);
+  return compressed.filter((ref) => !plainSet.has(plainRolloutPathOf(ref)));
+}
 function createCodexHistory() {
   return {
     /*
@@ -7525,10 +8316,15 @@ function createCodexHistory() {
       const hasSessions = await pathExists2(sessionsRoot3);
       const hasArchived = await pathExists2(archivedRoot);
       if (!hasSessions && !hasArchived) return null;
-      const refs = [
+      const plain = [
         ...hasSessions ? await walkSessionFiles(sessionsRoot3) : [],
         ...hasArchived ? await rolloutFilesIn(archivedRoot) : []
       ];
+      const compressed = [
+        ...hasSessions ? await walkCompressedSessionFiles(sessionsRoot3) : [],
+        ...hasArchived ? await compressedRolloutFilesIn(archivedRoot) : []
+      ];
+      const refs = [...plain, ...withoutPlainTwin(compressed, plain)];
       const items = [];
       for (const ref of refs) {
         const item = await itemOf(ref);
@@ -7536,10 +8332,17 @@ function createCodexHistory() {
       }
       return items;
     },
+    /*
+      Las dos formas de la sesion, siempre juntas: cuando `codex resume`
+      reemplaza el comprimido por el `.jsonl`, o la app de escritorio comprime
+      uno, cual de las dos se lista depende de la otra (`itemOf`).
+    */
     async changedRefs(filePath) {
       if (!accepts(filePath)) return null;
       const roots = [codexSessionsRoot(), codexArchivedRoot()];
-      return roots.some((root) => root !== null && isInside2(root, filePath)) ? [filePath] : null;
+      if (!roots.some((root) => root !== null && isInside2(root, filePath))) return null;
+      const plain = isCompressedRollout(filePath) ? plainRolloutPathOf(filePath) : filePath;
+      return [plain, compressedRolloutPathOf(plain)];
     },
     item: (ref) => itemOf(ref),
     scan: (item) => scanRollout(item),
@@ -7548,8 +8351,12 @@ function createCodexHistory() {
     /**
      * true si esa sesion tiene rollout. El `cwd` no importa: la carpeta de
      * Codex es por dia, no por proyecto.
+     *
+     * Un rollout comprimido tambien cuenta: `codex resume` lo reemplaza por el
+     * `.jsonl` y sigue escribiendo ahi (§10.12). Sin eso, despertar la pestana
+     * de una sesion comprimida abria una sesion nueva.
      */
-    exists: async (_cwd, sessionId) => await findRollout(sessionId) !== null,
+    exists: async (_cwd, sessionId) => await findReadableRollout(sessionId) !== null,
     follow(target, options) {
       return new CodexSessionFollower(target.cwd, target.sessionId, {
         limits: options?.limits,
@@ -7601,7 +8408,9 @@ var CODEX_CAPABILITIES = {
   // `update_plan` es una lista de pasos, no un archivo.
   plans: false,
   // Sin estado publicado no hay espera que mirar: manda el candado de 10.8.
-  waitingBlocksSubmit: false
+  waitingBlocksSubmit: false,
+  // No hace cola: un mensaje con el agente trabajando le llega al modelo en el acto (hito 45).
+  forceSend: false
 };
 function codexInput(platform) {
   const windows = platform === "win32";
@@ -7688,7 +8497,7 @@ function createCodexAdapter() {
      * credenciales de antes de cambiarla.
      */
     protectedDirs: () => {
-      const dirs = [path27.join(homedir7(), ".codex")];
+      const dirs = [path28.join(homedir7(), ".codex")];
       const home = codexHome();
       if (home !== null && !dirs.includes(home)) dirs.unshift(home);
       return dirs;
@@ -7881,7 +8690,7 @@ var DbChangeSignal = class {
 };
 
 // packages/server/src/agents/opencode/history.ts
-import { stat as stat15 } from "node:fs/promises";
+import { stat as stat17 } from "node:fs/promises";
 
 // packages/server/src/agents/opencode/events.ts
 var TOOL_INPUT_PARSE_MAX_CHARS = 16e3;
@@ -8610,7 +9419,61 @@ var OpenCodeSessionFollower = class {
     }
     return false;
   }
+  /**
+   * Los mensajes del usuario que esperan en la cola de OpenCode (hito 45,
+   * §11.13).
+   *
+   * OpenCode escribe el mensaje en la base en el acto, aunque el agente este
+   * contestando otro: medido con la 1.19.1, el hilo lo mostraba a los 0,9 s
+   * como uno mas, y la respuesta que se seguia escribiendo aparecia despues
+   * encima de el. Su TUI lo marca "QUEUED" con una regla que se lee en el
+   * binario: va despues de la respuesta que se esta escribiendo, la ultima sin
+   * `time.completed` detras de la ultima completa. Es la misma, mas el corte
+   * del proceso: una respuesta que quedo a medias con un proceso anterior no se
+   * va a terminar nunca.
+   *
+   * Detenida, la respuesta se cierra (con `MessageAbortedError`) y el mensaje
+   * sale de la cola sin contestar: OpenCode no lo atiende despues (medido), y
+   * el hilo lo muestra donde esta. El mensaje ya es un evento: va con su
+   * `eventId` y la web lo esconde de su lugar mientras espera.
+   */
+  queuedPrompts(launchedAt) {
+    const messages = this.visibleMessages;
+    const lastCompleted = findLastIndex(messages, (message) => message.role === "assistant" && message.completed_at !== null);
+    const pending = findLastIndex(
+      messages,
+      (message, index) => index > lastCompleted && message.role === "assistant" && message.completed_at === null
+    );
+    const running = messages[pending];
+    if (running === void 0 || running.time_created < launchedAt) return [];
+    const queued = [];
+    for (const message of messages.slice(pending + 1)) {
+      if (message.role !== "user") continue;
+      const event2 = this.delivered.find((each) => each.eventId === message.id);
+      if (event2 === void 0) continue;
+      const text = event2.parts.flatMap((part) => part.kind === "text" ? [part.text] : []).join("\n").trim();
+      const images = event2.parts.filter((part) => part.kind === "image").length;
+      if (text.length === 0 && images === 0) continue;
+      queued.push({
+        id: message.id,
+        eventId: message.id,
+        text: text.slice(0, MAX_QUEUED_PROMPT_CHARS),
+        truncated: text.length > MAX_QUEUED_PROMPT_CHARS,
+        images,
+        at: event2.at
+      });
+      if (queued.length >= MAX_QUEUED_PROMPTS) break;
+    }
+    return queued;
+  }
 };
+function findLastIndex(items, test) {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    const item = items[index];
+    if (item !== void 0 && test(item, index)) return index;
+  }
+  return -1;
+}
 function addPart(target, part) {
   let byId = target.get(part.message_id);
   if (byId === void 0) {
@@ -8832,7 +9695,7 @@ function createOpenCodeHistory(deps) {
     async rootExists() {
       if (dbFile === null) return false;
       try {
-        await stat15(dbFile);
+        await stat17(dbFile);
         return true;
       } catch {
         return false;
@@ -8864,13 +9727,13 @@ function createOpenCodeHistory(deps) {
 var OPENCODE_SESSION_ID_PATTERN = /^ses_[0-9A-Za-z]{20,40}$/;
 
 // packages/server/src/agents/opencode/paths.ts
-import path28 from "node:path";
+import path29 from "node:path";
 function isFullyQualified2(candidate, platform) {
   if (platform === "win32") return /^([a-zA-Z]:[\\/]|[\\/]{2})/.test(candidate);
-  return path28.posix.isAbsolute(candidate);
+  return path29.posix.isAbsolute(candidate);
 }
 function resolveOpenCodePaths(env, home, platform) {
-  const flavor = platform === "win32" ? path28.win32 : path28.posix;
+  const flavor = platform === "win32" ? path29.win32 : path29.posix;
   const variable = (name) => {
     const value = env[name];
     return value === void 0 || value.length === 0 ? null : value;
@@ -9319,7 +10182,7 @@ import { execFile as execFile2, spawn as nodeSpawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdir as mkdir4 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import path29 from "node:path";
+import path30 from "node:path";
 var OPENCODE_SERVE_HOST = "127.0.0.1";
 var OPENCODE_SERVE_START_TIMEOUT_MS = 2e4;
 var OPENCODE_SERVE_IDLE_STOP_MS = 3e5;
@@ -9351,7 +10214,7 @@ function parseListeningLine(line) {
   return `http://${OPENCODE_SERVE_HOST}:${found.port}`;
 }
 function defaultServeCwd() {
-  return path29.join(tmpdir4(), "agent-workbench", "opencode-serve");
+  return path30.join(tmpdir4(), "agent-workbench", "opencode-serve");
 }
 var ServeStartError = class extends Error {
 };
@@ -9485,7 +10348,7 @@ var OpenCodeServeProcess = class {
     this.running = running;
     return new Promise((resolve, reject) => {
       let settled = false;
-      const fail = (reason2) => {
+      const fail2 = (reason2) => {
         if (settled) return;
         settled = true;
         this.timers.clearTimeout(timer);
@@ -9495,7 +10358,7 @@ var OpenCodeServeProcess = class {
       const timer = this.timers.setTimeout(
         () => {
           const ms = this.startTimeoutMs;
-          fail(`didn't say which port it listens on within ${ms >= 1e3 ? `${Math.round(ms / 1e3)} s` : `${ms} ms`}`);
+          fail2(`didn't say which port it listens on within ${ms >= 1e3 ? `${Math.round(ms / 1e3)} s` : `${ms} ms`}`);
         },
         this.startTimeoutMs
       );
@@ -9512,7 +10375,7 @@ var OpenCodeServeProcess = class {
           return;
         }
         const other = matchListeningLine(line);
-        if (other !== null) fail(`listens on ${other.scheme}://${other.host} and not on http://${OPENCODE_SERVE_HOST}`);
+        if (other !== null) fail2(`listens on ${other.scheme}://${other.host} and not on http://${OPENCODE_SERVE_HOST}`);
       };
       const read = (stream) => {
         if (stream === null) return;
@@ -9527,13 +10390,13 @@ var OpenCodeServeProcess = class {
       };
       read(child.stdout);
       read(child.stderr);
-      child.once("error", (error) => fail(error.message));
+      child.once("error", (error) => fail2(error.message));
       child.once("close", (code, signal) => {
         if (this.running === running) this.running = null;
         const how = signal ?? `code ${code ?? "?"}`;
         if (!settled) {
           const tail = running.tail.trim();
-          fail(`exited before listening (${how})${tail.length > 0 ? `: ${tail}` : ""}`);
+          fail2(`exited before listening (${how})${tail.length > 0 ? `: ${tail}` : ""}`);
           return;
         }
         const endpoint = running.endpoint;
@@ -9626,6 +10489,9 @@ var SUBMIT = "\r";
 var END_KEY = "\x1B[F";
 var INTERRUPT = "\x1B";
 var CLEAR_EDITOR = "";
+function buildForceSendKeys(method) {
+  return method === "ctrl-x-ctrl-s" ? "" : "\x1Bm";
+}
 var MAX_SUBMIT_CHARS = 2e5;
 function sanitizeForPaste(text) {
   return text.replace(/\x1b\[20[01]~/g, "").replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
@@ -10216,7 +11082,9 @@ var OPENCODE_CAPABILITIES = {
     en el menu del TUI. El candado de §10.8 (`hasOpenToolCall`) no sirve: se
     apaga con `statusSource`.
   */
-  waitingBlocksSubmit: true
+  waitingBlocksSubmit: true,
+  // Detenerla con algo en cola lo deja sin contestar: no hay forma de forzarlo (hito 45, §11.13).
+  forceSend: false
 };
 var OPENCODE_INPUT = {
   imageReference: "bare-path-paste",
@@ -10334,6 +11202,8 @@ function createOpenCodeAdapter(options = {}) {
     }),
     status,
     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 },
     /**
      * 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:
@@ -10379,13 +11249,13 @@ function createOpenCodeAdapter(options = {}) {
 }
 
 // packages/server/src/agents/pi/index.ts
-import { stat as stat21 } from "node:fs/promises";
+import { stat as stat23 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import path37 from "node:path";
+import path38 from "node:path";
 
 // packages/server/src/agents/pi/catalog.ts
 import { readFile as readFileFromDisk2, stat as statFromDisk2 } from "node:fs/promises";
-import path30 from "node:path";
+import path31 from "node:path";
 var PI_CATALOG_RECHECK_MS = 3e4;
 var PI_MODEL_LIST_MAX = 300;
 var STORE_MAX_BYTES = 8 * 1024 * 1024;
@@ -10542,7 +11412,7 @@ var PiModelCatalog = class {
     let windows = /* @__PURE__ */ new Map();
     for (const dataDir of packageDataDirs(packageDir)) {
       try {
-        windows = packageWindows(JSON.parse(await this.readFile(path30.join(dataDir, `${provider}.json`))));
+        windows = packageWindows(JSON.parse(await this.readFile(path31.join(dataDir, `${provider}.json`))));
         break;
       } catch {
       }
@@ -10554,8 +11424,8 @@ var PiModelCatalog = class {
 function packageDataDirs(packageDir) {
   const tail = ["pi-ai", "dist", "providers", "data"];
   return [
-    path30.join(packageDir, "node_modules", "@earendil-works", ...tail),
-    path30.join(packageDir, "..", ...tail)
+    path31.join(packageDir, "node_modules", "@earendil-works", ...tail),
+    path31.join(packageDir, "..", ...tail)
   ];
 }
 
@@ -10582,22 +11452,22 @@ var PI_READY_AFTER_LAUNCH_MS = 3e3;
 var PI_CLEAR_GAP_MS = 750;
 
 // packages/server/src/agents/pi/history.ts
-import { stat as stat18 } from "node:fs/promises";
-import path34 from "node:path";
+import { stat as stat20 } from "node:fs/promises";
+import path35 from "node:path";
 
 // packages/server/src/agents/pi/paths.ts
-import { readdir as readdir9, stat as stat16 } from "node:fs/promises";
+import { readdir as readdir9, stat as stat18 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
-import path31 from "node:path";
+import path32 from "node:path";
 var warned = /* @__PURE__ */ new Set();
 function isFullyQualified3(candidate) {
-  if (!path31.isAbsolute(candidate)) return false;
+  if (!path32.isAbsolute(candidate)) return false;
   return process.platform !== "win32" || /^([a-zA-Z]:[\\/]|[\\/]{2})/.test(candidate);
 }
 function resolveConfigured(name, value) {
   if (value === "~") return homedir9();
-  if (value.startsWith("~/") || value.startsWith("~\\")) return path31.join(homedir9(), value.slice(2));
-  if (isFullyQualified3(value)) return path31.normalize(value);
+  if (value.startsWith("~/") || value.startsWith("~\\")) return path32.join(homedir9(), value.slice(2));
+  if (isFullyQualified3(value)) return path32.normalize(value);
   const key = `${name}=${value}`;
   if (!warned.has(key)) {
     warned.add(key);
@@ -10607,7 +11477,7 @@ function resolveConfigured(name, value) {
 }
 function piAgentDir() {
   const configured = process.env["PI_CODING_AGENT_DIR"];
-  if (configured === void 0 || configured.length === 0) return path31.join(homedir9(), ".pi", "agent");
+  if (configured === void 0 || configured.length === 0) return path32.join(homedir9(), ".pi", "agent");
   return resolveConfigured("PI_CODING_AGENT_DIR", configured);
 }
 function piSessionsLayout() {
@@ -10617,14 +11487,14 @@ function piSessionsLayout() {
     return root === null ? null : { root, flat: true };
   }
   const agentDir = piAgentDir();
-  return agentDir === null ? null : { root: path31.join(agentDir, "sessions"), flat: false };
+  return agentDir === null ? null : { root: path32.join(agentDir, "sessions"), flat: false };
 }
 function piModelsStorePath() {
   const agentDir = piAgentDir();
-  return agentDir === null ? null : path31.join(agentDir, "models-store.json");
+  return agentDir === null ? null : path32.join(agentDir, "models-store.json");
 }
 function projectFolderName(cwd) {
-  const resolved = path31.resolve(cwd);
+  const resolved = path32.resolve(cwd);
   return `--${resolved.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
 }
 function isProjectFolderName(name) {
@@ -10651,12 +11521,12 @@ function parseSessionFileName(name) {
   return Number.isFinite(startedAt) ? { sessionId, startedAt } : null;
 }
 function isInside3(root, filePath) {
-  const relative = path31.relative(root, filePath);
-  return relative.length > 0 && !relative.startsWith("..") && !path31.isAbsolute(relative);
+  const relative = path32.relative(root, filePath);
+  return relative.length > 0 && !relative.startsWith("..") && !path32.isAbsolute(relative);
 }
 function sessionDirFor(cwd, layout = piSessionsLayout()) {
   if (layout === null) return null;
-  return layout.flat ? layout.root : path31.join(layout.root, projectFolderName(cwd));
+  return layout.flat ? layout.root : path32.join(layout.root, projectFolderName(cwd));
 }
 async function sessionFilesIn(dir) {
   try {
@@ -10670,7 +11540,7 @@ async function projectFolders(layout) {
   if (layout.flat) return [];
   try {
     const entries = await readdir9(layout.root, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory() && isProjectFolderName(entry.name)).map((entry) => path31.join(layout.root, entry.name)).sort();
+    return entries.filter((entry) => entry.isDirectory() && isProjectFolderName(entry.name)).map((entry) => path32.join(layout.root, entry.name)).sort();
   } catch {
     return [];
   }
@@ -10679,7 +11549,7 @@ async function listSessionFiles(layout) {
   const dirs = layout.flat ? [layout.root] : await projectFolders(layout);
   const files = [];
   for (const dir of dirs) {
-    for (const name of await sessionFilesIn(dir)) files.push(path31.join(dir, name));
+    for (const name of await sessionFilesIn(dir)) files.push(path32.join(dir, name));
   }
   return files;
 }
@@ -10695,14 +11565,14 @@ async function findSessionFile(sessionId, cwd) {
     }
   }
   for (const dir of dirs) {
-    const matches = (await sessionFilesIn(dir)).filter((name) => parseSessionFileName(name)?.sessionId === sessionId);
-    if (matches.length === 0) continue;
-    if (matches.length === 1) return path31.join(dir, matches[0] ?? "");
+    const matches2 = (await sessionFilesIn(dir)).filter((name) => parseSessionFileName(name)?.sessionId === sessionId);
+    if (matches2.length === 0) continue;
+    if (matches2.length === 1) return path32.join(dir, matches2[0] ?? "");
     let best = null;
-    for (const name of matches) {
+    for (const name of matches2) {
       try {
-        const info = await stat16(path31.join(dir, name));
-        if (best === null || info.mtimeMs > best.mtimeMs) best = { file: path31.join(dir, name), mtimeMs: info.mtimeMs };
+        const info = await stat18(path32.join(dir, name));
+        if (best === null || info.mtimeMs > best.mtimeMs) best = { file: path32.join(dir, name), mtimeMs: info.mtimeMs };
       } catch {
       }
     }
@@ -10712,7 +11582,7 @@ async function findSessionFile(sessionId, cwd) {
 }
 
 // packages/server/src/agents/pi/session-follower.ts
-import path33 from "node:path";
+import path34 from "node:path";
 
 // packages/server/src/agents/pi/session-entries.ts
 var NOTICE_DETAIL_MAX_CHARS2 = 300;
@@ -10932,10 +11802,10 @@ function readEntry(record, lineNumber, limits) {
 }
 
 // packages/server/src/agents/pi/session-image.ts
-import { createReadStream as createReadStream2 } from "node:fs";
-import { readFile as readFile10, stat as stat17 } from "node:fs/promises";
-import path32 from "node:path";
-import { createInterface as createInterface2 } from "node:readline";
+import { createReadStream as createReadStream3 } from "node:fs";
+import { readFile as readFile11, stat as stat19 } from "node:fs/promises";
+import path33 from "node:path";
+import { createInterface as createInterface3 } from "node:readline";
 function tooBig2(data) {
   return data.length > MAX_SUBMIT_IMAGE_BYTES * 1.4;
 }
@@ -10957,18 +11827,18 @@ function textOf2(message) {
   return blocksOf2(message).filter((block) => block["type"] === "text" && typeof block["text"] === "string").map((block) => block["text"]).join("\n");
 }
 function sameFile(a, b) {
-  const normalize = (value) => {
-    const normalized = path32.normalize(value);
+  const normalize3 = (value) => {
+    const normalized = path33.normalize(value);
     return process.platform === "win32" ? normalized.toLowerCase() : normalized;
   };
-  return normalize(a) === normalize(b);
+  return normalize3(a) === normalize3(b);
 }
 async function readPastedFile2(target, pastedDir) {
   try {
-    const inside = await resolveInside(pastedDir, path32.relative(pastedDir, target), { mustExist: true });
-    const info = await stat17(inside);
+    const inside = await resolveInside(pastedDir, path33.relative(pastedDir, target), { mustExist: true });
+    const info = await stat19(inside);
     if (!info.isFile() || info.size === 0 || info.size > MAX_SUBMIT_IMAGE_BYTES) return null;
-    const bytes = await readFile10(inside);
+    const bytes = await readFile11(inside);
     const format = detectImageFormat(bytes);
     return format === null ? null : { mediaType: format.mediaType, data: bytes.toString("base64") };
   } catch {
@@ -10989,12 +11859,12 @@ function readCallOf(record, target) {
 async function loadPiImage(file, eventId, index, source, pastedDir = pasteRoot()) {
   if (source === "attachment" || !Number.isInteger(index) || index < 0) return null;
   try {
-    if (!(await stat17(file)).isFile()) return null;
+    if (!(await stat19(file)).isFile()) return null;
   } catch {
     return null;
   }
-  const stream = createReadStream2(file, { encoding: "utf8" });
-  const lines = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+  const stream = createReadStream3(file, { encoding: "utf8" });
+  const lines = createInterface3({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
   stream.on("error", () => lines.close());
   let target = null;
   let readId = null;
@@ -11359,7 +12229,7 @@ var PiSessionFollower = class {
       return own === filePath || normalizeCwdKey(own, process.platform) === normalizeCwdKey(filePath, process.platform);
     }
     if (!isPiSessionId(this.sessionId)) return false;
-    if (parseSessionFileName(path33.basename(filePath))?.sessionId !== this.sessionId) return false;
+    if (parseSessionFileName(path34.basename(filePath))?.sessionId !== this.sessionId) return false;
     this.jsonl.setPath(filePath);
     return true;
   }
@@ -11468,29 +12338,29 @@ async function scanPiSession(item) {
 
 // packages/server/src/agents/pi/history.ts
 var PI_FOLLOW_POLL_MS = 1e3;
-var accepts2 = (filePath) => parseSessionFileName(path34.basename(filePath)) !== null;
+var accepts2 = (filePath) => parseSessionFileName(path35.basename(filePath)) !== null;
 function toItem3(ref, info) {
-  const name = parseSessionFileName(path34.basename(ref));
+  const name = parseSessionFileName(path35.basename(ref));
   if (name === null) return null;
   return {
     ref,
     sessionId: name.sessionId,
     // La carpeta de proyecto: respaldo del `cwd` si la primera linea no lo trajera.
-    group: path34.basename(path34.dirname(ref)),
+    group: path35.basename(path35.dirname(ref)),
     mtimeMs: info.mtimeMs,
     sizeBytes: info.size
   };
 }
 async function itemOf3(ref) {
   try {
-    const info = await stat18(ref);
+    const info = await stat20(ref);
     return info.isFile() ? toItem3(ref, info) : null;
   } catch {
     return null;
   }
 }
 function ignoresPath(root, filePath) {
-  const relative = path34.relative(root, filePath).split(path34.sep).join("/");
+  const relative = path35.relative(root, filePath).split(path35.sep).join("/");
   if (relative.length === 0) return false;
   if (relative.startsWith("..")) return true;
   const parts = relative.split("/");
@@ -11518,7 +12388,7 @@ function createPiHistory(catalog) {
       const layout = piSessionsLayout();
       if (layout === null) return null;
       try {
-        if (!(await stat18(layout.root)).isDirectory()) return null;
+        if (!(await stat20(layout.root)).isDirectory()) return null;
       } catch {
         return null;
       }
@@ -11561,7 +12431,7 @@ function createPiHistory(catalog) {
 }
 
 // packages/server/src/agents/pi/live.ts
-import { open as open6, stat as stat19 } from "node:fs/promises";
+import { open as open5, stat as stat21 } from "node:fs/promises";
 var PI_LIVE_POLL_MS = 500;
 var PI_ERROR_CALM_MS = 2e3;
 var PI_TRUST_WAITING = "trust dialog";
@@ -11716,7 +12586,7 @@ var PiLiveSessions = class {
     if (live.file === null) live.file = await this.findFile(live.sessionId, live.cwd).catch(() => null);
     if (live.file === null || fromStart) return;
     try {
-      live.offset = (await stat19(live.file)).size;
+      live.offset = (await stat21(live.file)).size;
     } catch {
       live.offset = 0;
     }
@@ -11734,7 +12604,7 @@ var PiLiveSessions = class {
     }
     let size;
     try {
-      size = (await stat19(live.file)).size;
+      size = (await stat21(live.file)).size;
     } catch {
       return;
     }
@@ -11744,7 +12614,7 @@ var PiLiveSessions = class {
       live.lineNumber = 0;
     }
     if (size === live.offset) return;
-    const handle = await open6(live.file, "r");
+    const handle = await open5(live.file, "r");
     try {
       const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES2);
       while (live.offset < size) {
@@ -11818,14 +12688,14 @@ var PiStatusSource = class {
 };
 
 // packages/server/src/agents/pi/locate.ts
-import { readFile as readFile11, realpath as realpath2 } from "node:fs/promises";
-import path35 from "node:path";
+import { readFile as readFile12, realpath as realpath2 } from "node:fs/promises";
+import path36 from "node:path";
 var PACKAGE_PARTS = PI_PACKAGE_NAME.split("/");
 var MANAGED_VERSION_PATTERN = /^[0-9A-Za-z._+-]+$/;
 var WALK_UP_LEVELS = 6;
 async function packageVersion(dir, read) {
   try {
-    const manifest = asRecord(JSON.parse(await read(path35.join(dir, "package.json"))));
+    const manifest = asRecord(JSON.parse(await read(path36.join(dir, "package.json"))));
     if (manifest === null || manifest["name"] !== PI_PACKAGE_NAME) return null;
     const version = manifest["version"];
     return typeof version === "string" && version.length > 0 ? version : null;
@@ -11834,24 +12704,24 @@ async function packageVersion(dir, read) {
   }
 }
 async function candidateDirs(resolvedPath, deps) {
-  const dir = path35.dirname(resolvedPath);
+  const dir = path36.dirname(resolvedPath);
   const candidates = [
-    path35.join(dir, "node_modules", ...PACKAGE_PARTS),
-    path35.join(dir, "..", "lib", "node_modules", ...PACKAGE_PARTS)
+    path36.join(dir, "node_modules", ...PACKAGE_PARTS),
+    path36.join(dir, "..", "lib", "node_modules", ...PACKAGE_PARTS)
   ];
   try {
-    const installRoot = path35.join(dir, "..", "install");
-    const version = (await deps.readFile(path35.join(installRoot, "current-version"))).trim();
+    const installRoot = path36.join(dir, "..", "install");
+    const version = (await deps.readFile(path36.join(installRoot, "current-version"))).trim();
     if (version !== "." && version !== ".." && MANAGED_VERSION_PATTERN.test(version)) {
-      candidates.push(path35.join(installRoot, "releases", version, "node_modules", ...PACKAGE_PARTS));
+      candidates.push(path36.join(installRoot, "releases", version, "node_modules", ...PACKAGE_PARTS));
     }
   } catch {
   }
   try {
-    let cursor = path35.dirname(await deps.realpath(resolvedPath));
+    let cursor = path36.dirname(await deps.realpath(resolvedPath));
     for (let level = 0; level < WALK_UP_LEVELS; level += 1) {
       candidates.push(cursor);
-      const parent = path35.dirname(cursor);
+      const parent = path36.dirname(cursor);
       if (parent === cursor) break;
       cursor = parent;
     }
@@ -11863,7 +12733,7 @@ var warnedForeign = /* @__PURE__ */ new Set();
 async function locatePi(overrides = {}) {
   const deps = {
     findInPath: overrides.findInPath ?? findInPath,
-    readFile: overrides.readFile ?? ((file) => readFile11(file, "utf8")),
+    readFile: overrides.readFile ?? ((file) => readFile12(file, "utf8")),
     realpath: overrides.realpath ?? realpath2
   };
   const resolvedPath = await deps.findInPath(PI_COMMAND);
@@ -11882,8 +12752,8 @@ async function locatePi(overrides = {}) {
 }
 
 // packages/server/src/agents/pi/tab-watch.ts
-import { readdir as readdir10, stat as stat20 } from "node:fs/promises";
-import path36 from "node:path";
+import { readdir as readdir10, stat as stat22 } from "node:fs/promises";
+import path37 from "node:path";
 var TRUST_TITLE = "Trust project folder?";
 var INTERFACE_STARTED = "\x1B[?1049h";
 function trustDialogOpen(output) {
@@ -11912,8 +12782,8 @@ async function listSessionsIn(dir) {
   for (const name of names) {
     if (parseSessionFileName(name) === null) continue;
     try {
-      const info = await stat20(path36.join(dir, name));
-      if (info.isFile()) files.push({ file: path36.join(dir, name), size: info.size, mtimeMs: info.mtimeMs });
+      const info = await stat22(path37.join(dir, name));
+      if (info.isFile()) files.push({ file: path37.join(dir, name), size: info.size, mtimeMs: info.mtimeMs });
     } catch {
     }
   }
@@ -12053,7 +12923,7 @@ var PiTabWatch = class {
     const previous = this.sizes;
     this.sizes = new Map(files.map((each) => [each.file, each.size]));
     if (this.file === null && this.sessionId.length > 0) {
-      this.file = files.find((each) => parseSessionFileName(path36.basename(each.file))?.sessionId === this.sessionId)?.file ?? null;
+      this.file = files.find((each) => parseSessionFileName(path37.basename(each.file))?.sessionId === this.sessionId)?.file ?? null;
     }
     if (previous === null) return;
     const own = this.currentFile;
@@ -12167,7 +13037,9 @@ var PI_BASE_CAPABILITIES = {
   contextWindowSource: "usage-with-catalog",
   plans: false,
   // Con el dialogo de confianza abierto, el Enter de un mensaje lo aceptaria (16.11).
-  waitingBlocksSubmit: true
+  waitingBlocksSubmit: true,
+  // Sin tecla de "enviar ya": se detiene y se vuelve a mandar lo que tenia en cola (hito 45, §16.18).
+  forceSend: true
 };
 var PI_INPUT = {
   imageReference: "quoted-path-line",
@@ -12191,7 +13063,7 @@ function createPiAdapter(options = {}) {
     const file = piModelsStorePath();
     if (file === null) return "none";
     try {
-      const info = await stat21(file);
+      const info = await stat23(file);
       return `${info.mtimeMs}:${info.size}`;
     } catch {
       return "none";
@@ -12265,8 +13137,15 @@ function createPiAdapter(options = {}) {
     status,
     queuedSubmits: {
       clearGapMs: PI_CLEAR_GAP_MS,
+      returnReason: "returned-by-cli",
       check: (target, submissions, interruptedAt) => live.check(target.sessionId, submissions, interruptedAt)
     },
+    /*
+      Pi no escribe su cola hasta entregarla (16.5): es lo que la app le mando
+      con el agente trabajando. Sin tecla de "enviar ya", se detiene y se vuelve
+      a mandar lo que devolvio a su editor (hito 45, §16.18).
+    */
+    promptQueue: { source: "app", forceSend: "interrupt-and-resend" },
     // `settings.json` no se abre: sin modelo por defecto que anunciar. Al reanudar,
     // el modelo y el nivel salen de la propia sesion.
     defaults: () => Promise.resolve(null),
@@ -12277,9 +13156,9 @@ function createPiAdapter(options = {}) {
      * un proyecto.
      */
     protectedDirs: () => {
-      const dirs = [path37.join(homedir10(), ".pi")];
+      const dirs = [path38.join(homedir10(), ".pi")];
       const agentDir = piAgentDir();
-      if (agentDir !== null && !dirs.some((dir) => agentDir === dir || agentDir.startsWith(`${dir}${path37.sep}`))) {
+      if (agentDir !== null && !dirs.some((dir) => agentDir === dir || agentDir.startsWith(`${dir}${path38.sep}`))) {
         dirs.unshift(agentDir);
       }
       return dirs;
@@ -12542,11 +13421,137 @@ async function migrateLegacyConfigDir() {
 
 // packages/server/src/conversation-hub.ts
 import { EventEmitter } from "node:events";
-import path38 from "node:path";
+import path39 from "node:path";
+
+// packages/server/src/app-prompt-queue.ts
+var CLOCK_SLACK_MS3 = 2e3;
+function normalize2(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function userTextOf(event2) {
+  if (event2.role !== "user") return null;
+  const texts = [];
+  let images = 0;
+  for (const part of event2.parts) {
+    if (part.kind === "text") texts.push(part.text);
+    else if (part.kind === "image") images += 1;
+    else if (part.kind === "tool-result" || part.kind === "tool-call") return null;
+  }
+  return { text: normalize2(texts.join(" ")), images };
+}
+function matches(entry, message) {
+  const wanted = normalize2(entry.text);
+  if (wanted.length === 0) return message.text.length === 0 && message.images >= entry.images && entry.images > 0;
+  return message.text === wanted || message.text.includes(wanted) || message.text.length >= 200 && wanted.startsWith(message.text);
+}
+var AppPromptQueue = class {
+  byTerminal = /* @__PURE__ */ new Map();
+  seq = 0;
+  /** La app termino de escribir un mensaje con el agente trabajando. */
+  note(terminalId, input) {
+    if (input.text.trim().length === 0 && input.images === 0) return;
+    this.seq += 1;
+    const entries = this.byTerminal.get(terminalId) ?? [];
+    entries.push({ id: `app-${this.seq}`, text: input.text, images: input.images, at: input.at, forced: false });
+    this.byTerminal.set(terminalId, entries.slice(-MAX_QUEUED_PROMPTS));
+  }
+  /**
+   * Saca las que ya aparecieron en el hilo. Cada mensaje del hilo se lleva una
+   * sola entrada, la mas vieja que le corresponde. true si cambio algo.
+   */
+  settle(terminalId, events) {
+    const entries = this.byTerminal.get(terminalId);
+    if (entries === void 0 || entries.length === 0) return false;
+    const used = /* @__PURE__ */ new Set();
+    const remaining = entries.filter((entry) => {
+      for (const event2 of events) {
+        if (used.has(event2.eventId) || event2.at < entry.at - CLOCK_SLACK_MS3) continue;
+        const message = userTextOf(event2);
+        if (message === null || !matches(entry, message)) continue;
+        used.add(event2.eventId);
+        return false;
+      }
+      return true;
+    });
+    if (remaining.length === entries.length) return false;
+    this.set(terminalId, remaining);
+    return true;
+  }
+  /** Se forzo el envio: lo que esperaba ya se le esta pasando al agente. true si cambio algo. */
+  markForced(terminalId) {
+    const entries = this.byTerminal.get(terminalId);
+    if (entries === void 0 || entries.every((entry) => entry.forced)) return false;
+    this.set(terminalId, entries.map((entry) => ({ ...entry, forced: true })));
+    return true;
+  }
+  /** Nada sigue en cola: la pestana quedo sin proceso o libre, o Detener lo devolvio al cuadro. true si habia algo. */
+  clear(terminalId) {
+    const had = (this.byTerminal.get(terminalId)?.length ?? 0) > 0;
+    this.byTerminal.delete(terminalId);
+    return had;
+  }
+  list(terminalId) {
+    return (this.byTerminal.get(terminalId) ?? []).map((entry) => {
+      const text = entry.text.trim();
+      const prompt = {
+        id: entry.id,
+        text: text.slice(0, MAX_QUEUED_PROMPT_CHARS),
+        truncated: text.length > MAX_QUEUED_PROMPT_CHARS,
+        images: entry.images,
+        at: entry.at
+      };
+      if (entry.forced) prompt.forced = true;
+      return prompt;
+    });
+  }
+  set(terminalId, entries) {
+    if (entries.length === 0) this.byTerminal.delete(terminalId);
+    else this.byTerminal.set(terminalId, entries);
+  }
+};
+
+// packages/server/src/rewind-target.ts
+function promptTextOf2(event2) {
+  if (event2.role !== "user") return null;
+  if (event2.parts.some((part) => part.kind === "tool-result" || part.kind === "notice")) return null;
+  const texts = event2.parts.flatMap((part) => part.kind === "text" ? [part] : []);
+  if (texts.length === 0 && !event2.parts.some((part) => part.kind === "image")) return null;
+  return {
+    text: texts.map((part) => part.text).join("\n"),
+    truncated: texts.some((part) => part.truncated)
+  };
+}
+function firstLineOf(text) {
+  return text.split("\n").map((line) => line.trim()).find((line) => line.length > 0) ?? "";
+}
+var comparable2 = (line) => line.replace(/\s+/g, " ").trim();
+function rewindTargetFrom(events, eventId) {
+  const index = events.findIndex((event3) => event3.eventId === eventId);
+  if (index === -1) return null;
+  const event2 = events[index];
+  const prompt = event2 === void 0 ? null : promptTextOf2(event2);
+  if (prompt === null) return null;
+  const firstLine2 = firstLineOf(prompt.text);
+  let occurrence = 0;
+  let promptsFromHere = 0;
+  for (const later of events.slice(index)) {
+    const text = promptTextOf2(later);
+    if (text === null) continue;
+    promptsFromHere += 1;
+    if (comparable2(firstLineOf(text.text)) === comparable2(firstLine2)) occurrence += 1;
+  }
+  return { text: prompt.text, truncated: prompt.truncated, firstLine: firstLine2, occurrence, promptsFromHere };
+}
+
+// packages/server/src/conversation-hub.ts
 var INITIAL_EVENT_LIMIT = 300;
 var MAX_PAGE_LIMIT = 500;
 var PENDING_QUESTION_LOOKBACK = 50;
 var POLL_DEBOUNCE_MS = 150;
+var GROWTH_REFRESH_MS = 3e3;
+var WITHDRAWAL_PENDING_MS = 15e3;
+var IDLE_CLEARS_QUEUE_MS = 3e3;
+var QUEUE_SETTLE_LOOKBACK = 50;
 function sameSubagents(a, b) {
   return a.length === b.length && a.every((item, index) => item.toolUseId === b[index]?.toolUseId && item.background === b[index]?.background);
 }
@@ -12561,11 +13566,39 @@ var ConversationHub = class extends EventEmitter {
         this.refreshOpenToolCall(terminalId, entry);
         this.refreshSubagents(terminalId, entry);
       }
+      for (const terminalId of /* @__PURE__ */ new Set([...this.entries.keys(), ...this.announcedQueues.keys()])) {
+        if (this.registry.launchedAtOf(terminalId) === null) this.appQueue.clear(terminalId);
+        this.refreshQueue(terminalId);
+      }
     });
+    registry.on("activity", (terminalId, activity) => this.noteActivity(terminalId, activity));
   }
   registry;
   agents;
   entries = /* @__PURE__ */ new Map();
+  /**
+   * La cola de las CLIs que no la escriben en ningun lado (hito 45): lo que la
+   * app les mando con el agente trabajando. Vive aca y no en el seguidor porque
+   * no sale del historial, y tiene que sobrevivir a que nadie mire la pestana.
+   */
+  appQueue = new AppPromptQueue();
+  /** La ultima cola avisada de cada pestana, por su clave: un aviso igual no se repite. */
+  announcedQueues = /* @__PURE__ */ new Map();
+  /** La ultima actividad vista de cada pestana: solo cuentan los cambios. */
+  lastActivity = /* @__PURE__ */ new Map();
+  /** El temporizador de cada pestana que quedo libre (`IDLE_CLEARS_QUEUE_MS`). */
+  idleTimers = /* @__PURE__ */ new Map();
+  /** Las pestanas libres hace mas de `IDLE_CLEARS_QUEUE_MS`: no tienen nada en cola. */
+  idleSettled = /* @__PURE__ */ new Set();
+  /**
+   * El mensaje que la CLI deshizo sin escribirlo todavia, por pestana (hito 44,
+   * §4.16): desde ahi el hilo se esconde. Vive aca y no en el seguidor porque
+   * tiene que sobrevivir a que nadie mire la conversacion: un seguidor nuevo
+   * relee el archivo, donde lo deshecho sigue igual, y se lo vuelve a esconder.
+   * Se olvida cuando la CLI escribe otra cosa (el seguidor lo suelta), al
+   * cambiar de sesion o al cerrar la pestana.
+   */
+  withdrawals = /* @__PURE__ */ new Map();
   /**
    * Engancha un cliente mas a la conversacion de una pestana y devuelve lo que
    * se sabe hasta ahora.
@@ -12603,13 +13636,14 @@ var ConversationHub = class extends EventEmitter {
       await entry.follower.start();
       debugLog(
         "conversation",
-        `following ${path38.basename(entry.follower.label)} for ${terminalId.slice(0, 8)}`
+        `following ${path39.basename(entry.follower.label)} for ${terminalId.slice(0, 8)}`
       );
       entry = this.entries.get(terminalId) ?? entry;
     }
     entry.refs += 1;
     entry.primed = true;
     await this.runPoll(terminalId, entry, { silent: true });
+    this.applyWithdrawal(terminalId, entry);
     const tail = entry.follower.getTail(INITIAL_EVENT_LIMIT);
     const plans = entry.adapter.history.plans;
     return {
@@ -12674,7 +13708,8 @@ var ConversationHub = class extends EventEmitter {
       subagents: [],
       primed: false,
       stopWatchingStatus: null,
-      followTicker: null
+      followTicker: null,
+      growthTimer: null
     };
   }
   /**
@@ -12697,6 +13732,25 @@ var ConversationHub = class extends EventEmitter {
   stopFollowTicker(entry) {
     if (entry.followTicker !== null) clearInterval(entry.followTicker);
     entry.followTicker = null;
+    if (entry.growthTimer !== null) clearTimeout(entry.growthTimer);
+    entry.growthTimer = null;
+  }
+  /**
+   * La sesion crecio: la barra se entera aunque el watcher no avise, una vez
+   * cada `GROWTH_REFRESH_MS` como mucho y con la ruta de ese momento. Solo con
+   * una CLI que se relee sola y un seguidor que dice su archivo: con Claude Code
+   * el watcher ya avisa.
+   */
+  noteGrowth(terminalId, entry) {
+    if ((entry.adapter.history.followPollMs ?? null) === null || entry.growthTimer !== null) return;
+    if (typeof entry.follower.sourcePath !== "string") return;
+    entry.growthTimer = setTimeout(() => {
+      entry.growthTimer = null;
+      if (this.entries.get(terminalId) !== entry) return;
+      const filePath = entry.follower.sourcePath;
+      if (typeof filePath === "string" && filePath.length > 0) this.emit("historyGrew", entry.agent, filePath);
+    }, GROWTH_REFRESH_MS);
+    entry.growthTimer.unref();
   }
   /**
    * Recalcula `openToolCall` y avisa si cambio.
@@ -12731,6 +13785,94 @@ var ConversationHub = class extends EventEmitter {
   getSubagents(terminalId) {
     return this.entries.get(terminalId)?.subagents ?? [];
   }
+  /**
+   * La cola de la CLI de una pestana, ahora (hito 45, §6.35): la del historial
+   * si su seguidor la dice, o la que lleva la app. Vacia sin proceso, si la CLI
+   * no hace cola, o si lleva libre `IDLE_CLEARS_QUEUE_MS`. La de una CLI cuyo
+   * historial la dice se ve solo con alguien siguiendo la pestana: quien mira
+   * la cola mira el hilo.
+   */
+  computeQueue(terminalId) {
+    const descriptor = this.registry.get(terminalId);
+    if (descriptor === null || descriptor.agent === null) return [];
+    const support = this.agents.get(descriptor.agent)?.adapter.promptQueue;
+    const launchedAt = this.registry.launchedAtOf(terminalId);
+    if (support === void 0 || launchedAt === null || this.idleSettled.has(terminalId)) return [];
+    if (support.source === "app") return this.appQueue.list(terminalId);
+    const follower = this.entries.get(terminalId)?.follower;
+    return follower?.queuedPrompts === void 0 ? [] : [...follower.queuedPrompts(launchedAt)];
+  }
+  /** La cola si cambio desde el ultimo aviso, que pasa a ser esta; null si es la misma. */
+  takeQueueChange(terminalId) {
+    const queue = this.computeQueue(terminalId);
+    const key = JSON.stringify(queue);
+    if ((this.announcedQueues.get(terminalId) ?? "[]") === key) return null;
+    if (queue.length === 0) this.announcedQueues.delete(terminalId);
+    else this.announcedQueues.set(terminalId, key);
+    return queue;
+  }
+  /** Recalcula la cola y avisa si cambio. */
+  refreshQueue(terminalId) {
+    const queue = this.takeQueueChange(terminalId);
+    if (queue !== null) this.emit("queue", terminalId, queue);
+  }
+  /**
+   * La cola de una pestana, para un `conversation.reset`: va dentro, y desde
+   * ahi es lo avisado.
+   */
+  getQueue(terminalId) {
+    this.takeQueueChange(terminalId);
+    return this.computeQueue(terminalId);
+  }
+  /** true si la CLI de la pestana tiene algo en cola. Lo pregunta el socket antes de forzar el envio. */
+  hasQueue(terminalId) {
+    return this.computeQueue(terminalId).length > 0;
+  }
+  /**
+   * La app termino de escribirle un mensaje a una CLI cuya cola no queda
+   * escrita (`source: 'app'`), con el agente trabajando: queda en cola hasta
+   * que aparezca en el hilo.
+   */
+  noteQueued(terminalId, input) {
+    this.appQueue.note(terminalId, input);
+    this.refreshQueue(terminalId);
+  }
+  /** Lo que la app llevaba en cola ya no esta ahi: Detener se lo devolvio al cuadro. */
+  clearQueued(terminalId) {
+    if (this.appQueue.clear(terminalId)) this.refreshQueue(terminalId);
+  }
+  /** Se forzo el envio: lo que la app llevaba en cola ya se le esta pasando al agente. */
+  markQueueForced(terminalId) {
+    if (this.appQueue.markForced(terminalId)) this.refreshQueue(terminalId);
+  }
+  /**
+   * Cambio la actividad de una pestana. Libre un rato, no queda nada en cola;
+   * sin proceso, tampoco. Otra cosa (trabajando, esperando) cancela la cuenta.
+   */
+  noteActivity(terminalId, activity) {
+    if (this.lastActivity.get(terminalId) === activity) return;
+    this.lastActivity.set(terminalId, activity);
+    const timer = this.idleTimers.get(terminalId);
+    if (timer !== void 0) clearTimeout(timer);
+    this.idleTimers.delete(terminalId);
+    const wasSettled = this.idleSettled.delete(terminalId);
+    if (activity === "offline") {
+      this.appQueue.clear(terminalId);
+      this.refreshQueue(terminalId);
+      return;
+    }
+    if (activity === "idle") {
+      const idleTimer = setTimeout(() => {
+        this.idleTimers.delete(terminalId);
+        this.idleSettled.add(terminalId);
+        this.appQueue.clear(terminalId);
+        this.refreshQueue(terminalId);
+      }, IDLE_CLEARS_QUEUE_MS);
+      idleTimer.unref();
+      this.idleTimers.set(terminalId, idleTimer);
+    }
+    if (wasSettled) this.refreshQueue(terminalId);
+  }
   /**
    * La pestana cambio de sesion: se suelta el seguidor viejo y se sigue la
    * nueva, sin perder a quien estaba mirando.
@@ -12768,7 +13910,7 @@ var ConversationHub = class extends EventEmitter {
     this.startFollowTicker(terminalId, next);
     debugLog(
       "conversation",
-      `${terminalId.slice(0, 8)} changed session: following ${path38.basename(next.follower.label)}`
+      `${terminalId.slice(0, 8)} changed session: following ${path39.basename(next.follower.label)}`
     );
     await next.follower.start();
     next.primed = true;
@@ -12863,10 +14005,70 @@ var ConversationHub = class extends EventEmitter {
   }
   /** La pestana se cerro: se suelta sin importar cuantos la miraban. */
   drop(terminalId) {
+    this.withdrawals.delete(terminalId);
+    this.appQueue.clear(terminalId);
+    this.announcedQueues.delete(terminalId);
+    this.lastActivity.delete(terminalId);
+    this.idleSettled.delete(terminalId);
+    const idleTimer = this.idleTimers.get(terminalId);
+    if (idleTimer !== void 0) clearTimeout(idleTimer);
+    this.idleTimers.delete(terminalId);
     const entry = this.entries.get(terminalId);
     if (entry === void 0) return;
     this.release(terminalId, entry);
   }
+  /**
+   * Esconde del hilo desde ese mensaje: la CLI lo deshizo y todavia no escribio
+   * nada que lo diga (hito 44, §4.16). Quien mira recibe un `reset`. Se anota
+   * aunque nadie mire: se aplica al suscribirse. false si la pestana no esta.
+   */
+  withdraw(terminalId, eventId) {
+    const descriptor = this.registry.get(terminalId);
+    if (descriptor === null) return false;
+    this.withdrawals.set(terminalId, {
+      sessionId: descriptor.sessionId,
+      eventId,
+      applied: false,
+      until: Date.now() + WITHDRAWAL_PENDING_MS
+    });
+    const entry = this.entries.get(terminalId);
+    if (entry === void 0) return true;
+    if (!this.applyWithdrawal(terminalId, entry, true)) this.schedulePoll(terminalId, entry);
+    return true;
+  }
+  /**
+   * Esconde lo anotado en un seguidor (recien creado, o el de siempre). true si
+   * quedo escondido. Si nunca se pudo, se sigue esperando a que el seguidor lea
+   * el mensaje, con un tope; si ya se habia podido y ahora no, la CLI escribio
+   * otra cosa (otra rama, u otra sesion) y se olvida.
+   */
+  applyWithdrawal(terminalId, entry, announce = false) {
+    const withdrawal = this.withdrawals.get(terminalId);
+    if (withdrawal === void 0) return false;
+    if (withdrawal.sessionId !== entry.sessionId || entry.follower.withdrawFrom === void 0) {
+      this.withdrawals.delete(terminalId);
+      return false;
+    }
+    const changed = entry.follower.withdrawFrom(withdrawal.eventId);
+    if (entry.follower.withdrawnFrom?.() === withdrawal.eventId) {
+      withdrawal.applied = true;
+      if (changed && announce) this.emit("reset", terminalId);
+      return true;
+    }
+    if (withdrawal.applied || Date.now() > withdrawal.until) this.withdrawals.delete(terminalId);
+    return false;
+  }
+  /**
+   * Lo que el menu de rewind necesita del mensaje `eventId` (hito 44): su
+   * texto, su primera linea y cuantos iguales hay despues. Sale de lo que se
+   * ve, que es lo que la CLI lista. null si nadie mira la conversacion o el
+   * mensaje no es uno que escribio el usuario.
+   */
+  rewindTarget(terminalId, eventId) {
+    const entry = this.entries.get(terminalId);
+    if (entry === void 0) return null;
+    return rewindTargetFrom(entry.follower.getTail(Number.MAX_SAFE_INTEGER).events, eventId);
+  }
   getPage(terminalId, beforeEventId, limit) {
     const entry = this.entries.get(terminalId);
     if (entry === void 0) return null;
@@ -13041,6 +14243,8 @@ var ConversationHub = class extends EventEmitter {
       entry.stopWatchingStatus?.();
     }
     this.entries.clear();
+    for (const timer of this.idleTimers.values()) clearTimeout(timer);
+    this.idleTimers.clear();
   }
   schedulePoll(terminalId, entry) {
     if (entry.timer !== null) clearTimeout(entry.timer);
@@ -13061,15 +14265,29 @@ var ConversationHub = class extends EventEmitter {
     entry.polling = entry.polling.then(async () => {
       if (this.entries.get(terminalId) !== entry) return;
       let result;
+      const withdrawnBefore = entry.follower.withdrawnFrom?.() ?? null;
       try {
         result = await entry.follower.poll();
       } catch (error) {
         console.warn(`[conversation] couldn't read ${entry.follower.label}:`, error);
         return;
       }
+      if (withdrawnBefore !== null && entry.follower.withdrawnFrom?.() !== withdrawnBefore) {
+        if (this.withdrawals.get(terminalId)?.eventId === withdrawnBefore) this.withdrawals.delete(terminalId);
+      }
       this.refreshOpenToolCall(terminalId, entry);
       this.refreshSubagents(terminalId, entry);
+      if (entry.adapter.promptQueue?.source === "app") {
+        this.appQueue.settle(terminalId, entry.follower.getTail(QUEUE_SETTLE_LOOKBACK).events);
+      }
       if (options.silent) return;
+      const queue = this.takeQueueChange(terminalId);
+      if (result.reset || result.added.length > 0) this.noteGrowth(terminalId, entry);
+      const pending = this.withdrawals.get(terminalId);
+      if (pending !== void 0 && !pending.applied && this.applyWithdrawal(terminalId, entry)) {
+        this.emit("reset", terminalId);
+        return;
+      }
       const observed = entry.follower.getPermissionMode();
       if (observed !== null) {
         entry.observedMode = observed;
@@ -13081,7 +14299,9 @@ var ConversationHub = class extends EventEmitter {
         return;
       }
       if (result.added.length > 0 || result.usageChanged === true) {
-        this.emit("append", terminalId, result.added, entry.follower.getUsage(), mode);
+        this.emit("append", terminalId, result.added, entry.follower.getUsage(), mode, queue ?? void 0);
+      } else if (queue !== null) {
+        this.emit("queue", terminalId, queue);
       }
       if (result.turns.length > 0) this.emit("turns", terminalId, result.turns);
       const plans = entry.adapter.history.plans;
@@ -13132,18 +14352,18 @@ function openBrowser(url) {
 // packages/server/src/pty-helper.ts
 import { chmodSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
-import path39 from "node:path";
+import path40 from "node:path";
 function helperCandidates(packageDir, platform, arch) {
   return [
-    path39.join(packageDir, "build", "Release", "spawn-helper"),
-    path39.join(packageDir, "build", "Debug", "spawn-helper"),
-    path39.join(packageDir, "prebuilds", `${platform}-${arch}`, "spawn-helper")
+    path40.join(packageDir, "build", "Release", "spawn-helper"),
+    path40.join(packageDir, "build", "Debug", "spawn-helper"),
+    path40.join(packageDir, "prebuilds", `${platform}-${arch}`, "spawn-helper")
   ];
 }
 function locateNodePty() {
   try {
     const require2 = createRequire(import.meta.url);
-    return path39.resolve(path39.dirname(require2.resolve("node-pty")), "..");
+    return path40.resolve(path40.dirname(require2.resolve("node-pty")), "..");
   } catch {
     return null;
   }
@@ -13804,24 +15024,24 @@ var RemoteAccessService = class {
 };
 
 // packages/server/src/remote-devices-store.ts
-import { chmod, mkdir as mkdir6, readFile as readFile12, stat as stat23 } from "node:fs/promises";
-import path41 from "node:path";
+import { chmod, mkdir as mkdir6, readFile as readFile13, stat as stat25 } from "node:fs/promises";
+import path42 from "node:path";
 
 // packages/server/src/vault/write.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { mkdir as mkdir5, rename as rename3, rm as rm2, stat as stat22, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir5, rename as rename3, rm as rm2, stat as stat24, writeFile as writeFile3 } from "node:fs/promises";
 
 // packages/server/src/vault/paths.ts
 import { createHash as createHash2 } from "node:crypto";
-import path40 from "node:path";
+import path41 from "node:path";
 function defaultVaultDir() {
-  return path40.join(appConfigDir(), "vault");
+  return path41.join(appConfigDir(), "vault");
 }
 function vaultMarkerFile(dir) {
-  return path40.join(dir, "vault.json");
+  return path41.join(dir, "vault.json");
 }
 function sessionsRoot2(dir) {
-  return path40.join(dir, "sessions");
+  return path41.join(dir, "sessions");
 }
 function isSafeSessionId(sessionId) {
   return isVaultSessionId(sessionId);
@@ -13835,41 +15055,41 @@ function assertSessionKey(agent, sessionId) {
 }
 function agentSessionsDir(dir, agent) {
   if (!isSessionAgentId(agent)) throw new Error(`Unknown source for the local copy: ${JSON.stringify(agent)}`);
-  return path40.join(sessionsRoot2(dir), agent);
+  return path41.join(sessionsRoot2(dir), agent);
 }
 function sessionFile(dir, agent, sessionId) {
   assertSessionKey(agent, sessionId);
-  return path40.join(sessionsRoot2(dir), agent, `${sessionId}.jsonl`);
+  return path41.join(sessionsRoot2(dir), agent, `${sessionId}.jsonl`);
 }
 function assetsDir(dir, agent, sessionId) {
   assertSessionKey(agent, sessionId);
-  return path40.join(sessionsRoot2(dir), agent, `${sessionId}.assets`);
+  return path41.join(sessionsRoot2(dir), agent, `${sessionId}.assets`);
 }
 function assetFile(dir, agent, sessionId, asset) {
   if (!VAULT_ASSET_NAME_PATTERN.test(asset)) throw new Error(`Invalid asset name: ${JSON.stringify(asset)}`);
-  return path40.join(assetsDir(dir, agent, sessionId), asset);
+  return path41.join(assetsDir(dir, agent, sessionId), asset);
 }
 function projectFolderName2(cwd, platform) {
   const hash = createHash2("sha256").update(normalizeCwdKey(cwd, platform)).digest("hex").slice(0, 8);
-  const base = (platform === "win32" ? path40.win32 : path40.posix).basename(cwd);
+  const base = (platform === "win32" ? path41.win32 : path41.posix).basename(cwd);
   const name = base.length === 0 ? "proyecto" : sanitizeFileName(base, 60);
   return `${name}-${hash}`;
 }
 function memoryDir(dir, cwd, platform) {
-  return path40.join(dir, "memory", projectFolderName2(cwd, platform));
+  return path41.join(dir, "memory", projectFolderName2(cwd, platform));
 }
 function projectExportDir(dir, cwd, platform) {
-  return path40.join(dir, "export", projectFolderName2(cwd, platform));
+  return path41.join(dir, "export", projectFolderName2(cwd, platform));
 }
 function projectExportDirFor(dir, project, platform) {
   if (project.cwd.length > 0) return projectExportDir(dir, project.cwd, platform);
   const hash = createHash2("sha256").update(project.key).digest("hex").slice(0, 8);
   const name = project.fallbackName.length > 0 ? sanitizeFileName(project.fallbackName, 60) : "proyecto";
-  return path40.join(dir, "export", `${name}-${hash}`);
+  return path41.join(dir, "export", `${name}-${hash}`);
 }
 function sessionExportFile(dir, agent, sessionId) {
   assertSessionKey(agent, sessionId);
-  return path40.join(dir, "export", "sesiones", `${agent}-${sessionId}.md`);
+  return path41.join(dir, "export", "sesiones", `${agent}-${sessionId}.md`);
 }
 var RESERVED_WINDOWS_NAME = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
 function sanitizeFileName(text, max = 80) {
@@ -13924,7 +15144,7 @@ async function writeFileAtomic(target, data, deps = DEFAULT_WRITE_DEPS) {
 async function ensureVaultMarker(dir, deps = DEFAULT_WRITE_DEPS) {
   const marker = vaultMarkerFile(dir);
   try {
-    await stat22(marker);
+    await stat24(marker);
     return;
   } catch {
   }
@@ -13934,7 +15154,7 @@ async function ensureVaultMarker(dir, deps = DEFAULT_WRITE_DEPS) {
 }
 async function assetPresent(file, size) {
   try {
-    const info = await stat22(file);
+    const info = await stat24(file);
     return info.isFile() && info.size === size;
   } catch {
     return false;
@@ -13976,7 +15196,7 @@ var RemoteDevicesStore = class {
   async load() {
     let raw;
     try {
-      raw = await readFile12(this.filePath, "utf8");
+      raw = await readFile13(this.filePath, "utf8");
     } catch {
       return [];
     }
@@ -13997,7 +15217,7 @@ var RemoteDevicesStore = class {
   save(devices) {
     const text = serializeRemoteDevices(devices);
     const run = async () => {
-      await mkdir6(path41.dirname(this.filePath), { recursive: true });
+      await mkdir6(path42.dirname(this.filePath), { recursive: true });
       await writeFileAtomic(this.filePath, text);
       await chmod(this.filePath, 384).catch(() => void 0);
     };
@@ -14016,7 +15236,7 @@ var RemoteDevicesStore = class {
    */
   async stamp() {
     try {
-      const info = await stat23(this.filePath);
+      const info = await stat25(this.filePath);
       return `${info.mtimeMs}:${info.size}`;
     } catch {
       return "";
@@ -14130,8 +15350,8 @@ import chokidar from "chokidar";
 
 // packages/server/src/git-repo.ts
 import { execFile as execFile4 } from "node:child_process";
-import { readFile as readFile13 } from "node:fs/promises";
-import path42 from "node:path";
+import { readFile as readFile14 } from "node:fs/promises";
+import path43 from "node:path";
 function gitOutputText(output, command) {
   return output.length > 0 ? serverText("raw", { text: output }) : serverText("gitCommandFailed", { command });
 }
@@ -14192,7 +15412,7 @@ async function resolveRepo(cwd) {
   const result = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
   if (result.code === 0) {
     const root = result.stdout.trim();
-    if (root.length > 0) return { state: "ready", root: path42.resolve(root), message: null };
+    if (root.length > 0) return { state: "ready", root: path43.resolve(root), message: null };
   }
   const stderr = result.stderr.trim();
   if (/not a git repository|no es un repositorio/i.test(stderr)) {
@@ -14219,7 +15439,7 @@ async function findGitDir(cwd) {
   const result = await runGit(cwd, ["rev-parse", "--absolute-git-dir"]);
   if (result.code !== 0) return null;
   const dir = result.stdout.trim();
-  return dir.length > 0 ? path42.resolve(dir) : null;
+  return dir.length > 0 ? path43.resolve(dir) : null;
 }
 function letterToKind(letter) {
   switch (letter) {
@@ -14322,7 +15542,7 @@ function parseWorktrees(raw, currentRoot) {
     worktrees.push({
       path: current.path,
       branch: current.branch,
-      isCurrent: path42.resolve(current.path) === path42.resolve(currentRoot)
+      isCurrent: path43.resolve(current.path) === path43.resolve(currentRoot)
     });
     current = null;
   };
@@ -14465,7 +15685,7 @@ function looksBinary(buffer) {
 async function readUntrackedAsDiff(absolutePath, relativePath) {
   let content;
   try {
-    content = await readFile13(absolutePath);
+    content = await readFile14(absolutePath);
   } catch {
     return {
       path: relativePath,
@@ -14513,7 +15733,7 @@ async function readUntrackedAsDiff(absolutePath, relativePath) {
 async function readDiff(options) {
   const { repoRoot: repoRoot2, relativePath, staged, untracked } = options;
   if (untracked && !staged) {
-    return readUntrackedAsDiff(path42.join(repoRoot2, relativePath), relativePath);
+    return readUntrackedAsDiff(path43.join(repoRoot2, relativePath), relativePath);
   }
   const args = [
     "diff",
@@ -14733,33 +15953,74 @@ var RepoHub = class extends EventEmitter2 {
 // packages/server/src/memory-hub.ts
 import { EventEmitter as EventEmitter3 } from "node:events";
 import { homedir as homedir12 } from "node:os";
-import path44 from "node:path";
+import path46 from "node:path";
 import chokidar2 from "chokidar";
 
 // packages/server/src/memory-bridge.ts
-import { execFile as execFile5 } from "node:child_process";
-import { randomBytes as randomBytes4 } from "node:crypto";
-import {
-  mkdir as mkdir7,
-  open as open7,
-  readdir as readdir11,
-  readFile as readFile14,
-  realpath as realpath3,
-  rename as rename4,
-  stat as stat24,
-  unlink as unlink3
-} from "node:fs/promises";
-import { homedir as homedir11 } from "node:os";
-import path43 from "node:path";
+import { execFile as execFile5 } from "node:child_process";
+import { mkdir as mkdir7, open as open7, readdir as readdir11, readFile as readFile15, realpath as realpath3, stat as stat26 } from "node:fs/promises";
+import { homedir as homedir11 } from "node:os";
+import path45 from "node:path";
+
+// packages/server/src/atomic-write.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { open as open6, rename as rename4, unlink as unlink3 } from "node:fs/promises";
+import path44 from "node:path";
+var RENAME_ATTEMPTS = 5;
+var RENAME_BACKOFF_MS = 40;
+var TEMPORARY_ATTEMPTS = 5;
+async function writeAtomically(target, content, options = {}) {
+  const { temporary, handle } = await createTemporary(target, options.mode === void 0 ? 438 : 384);
+  try {
+    try {
+      await handle.writeFile(content);
+      if (options.mode !== void 0 && process.platform !== "win32") await handle.chmod(options.mode & 4095);
+    } finally {
+      await handle.close();
+    }
+    await options.beforeRename?.();
+    await renameWithRetry(temporary, target);
+  } catch (error) {
+    await unlink3(temporary).catch(() => void 0);
+    throw error;
+  }
+}
+async function createTemporary(target, mode) {
+  for (let attempt = 1; ; attempt += 1) {
+    const suffix = randomBytes4(6).toString("hex");
+    const temporary = path44.join(
+      path44.dirname(target),
+      `.${path44.basename(target)}.${process.pid}.${suffix}.tmp`
+    );
+    try {
+      return { temporary, handle: await open6(temporary, "wx", mode) };
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST" || attempt >= TEMPORARY_ATTEMPTS) throw error;
+    }
+  }
+}
+async function renameWithRetry(from, to) {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      await rename4(from, to);
+      return;
+    } catch (error) {
+      const code = error.code;
+      const transient = code === "EPERM" || code === "EACCES" || code === "EBUSY";
+      if (!transient || attempt >= RENAME_ATTEMPTS) throw error;
+      await new Promise((resolve) => setTimeout(resolve, RENAME_BACKOFF_MS * attempt));
+    }
+  }
+}
+
+// packages/server/src/memory-bridge.ts
 var MemoryBridgeError = class extends ServerTextError {
 };
 var MAX_LISTED_NOTES = 500;
 var MAX_NOTE_BYTES = 256 * 1024;
 var NOTE_HEAD_BYTES = 16 * 1024;
 var GIT_TIMEOUT_MS2 = 15e3;
-var RENAME_ATTEMPTS = 5;
-var RENAME_BACKOFF_MS = 40;
-var TEMPORARY_ATTEMPTS = 5;
 var INDEX_REL = `${MEMORY_DIR}/${MEMORY_INDEX_FILE}`;
 var AGENTS_DIR_REL = MEMORY_DIR.split("/")[0] ?? ".agents";
 var GITIGNORE_REL = ".gitignore";
@@ -14768,9 +16029,9 @@ var GITIGNORE_MEMORY_LINE = `${MEMORY_DIR}/`;
 var BOM2 = Buffer.from([239, 187, 191]);
 async function inspectMemory(cwd, home = homedir11()) {
   await assertMemoryDirInside(cwd);
-  const folder = path43.join(cwd, MEMORY_DIR);
+  const folder = path45.join(cwd, MEMORY_DIR);
   const folderExists = await isDirectory2(folder);
-  const indexExists = folderExists && await isFile(path43.join(folder, MEMORY_INDEX_FILE));
+  const indexExists = folderExists && await isFile(path45.join(folder, MEMORY_INDEX_FILE));
   const noteNames = folderExists ? await listNoteFiles(folder) : [];
   const notes = await describeNotes(folder, noteNames);
   const files = await Promise.all(
@@ -14802,7 +16063,7 @@ async function installMemory(cwd, options, home = homedir11()) {
 }
 async function importNativeMemory(cwd, home = homedir11()) {
   await assertMemoryDirInside(cwd);
-  if (!await isDirectory2(path43.join(cwd, MEMORY_DIR))) {
+  if (!await isDirectory2(path45.join(cwd, MEMORY_DIR))) {
     throw new MemoryBridgeError(serverText("memoryNotInstalled"));
   }
   const plan = new PlanBuilder(cwd);
@@ -14820,9 +16081,9 @@ async function readMemoryNote(cwd, name) {
   }
   const absolute = await resolveInside(cwd, `${MEMORY_DIR}/${name}`);
   try {
-    const info = await stat24(absolute);
+    const info = await stat26(absolute);
     if (!info.isFile()) return null;
-    const content = await readFile14(absolute);
+    const content = await readFile15(absolute);
     return {
       name,
       text: content.subarray(0, MAX_NOTE_BYTES).toString("utf8"),
@@ -14837,7 +16098,7 @@ function isNoteName(name) {
   if (name.length === 0 || name.length > 255) return false;
   if (name.includes("\0")) return false;
   if (name === "." || name === "..") return false;
-  if (path43.basename(name) !== name) return false;
+  if (path45.basename(name) !== name) return false;
   if (/[\\/:*?"<>|\u0000-\u001f]/.test(name)) return false;
   return name.toLowerCase().endsWith(".md");
 }
@@ -14874,7 +16135,7 @@ var PlanBuilder = class {
   /** Nombres de nota que habria en la carpeta, en minusculas. */
   async noteNames() {
     const names = /* @__PURE__ */ new Map();
-    for (const name of await listNoteFiles(path43.join(this.cwd, MEMORY_DIR))) {
+    for (const name of await listNoteFiles(path45.join(this.cwd, MEMORY_DIR))) {
       names.set(name.toLowerCase(), name);
     }
     for (const rel of this.files.keys()) {
@@ -14917,7 +16178,7 @@ var PlanBuilder = class {
         continue;
       }
       const target = await realpath3(absolute);
-      const info = await stat24(target);
+      const info = await stat26(target);
       if (info.nlink > 1) {
         throw new MemoryBridgeError(serverText("memoryHardLinks", { file: file.rel }));
       }
@@ -14936,7 +16197,7 @@ var PlanBuilder = class {
     );
     if (pending.length === 0) return;
     if (pending.some((file) => file.rel.startsWith(`${MEMORY_DIR}/`))) {
-      await mkdir7(path43.join(this.cwd, MEMORY_DIR), { recursive: true });
+      await mkdir7(path45.join(this.cwd, MEMORY_DIR), { recursive: true });
     }
     for (const file of pending) {
       if (file.target === null) throw new Error(`Unvalidated plan: ${file.rel}`);
@@ -15047,7 +16308,7 @@ async function planNativeImport(plan, cwd, home) {
     const local = await plan.noteNames();
     for (const name of await listNoteFiles(folder)) {
       const key = name.toLowerCase();
-      const content = await readIfFile(path43.join(folder, name), name);
+      const content = await readIfFile(path45.join(folder, name), name);
       if (content === null) continue;
       const already = chosen.get(key);
       if (already !== void 0) {
@@ -15061,7 +16322,7 @@ async function planNativeImport(plan, cwd, home) {
         if (existing !== null && !existing.equals(content)) skipped.push(name);
         continue;
       }
-      plan.put(`${MEMORY_DIR}/${name}`, null, content, "copy", "", path43.join(folder, name));
+      plan.put(`${MEMORY_DIR}/${name}`, null, content, "copy", "", path45.join(folder, name));
       copied.push(name);
     }
   }
@@ -15071,7 +16332,7 @@ async function planNativeImport(plan, cwd, home) {
     const known = new Set(linkTargets(index.toString("utf8")));
     const additions = [];
     for (const folder of folders) {
-      const nativeIndex = await readIfFile(path43.join(folder, MEMORY_INDEX_FILE), MEMORY_INDEX_FILE);
+      const nativeIndex = await readIfFile(path45.join(folder, MEMORY_INDEX_FILE), MEMORY_INDEX_FILE);
       if (nativeIndex === null) continue;
       for (const line of nativeIndex.toString("utf8").replace(/^\uFEFF/, "").split(/\r?\n/)) {
         const target = linkTargets(line)[0];
@@ -15300,7 +16561,7 @@ async function describeNotes(folder, names) {
   const stated = [];
   for (const name of names) {
     try {
-      const info = await stat24(path43.join(folder, name));
+      const info = await stat26(path45.join(folder, name));
       if (info.isFile()) stated.push({ name, sizeBytes: info.size, modifiedAt: info.mtimeMs });
     } catch {
     }
@@ -15308,7 +16569,7 @@ async function describeNotes(folder, names) {
   stated.sort((a, b) => b.modifiedAt - a.modifiedAt || a.name.localeCompare(b.name));
   const notes = [];
   for (const item of stated.slice(0, MAX_LISTED_NOTES)) {
-    const head = await readHead(path43.join(folder, item.name));
+    const head = await readHead(path45.join(folder, item.name));
     notes.push({ ...item, ...describeNoteText(head, item.name) });
   }
   return notes;
@@ -15366,29 +16627,29 @@ async function countNativeMemory(cwd, home, sharedNames) {
   return { available: names.size, pending };
 }
 async function nativeMemoryFolders(cwd, home) {
-  const root = path43.join(home, ".claude", "projects");
+  const root = path45.join(home, ".claude", "projects");
   const slug = projectSlugFor(cwd).toLowerCase();
   try {
     const entries = await readdir11(root, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory() && entry.name.toLowerCase() === slug).map((entry) => entry.name).sort().map((name) => path43.join(root, name, "memory"));
+    return entries.filter((entry) => entry.isDirectory() && entry.name.toLowerCase() === slug).map((entry) => entry.name).sort().map((name) => path45.join(root, name, "memory"));
   } catch {
     return [];
   }
 }
 function buildGlobalFragments(home) {
   const windows = process.platform === "win32";
-  const globalFile = path43.join(home, ...GLOBAL_MEMORY_RELATIVE.split("/"));
+  const globalFile = path45.join(home, ...GLOBAL_MEMORY_RELATIVE.split("/"));
   const hardLink = (link) => windows ? `mklink /H "${link}" "${globalFile}"` : `ln "${globalFile}" "${link}"`;
   const hardLinkNote = windows ? serverText("memoryNoteHardLinkCmd", { path: GLOBAL_MEMORY_RELATIVE }) : serverText("memoryNoteHardLink", { path: GLOBAL_MEMORY_RELATIVE });
-  const codexTarget = path43.join(home, ".codex", "AGENTS.md");
-  const geminiTarget = path43.join(home, ".gemini", "GEMINI.md");
-  const piTarget = path43.join(home, ".pi", "agent", "AGENTS.md");
+  const codexTarget = path45.join(home, ".codex", "AGENTS.md");
+  const geminiTarget = path45.join(home, ".gemini", "GEMINI.md");
+  const piTarget = path45.join(home, ".pi", "agent", "AGENTS.md");
   const homeSlashes = home.replace(/\\/g, "/").replace(/\/+$/, "");
   return [
     {
       agent: "claude-code",
       label: MEMORY_AGENT_LABELS["claude-code"],
-      target: path43.join(home, ".claude", "CLAUDE.md"),
+      target: path45.join(home, ".claude", "CLAUDE.md"),
       kind: "line",
       text: `@~/${GLOBAL_MEMORY_RELATIVE}`,
       note: serverText("memoryNoteClaude")
@@ -15412,7 +16673,7 @@ function buildGlobalFragments(home) {
     {
       agent: "opencode",
       label: MEMORY_AGENT_LABELS.opencode,
-      target: path43.join(home, ".config", "opencode", "opencode.json"),
+      target: path45.join(home, ".config", "opencode", "opencode.json"),
       kind: "json",
       text: `"instructions": ["${homeSlashes}/${GLOBAL_MEMORY_RELATIVE}"]`,
       note: serverText("memoryNoteOpenCode")
@@ -15452,33 +16713,33 @@ function runGit2(cwd, args) {
   });
 }
 async function readGit(cwd) {
-  const fail = (message) => ({ state: { kind: "error", message }, main: null });
+  const fail2 = (message) => ({ state: { kind: "error", message }, main: null });
   const result = await runGit2(cwd, ["rev-parse", "--show-toplevel", "--git-dir", "--git-common-dir"]);
-  if (result.kind === "spawn-failed") return fail(result.text);
+  if (result.kind === "spawn-failed") return fail2(result.text);
   if (result.code !== 0) {
     const stderr = result.stderr.trim();
     if (/not a git repository|no es un repositorio/i.test(stderr)) {
       return { state: { kind: "not-repo" }, main: null };
     }
-    return fail(
+    return fail2(
       stderr.length > 0 ? serverText("raw", { text: stderr.slice(0, 400) }) : serverText("gitCommandFailed", { command: "rev-parse" })
     );
   }
   const [toplevel, gitDir, commonDir] = result.stdout.split(/\r?\n/).map((line) => line.trim());
-  if (!toplevel || !gitDir || !commonDir) return fail(serverText("gitUnexpected", { command: "rev-parse" }));
+  if (!toplevel || !gitDir || !commonDir) return fail2(serverText("gitUnexpected", { command: "rev-parse" }));
   const ignored = await checkIgnored(cwd, INDEX_REL);
-  if (typeof ignored !== "boolean") return fail(ignored);
-  const absoluteGitDir = path43.resolve(cwd, gitDir);
-  const absoluteCommonDir = path43.resolve(cwd, commonDir);
+  if (typeof ignored !== "boolean") return fail2(ignored);
+  const absoluteGitDir = path45.resolve(cwd, gitDir);
+  const absoluteCommonDir = path45.resolve(cwd, commonDir);
   let worktree = null;
   let main2 = null;
-  if (!await samePath(absoluteGitDir, absoluteCommonDir)) {
-    if (path43.basename(absoluteCommonDir).toLowerCase() === ".git") {
-      const mainRoot = path43.dirname(absoluteCommonDir);
-      const inner = path43.relative(path43.resolve(toplevel), path43.resolve(cwd));
-      const sameFolder = inner.length === 0 || inner.startsWith("..") || path43.isAbsolute(inner);
-      const mainPath = sameFolder ? mainRoot : path43.join(mainRoot, inner);
-      const memoryRel = sameFolder ? MEMORY_DIR : [...inner.split(path43.sep), MEMORY_DIR].join("/");
+  if (!await samePath2(absoluteGitDir, absoluteCommonDir)) {
+    if (path45.basename(absoluteCommonDir).toLowerCase() === ".git") {
+      const mainRoot = path45.dirname(absoluteCommonDir);
+      const inner = path45.relative(path45.resolve(toplevel), path45.resolve(cwd));
+      const sameFolder = inner.length === 0 || inner.startsWith("..") || path45.isAbsolute(inner);
+      const mainPath = sameFolder ? mainRoot : path45.join(mainRoot, inner);
+      const memoryRel = sameFolder ? MEMORY_DIR : [...inner.split(path45.sep), MEMORY_DIR].join("/");
       main2 = { root: mainRoot, memoryRel };
       worktree = {
         mainPath,
@@ -15498,12 +16759,12 @@ async function checkIgnored(cwd, rel) {
   const stderr = result.stderr.trim().slice(0, 400);
   return stderr.length > 0 ? serverText("raw", { text: stderr }) : serverText("gitCommandFailed", { command: "check-ignore" });
 }
-async function samePath(a, b) {
+async function samePath2(a, b) {
   const resolve = async (value) => {
     try {
       return await realpath3(value);
     } catch {
-      return path43.resolve(value);
+      return path45.resolve(value);
     }
   };
   const [left, right] = await Promise.all([resolve(a), resolve(b)]);
@@ -15530,8 +16791,8 @@ async function existingInside(root, rel, kind) {
     if (error instanceof InvalidPathError) return null;
     throw error;
   }
-  const matches = kind === "file" ? await isFile(absolute) : await isDirectory2(absolute);
-  return matches ? absolute : null;
+  const matches2 = kind === "file" ? await isFile(absolute) : await isDirectory2(absolute);
+  return matches2 ? absolute : null;
 }
 async function listNoteFiles(folder) {
   try {
@@ -15545,9 +16806,9 @@ async function listNoteFiles(folder) {
 }
 async function readIfFile(absolute, label) {
   try {
-    const info = await stat24(absolute);
+    const info = await stat26(absolute);
     if (!info.isFile()) throw new MemoryBridgeError(serverText("memoryNotAFile", { label }));
-    return await readFile14(absolute);
+    return await readFile15(absolute);
   } catch (error) {
     if (isNotFound(error)) return null;
     throw error;
@@ -15569,14 +16830,14 @@ async function readHead(absolute) {
 }
 async function isFile(absolute) {
   try {
-    return (await stat24(absolute)).isFile();
+    return (await stat26(absolute)).isFile();
   } catch {
     return false;
   }
 }
 async function isDirectory2(absolute) {
   try {
-    return (await stat24(absolute)).isDirectory();
+    return (await stat26(absolute)).isDirectory();
   } catch {
     return false;
   }
@@ -15586,58 +16847,22 @@ function isNotFound(error) {
   return code === "ENOENT" || code === "ENOTDIR";
 }
 async function writeAtomic(target, content, mustNotExist) {
-  const { temporary, handle } = await createTemporary(target);
-  try {
-    try {
-      await handle.writeFile(content);
-    } finally {
-      await handle.close();
-    }
-    if (mustNotExist && await exists2(target)) {
-      throw new MemoryBridgeError(serverText("memoryAppeared", { file: path43.basename(target) }));
-    }
-    await renameWithRetry(temporary, target);
-  } catch (error) {
-    await unlink3(temporary).catch(() => void 0);
-    throw error;
-  }
-}
-async function createTemporary(target) {
-  for (let attempt = 1; ; attempt += 1) {
-    const suffix = randomBytes4(6).toString("hex");
-    const temporary = path43.join(
-      path43.dirname(target),
-      `.${path43.basename(target)}.${process.pid}.${suffix}.tmp`
-    );
-    try {
-      return { temporary, handle: await open7(temporary, "wx") };
-    } catch (error) {
-      const code = error.code;
-      if (code !== "EEXIST" || attempt >= TEMPORARY_ATTEMPTS) throw error;
-    }
-  }
+  await writeAtomically(target, content, {
+    beforeRename: mustNotExist ? async () => {
+      if (await exists2(target)) {
+        throw new MemoryBridgeError(serverText("memoryAppeared", { file: path45.basename(target) }));
+      }
+    } : void 0
+  });
 }
 async function exists2(absolute) {
   try {
-    await stat24(absolute);
+    await stat26(absolute);
     return true;
   } catch {
     return false;
   }
 }
-async function renameWithRetry(from, to) {
-  for (let attempt = 1; ; attempt += 1) {
-    try {
-      await rename4(from, to);
-      return;
-    } catch (error) {
-      const code = error.code;
-      const transient = code === "EPERM" || code === "EACCES" || code === "EBUSY";
-      if (!transient || attempt >= RENAME_ATTEMPTS) throw error;
-      await new Promise((resolve) => setTimeout(resolve, RENAME_BACKOFF_MS * attempt));
-    }
-  }
-}
 
 // packages/server/src/memory-hub.ts
 var WATCH_DEBOUNCE_MS2 = 300;
@@ -15845,13 +17070,13 @@ var MemoryHub = class extends EventEmitter3 {
   }
 };
 function keyFor(cwd) {
-  const resolved = path44.resolve(cwd);
+  const resolved = path46.resolve(cwd);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function isRelevantPath(cwd, candidate) {
-  const relative = path44.relative(cwd, candidate);
+  const relative = path46.relative(cwd, candidate);
   if (relative.length === 0) return true;
-  if (relative.startsWith("..") || path44.isAbsolute(relative)) return false;
+  if (relative.startsWith("..") || path46.isAbsolute(relative)) return false;
   const same = (a, b) => process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
   const parts = relative.split(/[\\/]/);
   const [first = "", second = "", third = ""] = parts;
@@ -15869,8 +17094,8 @@ function isRelevantPath(cwd, candidate) {
 
 // packages/server/src/paste-store.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
-import { mkdir as mkdir8, readdir as readdir12, rm as rm3, stat as stat25, writeFile as writeFile4 } from "node:fs/promises";
-import path45 from "node:path";
+import { mkdir as mkdir8, readdir as readdir12, rm as rm3, stat as stat27, writeFile as writeFile4 } from "node:fs/promises";
+import path47 from "node:path";
 
 // packages/server/src/vault/markdown.ts
 var pad2 = (value) => String(value).padStart(2, "0");
@@ -16385,8 +17610,8 @@ function buildContinuationMessage(input) {
   }
   return sanitizeForPaste(lines.join("\n"));
 }
-function transcriptReferenceFor(path60, style) {
-  return style === "at-quoted" ? fileReference(path60, "at-quoted") : `"${path60}"`;
+function transcriptReferenceFor(path63, style) {
+  return style === "at-quoted" ? fileReference(path63, "at-quoted") : `"${path63}"`;
 }
 function planTranscript(input) {
   const turns = splitTurns(input.events);
@@ -16562,11 +17787,11 @@ var PasteStore = class {
     if (signature === null) {
       throw new PasteImageError(serverText("imageUnknownFormat"));
     }
-    const directory = path45.join(this.root, safeSegment(terminalId));
+    const directory = path47.join(this.root, safeSegment(terminalId));
     await mkdir8(directory, { recursive: true, mode: DIRECTORY_MODE });
     this.counter += 1;
     const name = `pegada-${this.counter}-${randomUUID3().slice(0, 8)}.${signature.ext}`;
-    const file = path45.join(directory, name);
+    const file = path47.join(directory, name);
     await writeFile4(file, bytes, { mode: FILE_MODE });
     return { path: file, bytes: bytes.length };
   }
@@ -16584,11 +17809,11 @@ var PasteStore = class {
     if (bytes.length > MAX_TEXT_BYTES) {
       throw new PasteTextError(`The text is ${bytes.length} bytes; the maximum is ${MAX_TEXT_BYTES}.`);
     }
-    const directory = path45.join(this.root, safeSegment(terminalId));
+    const directory = path47.join(this.root, safeSegment(terminalId));
     await mkdir8(directory, { recursive: true, mode: DIRECTORY_MODE });
     this.counter += 1;
     const name = `${baseName}-${this.counter}-${randomUUID3().slice(0, 8)}.md`;
-    const file = path45.join(directory, name);
+    const file = path47.join(directory, name);
     await writeFile4(file, bytes, { mode: FILE_MODE });
     return { path: file, bytes: bytes.length };
   }
@@ -16618,17 +17843,17 @@ var PasteStore = class {
         })
       );
     }
-    const directory = path45.join(this.root, safeSegment(terminalId));
+    const directory = path47.join(this.root, safeSegment(terminalId));
     await mkdir8(directory, { recursive: true, mode: DIRECTORY_MODE });
     this.counter += 1;
     const name = `adjunto-${this.counter}-${randomUUID3().slice(0, 8)}-${safe}`;
-    const file = path45.join(directory, name);
+    const file = path47.join(directory, name);
     await writeFile4(file, bytes, { mode: FILE_MODE });
     return { path: file, bytes: bytes.length, name };
   }
   /** Borra lo de una pestana. Se llama al cerrarla. */
   async clearTerminal(terminalId) {
-    await rm3(path45.join(this.root, safeSegment(terminalId)), {
+    await rm3(path47.join(this.root, safeSegment(terminalId)), {
       recursive: true,
       force: true
     }).catch(() => {
@@ -16650,9 +17875,9 @@ var PasteStore = class {
     }
     await Promise.all(
       entries.map(async (entry) => {
-        const full = path45.join(this.root, entry);
+        const full = path47.join(this.root, entry);
         try {
-          const info = await stat25(full);
+          const info = await stat27(full);
           if (now - info.mtimeMs > STALE_AFTER_MS) {
             await rm3(full, { recursive: true, force: true });
           }
@@ -16669,8 +17894,8 @@ function safeSegment(value) {
 
 // packages/server/src/session-index.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
-import { mkdir as mkdir9, readFile as readFile15, stat as stat26, writeFile as writeFile5 } from "node:fs/promises";
-import path46 from "node:path";
+import { mkdir as mkdir9, readFile as readFile16, stat as stat28, writeFile as writeFile5 } from "node:fs/promises";
+import path48 from "node:path";
 var CACHE_VERSION = 4;
 var vaultPairKey = (agent, sessionId) => `${agent}/${sessionId}`;
 function vaultOnlySessions(natives, vault, listState, ready) {
@@ -16722,7 +17947,7 @@ function cacheKey(agent, ref) {
 }
 async function pathExists3(candidate) {
   try {
-    await stat26(candidate);
+    await stat28(candidate);
     return true;
   } catch {
     return false;
@@ -16772,7 +17997,7 @@ function migrateEntryV3(filePath, value) {
   return {
     agent: "claude-code",
     ref: filePath,
-    group: path46.basename(path46.dirname(filePath)),
+    group: path48.basename(path48.dirname(filePath)),
     mtimeMs,
     sizeBytes,
     cwd,
@@ -17037,7 +18262,7 @@ var SessionIndex = class extends EventEmitter4 {
   }
   async loadCache() {
     try {
-      const raw = await readFile15(sessionIndexCachePath(), "utf8");
+      const raw = await readFile16(sessionIndexCachePath(), "utf8");
       const parsed = JSON.parse(raw);
       const migrated = migrateIndexCache(parsed);
       if (migrated === null) return;
@@ -17265,8 +18490,8 @@ var SessionIndex = class extends EventEmitter4 {
 };
 
 // packages/server/src/settings-store.ts
-import { mkdir as mkdir10, readFile as readFile16, stat as stat27 } from "node:fs/promises";
-import path47 from "node:path";
+import { mkdir as mkdir10, readFile as readFile17, stat as stat29 } from "node:fs/promises";
+import path49 from "node:path";
 var SETTINGS_VERSION = 1;
 var VAULT_TOOL_RESULT_DEFAULT_CHARS = 64e3;
 var VAULT_TOOL_RESULT_MIN_CHARS = 4e3;
@@ -17283,7 +18508,7 @@ function defaultAppSettings() {
 function isAbsoluteDir(dir, platform) {
   if (dir.length === 0 || dir.includes("\0")) return false;
   if (platform === "win32") return /^[A-Za-z]:[\\/]/.test(dir) || /^\\\\[^\\/]+[\\/][^\\/]+/.test(dir);
-  return path47.posix.isAbsolute(dir);
+  return path49.posix.isAbsolute(dir);
 }
 function clampToolResultMaxChars(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return VAULT_TOOL_RESULT_DEFAULT_CHARS;
@@ -17342,7 +18567,7 @@ var SettingsStore = class {
   async load() {
     let raw;
     try {
-      raw = await readFile16(this.filePath, "utf8");
+      raw = await readFile17(this.filePath, "utf8");
     } catch {
       this.current = frozen(defaultAppSettings());
       return;
@@ -17370,7 +18595,7 @@ var SettingsStore = class {
   async reloadRemote() {
     let parsed;
     try {
-      parsed = JSON.parse(await readFile16(this.filePath, "utf8"));
+      parsed = JSON.parse(await readFile17(this.filePath, "utf8"));
     } catch {
       return;
     }
@@ -17381,7 +18606,7 @@ var SettingsStore = class {
   /** Una marca que cambia cuando el archivo cambia (fecha y tamano), o '' si no esta. */
   async stamp() {
     try {
-      const info = await stat27(this.filePath);
+      const info = await stat29(this.filePath);
       return `${info.mtimeMs}:${info.size}`;
     } catch {
       return "";
@@ -17425,7 +18650,7 @@ var SettingsStore = class {
         if (!isRemotePort(remote.port)) throw new Error(`The remote access port isn't valid: ${JSON.stringify(remote.port)}`);
         next.remote.port = remote.port;
       }
-      await mkdir10(path47.dirname(this.filePath), { recursive: true });
+      await mkdir10(path49.dirname(this.filePath), { recursive: true });
       await writeFileAtomic(this.filePath, `${JSON.stringify(next, null, 2)}
 `);
       this.current = frozen(next);
@@ -17513,8 +18738,8 @@ function supportStartupLineColored() {
 
 // packages/server/src/notes-store.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { mkdir as mkdir11, readFile as readFile17, rename as rename5, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
-import path48 from "node:path";
+import { mkdir as mkdir11, readFile as readFile18, rename as rename5, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
+import path50 from "node:path";
 var STATE_VERSION2 = 1;
 var WRITE_DEBOUNCE_MS2 = 500;
 var NotesError = class extends ServerTextError {
@@ -17557,7 +18782,7 @@ var NotesStore = class {
   }
   async load() {
     try {
-      const raw = await readFile17(this.statePath, "utf8");
+      const raw = await readFile18(this.statePath, "utf8");
       this.notes = parseState2(raw) ?? [];
     } catch {
       this.notes = [];
@@ -17674,7 +18899,7 @@ var NotesStore = class {
     const image = this.findImage(imageId);
     if (image === null) return null;
     try {
-      const bytes = await readFile17(this.imagePath(image));
+      const bytes = await readFile18(this.imagePath(image));
       return { mediaType: image.mediaType, data: bytes.toString("base64") };
     } catch {
       return null;
@@ -17694,7 +18919,7 @@ var NotesStore = class {
     const images = [];
     for (const image of note.images) {
       try {
-        const bytes = await readFile17(this.imagePath(image));
+        const bytes = await readFile18(this.imagePath(image));
         images.push({ mediaType: image.mediaType, data: bytes.toString("base64") });
       } catch {
       }
@@ -17718,7 +18943,7 @@ var NotesStore = class {
   }
   imagePath(image) {
     const safe = image.imageId.replace(/[^a-zA-Z0-9-]/g, "");
-    return path48.join(this.imagesDir, `${safe}.${extensionFor(image.mediaType)}`);
+    return path50.join(this.imagesDir, `${safe}.${extensionFor(image.mediaType)}`);
   }
   async unlinkImage(image) {
     await rm4(this.imagePath(image), { force: true }).catch(() => {
@@ -17736,8 +18961,8 @@ var NotesStore = class {
   async writeNow() {
     this.dirty = false;
     try {
-      await mkdir11(path48.dirname(this.statePath), { recursive: true });
-      const temporary = path48.join(path48.dirname(this.statePath), `notes.${process.pid}.tmp`);
+      await mkdir11(path50.dirname(this.statePath), { recursive: true });
+      const temporary = path50.join(path50.dirname(this.statePath), `notes.${process.pid}.tmp`);
       await writeFile6(
         temporary,
         JSON.stringify({ version: STATE_VERSION2, notes: this.notes }, null, 2),
@@ -17751,8 +18976,8 @@ var NotesStore = class {
 };
 
 // packages/server/src/draft-store.ts
-import { mkdir as mkdir12, readFile as readFile18, rename as rename6, writeFile as writeFile7 } from "node:fs/promises";
-import path49 from "node:path";
+import { mkdir as mkdir12, readFile as readFile19, rename as rename6, writeFile as writeFile7 } from "node:fs/promises";
+import path51 from "node:path";
 var STATE_VERSION3 = 1;
 var WRITE_DEBOUNCE_MS3 = 500;
 var MAX_STORED_DRAFTS = 100;
@@ -17858,7 +19083,7 @@ var DraftStore = class {
   }
   async load() {
     try {
-      this.drafts = parseState3(await readFile18(this.statePath, "utf8"));
+      this.drafts = parseState3(await readFile19(this.statePath, "utf8"));
     } catch {
       this.drafts = /* @__PURE__ */ new Map();
     }
@@ -17949,7 +19174,7 @@ var DraftStore = class {
   async writeNow() {
     let onDisk = /* @__PURE__ */ new Map();
     try {
-      onDisk = parseState3(await readFile18(this.statePath, "utf8"));
+      onDisk = parseState3(await readFile19(this.statePath, "utf8"));
     } catch {
     }
     const changed = this.changed;
@@ -17963,8 +19188,8 @@ var DraftStore = class {
     trimOldest(merged);
     this.drafts = new Map(merged);
     try {
-      await mkdir12(path49.dirname(this.statePath), { recursive: true });
-      const temporary = path49.join(path49.dirname(this.statePath), `composer-drafts.${process.pid}.tmp`);
+      await mkdir12(path51.dirname(this.statePath), { recursive: true });
+      const temporary = path51.join(path51.dirname(this.statePath), `composer-drafts.${process.pid}.tmp`);
       const payload = {
         version: STATE_VERSION3,
         drafts: [...merged.values()].map(({ agent, sessionId, updatedAt, draft }) => ({ agent, sessionId, updatedAt, draft }))
@@ -17981,7 +19206,7 @@ var DraftStore = class {
 // packages/server/src/shell-locator.ts
 import { access as access2 } from "node:fs/promises";
 import { constants as fsConstants2 } from "node:fs";
-import path50 from "node:path";
+import path52 from "node:path";
 async function isExecutable(candidate) {
   try {
     await access2(candidate, process.platform === "win32" ? fsConstants2.R_OK : fsConstants2.X_OK);
@@ -17999,21 +19224,21 @@ var SYSTEM_PROBE = {
 function windowsPowerShellPath(env) {
   const systemRoot = env["SystemRoot"] ?? env["windir"];
   if (systemRoot === void 0 || systemRoot.length === 0) return null;
-  return path50.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  return path52.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
 }
 function gitBashCandidates(gitPath, env) {
   const candidates = [];
   if (gitPath !== null) {
-    let dir = path50.win32.dirname(gitPath);
+    let dir = path52.win32.dirname(gitPath);
     for (let level = 0; level < 3; level++) {
-      candidates.push(path50.win32.join(dir, "bin", "bash.exe"));
-      const parent = path50.win32.dirname(dir);
+      candidates.push(path52.win32.join(dir, "bin", "bash.exe"));
+      const parent = path52.win32.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
   }
-  for (const base of [env["ProgramFiles"], env["LOCALAPPDATA"] === void 0 ? void 0 : path50.win32.join(env["LOCALAPPDATA"], "Programs")]) {
-    if (base !== void 0 && base.length > 0) candidates.push(path50.win32.join(base, "Git", "bin", "bash.exe"));
+  for (const base of [env["ProgramFiles"], env["LOCALAPPDATA"] === void 0 ? void 0 : path52.win32.join(env["LOCALAPPDATA"], "Programs")]) {
+    if (base !== void 0 && base.length > 0) candidates.push(path52.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));
@@ -18044,7 +19269,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 = path50.posix.basename(preferred);
+    const name = path52.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"]]) {
@@ -18116,13 +19341,13 @@ var AppSettingsService = class extends EventEmitter5 {
 };
 
 // packages/server/src/session-watcher.ts
-import { stat as stat28 } from "node:fs/promises";
+import { stat as stat30 } 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 stat28(target)).isDirectory();
+    return (await stat30(target)).isDirectory();
   } catch {
     return false;
   }
@@ -18225,7 +19450,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 stat29 } from "node:fs/promises";
+import { stat as stat31 } from "node:fs/promises";
 
 // packages/server/src/launch-hook-slot.ts
 var LaunchHookSlot = class {
@@ -18426,6 +19651,45 @@ var PtySession = class {
   }
 };
 
+// packages/server/src/pty-screen.ts
+import headless from "@xterm/headless";
+var { Terminal } = headless;
+function createPtyScreen(cols, rows, replay) {
+  const term = new Terminal({ cols, rows, scrollback: 0, allowProposedApi: true });
+  let disposed = false;
+  if (replay.length > 0) term.write(replay);
+  return {
+    feed(chunk) {
+      if (!disposed) term.write(chunk);
+    },
+    lines() {
+      return new Promise((resolve) => {
+        if (disposed) {
+          resolve([]);
+          return;
+        }
+        term.write("", () => {
+          try {
+            const buffer = term.buffer.active;
+            const lines = [];
+            for (let y = 0; y < term.rows; y += 1) {
+              lines.push(buffer.getLine(buffer.viewportY + y)?.translateToString(true) ?? "");
+            }
+            resolve(lines);
+          } catch {
+            resolve([]);
+          }
+        });
+      });
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      term.dispose();
+    }
+  };
+}
+
 // packages/server/src/terminal-activity.ts
 var ActivityBook = class {
   entries = /* @__PURE__ */ new Map();
@@ -18487,8 +19751,8 @@ async function resolveLaunchPlan(launch) {
 }
 
 // packages/server/src/workspace-store.ts
-import { mkdir as mkdir13, readFile as readFile19, writeFile as writeFile8 } from "node:fs/promises";
-import path51 from "node:path";
+import { mkdir as mkdir13, readFile as readFile20, writeFile as writeFile8 } from "node:fs/promises";
+import path53 from "node:path";
 var STATE_VERSION4 = 1;
 var WRITE_DEBOUNCE_MS4 = 400;
 var LEGACY_TAB_AGENT = "claude-code";
@@ -18610,7 +19874,7 @@ var WorkspaceStore = class {
   pending = null;
   async load() {
     try {
-      const raw = await readFile19(workspaceStatePath(), "utf8");
+      const raw = await readFile20(workspaceStatePath(), "utf8");
       return parseState4(raw) ?? EMPTY_STATE();
     } catch {
       return EMPTY_STATE();
@@ -18642,7 +19906,7 @@ var WorkspaceStore = class {
     try {
       await mkdir13(appConfigDir(), { recursive: true });
       const target = workspaceStatePath();
-      const temporary = path51.join(path51.dirname(target), `workspace.${process.pid}.tmp`);
+      const temporary = path53.join(path53.dirname(target), `workspace.${process.pid}.tmp`);
       await writeFile8(temporary, JSON.stringify(serializeState(state), null, 2), "utf8");
       const { rename: rename7 } = await import("node:fs/promises");
       await rename7(temporary, target);
@@ -18880,7 +20144,7 @@ var TerminalRegistry = class extends EventEmitter6 {
   async assertDirectory(cwd) {
     let info;
     try {
-      info = await stat29(cwd);
+      info = await stat31(cwd);
     } catch {
       throw new TerminalOpenError("invalid-cwd", serverText("cwdMissing", { cwd }));
     }
@@ -19245,6 +20509,27 @@ var TerminalRegistry = class extends EventEmitter6 {
    * normal de una pestana restaurada. Quien llama decide que hacer —el socket
    * lo dice, el cliente ofrece abrir la CLI.
    */
+  /**
+   * La pantalla de la CLI de esa pestana, emulada, para leerla mientras se le
+   * escribe (hito 44: el menu de rewind, §4.16). Arranca con la salida reciente
+   * y sigue con la que llegue, al tamano actual de la pty. `dispose` la suelta.
+   * null sin proceso.
+   */
+  watchScreen(terminalId) {
+    const entry = this.terminals.get(terminalId);
+    if (entry === void 0 || entry.session === null) return null;
+    const screen = createPtyScreen(entry.size.cols, entry.size.rows, entry.buffer.read());
+    const listener = (_terminalId, chunk) => screen.feed(chunk);
+    entry.listeners.add(listener);
+    return {
+      feed: (chunk) => screen.feed(chunk),
+      lines: () => screen.lines(),
+      dispose: () => {
+        entry.listeners.delete(listener);
+        screen.dispose();
+      }
+    };
+  }
   write(terminalId, data) {
     const entry = this.terminals.get(terminalId);
     if (entry === void 0 || entry.session === null) return false;
@@ -19311,26 +20596,26 @@ import { WebSocketServer } from "ws";
 
 // packages/server/src/directory-picker.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { lstat, mkdir as mkdir14, readdir as readdir13, stat as stat30 } from "node:fs/promises";
+import { lstat, mkdir as mkdir14, readdir as readdir13, stat as stat32 } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
-import path52 from "node:path";
+import path54 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 = path52.resolve(target);
+  const resolved = path54.resolve(target);
   return dirs.some((dir) => {
-    const protectedDir = path52.resolve(dir);
-    return resolved === protectedDir || resolved.startsWith(protectedDir + path52.sep);
+    const protectedDir = path54.resolve(dir);
+    return resolved === protectedDir || resolved.startsWith(protectedDir + path54.sep);
   });
 }
 async function isListedDirectory(parent, entry, readLink = lstat) {
   if (entry.isDirectory()) return true;
   if (!entry.isSymbolicLink()) return false;
   try {
-    const info = await readLink(path52.join(parent, entry.name));
+    const info = await readLink(path54.join(parent, entry.name));
     return info.isDirectory() && !info.isSymbolicLink();
   } catch {
     return false;
@@ -19345,7 +20630,7 @@ async function listRoots() {
       letters.map(async (letter) => {
         const drive = `${letter}:\\`;
         try {
-          await stat30(drive);
+          await stat32(drive);
           return drive;
         } catch {
           return null;
@@ -19397,14 +20682,14 @@ var DirectoryPickers = class {
   async enter(pickerId, name) {
     const picker = this.require(pickerId);
     if (name === "..") {
-      const parent = path52.dirname(picker.current);
+      const parent = path54.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 = path52.join(picker.current, name);
+    const target = path54.join(picker.current, name);
     if (isInsideProtected(target, this.protectedDirs)) {
       throw new DirectoryPickerError(serverText("pickerCliFolder"));
     }
@@ -19444,7 +20729,7 @@ var DirectoryPickers = class {
         throw new DirectoryPickerError(serverText("pickerNameChars"));
       }
     }
-    const target = path52.join(picker.current, clean);
+    const target = path54.join(picker.current, clean);
     if (isInsideProtected(target, this.protectedDirs)) {
       throw new DirectoryPickerError(serverText("pickerNoProjectsHere"));
     }
@@ -19482,7 +20767,7 @@ var DirectoryPickers = class {
     try {
       const found = await readdir13(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(path52.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(path54.join(picker.current, name), this.protectedDirs)).sort((a, b) => a.localeCompare(b));
       truncated = dirs.length > MAX_ENTRIES;
       names = dirs.slice(0, MAX_ENTRIES);
     } catch {
@@ -19493,15 +20778,51 @@ var DirectoryPickers = class {
       path: picker.current,
       entries: names,
       roots,
-      canGoUp: path52.dirname(picker.current) !== picker.current,
+      canGoUp: path54.dirname(picker.current) !== picker.current,
       truncated
     };
   }
 };
 
+// packages/server/src/cli-folders.ts
+import { realpath as realpath4 } from "node:fs/promises";
+import path55 from "node:path";
+function isSameOrInside(child, parent, platform) {
+  const childKey = normalizeCwdKey(child, platform);
+  const parentKey = normalizeCwdKey(parent, platform);
+  if (childKey.length === 0 || parentKey.length === 0) return false;
+  if (childKey === parentKey) return true;
+  const separator = platform === "win32" ? "\\" : "/";
+  return childKey.startsWith(parentKey.endsWith(separator) ? parentKey : `${parentKey}${separator}`);
+}
+async function cliFolders(dirs, platform = process.platform) {
+  const known = [];
+  for (const dir of dirs) {
+    known.push(path55.resolve(dir));
+    try {
+      known.push(await realpath4(dir));
+    } catch {
+    }
+  }
+  const holds = (candidate) => known.some((dir) => isSameOrInside(candidate, dir, platform));
+  return {
+    holds,
+    async contains(absolute) {
+      if (known.length === 0) return false;
+      if (holds(absolute)) return true;
+      try {
+        return holds(await realpath4(absolute));
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
 // packages/server/src/file-browser.ts
-import { readFile as readFile20, readdir as readdir14, stat as stat31 } from "node:fs/promises";
-import path53 from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { readFile as readFile21, readdir as readdir14, realpath as realpath5, stat as stat33 } from "node:fs/promises";
+import path56 from "node:path";
 var MAX_ENTRIES2 = 1e3;
 var SEARCH_MAX_RESULTS = 200;
 var SEARCH_MAX_DIRECTORIES = 4e3;
@@ -19564,7 +20885,7 @@ function languageFor(fileName) {
   const lower = fileName.toLowerCase();
   const byName = LANGUAGE_BY_NAME[lower];
   if (byName !== void 0) return byName;
-  const extension = path53.extname(lower);
+  const extension = path56.extname(lower);
   return LANGUAGE_BY_EXTENSION[extension] ?? null;
 }
 function looksBinary2(buffer) {
@@ -19577,10 +20898,15 @@ function looksBinary2(buffer) {
 function joinRelative(parent, name) {
   return parent.length === 0 ? name : `${parent}/${name}`;
 }
-async function listDirectory(cwd, relativePath, options = {}) {
+async function resolveForFiles(cwd, relativePath, folders) {
   const absolute = await resolveInside(cwd, relativePath, { mustExist: true });
+  if (await folders.contains(absolute)) throw new InvalidPathError(serverText("cliFolderClosed"));
+  return absolute;
+}
+async function listDirectory(cwd, relativePath, folders, options = {}) {
+  const absolute = await resolveForFiles(cwd, relativePath, folders);
   const repoRoot2 = await findRepoRoot(cwd).catch(() => null);
-  const scanned = await scanLevel(absolute, repoRoot2);
+  const scanned = await scanLevel(absolute, repoRoot2, folders);
   const entries = [];
   let hiddenCount = scanned.skipped;
   let truncated = false;
@@ -19596,7 +20922,7 @@ async function listDirectory(cwd, relativePath, options = {}) {
     let sizeBytes = 0;
     let modifiedAt = 0;
     try {
-      const info = await stat31(path53.join(absolute, candidate.name));
+      const info = await stat33(path56.join(absolute, candidate.name));
       sizeBytes = candidate.isDirectory ? 0 : info.size;
       modifiedAt = info.mtimeMs;
     } catch {
@@ -19616,20 +20942,23 @@ async function listDirectory(cwd, relativePath, options = {}) {
   });
   return { path: relativePath, entries, truncated, hiddenCount };
 }
-async function scanLevel(absolute, repoRoot2) {
-  const level = await readLevel(absolute);
+async function scanLevel(absolute, repoRoot2, folders) {
+  const level = await readLevel(absolute, folders);
   await markIgnored(repoRoot2, [{ absolute, entries: level.entries }]);
   return level;
 }
-async function readLevel(absolute) {
+async function readLevel(absolute, folders) {
   const dirents = await readdir14(absolute, { withFileTypes: true });
+  const realLevel = await realpath5(absolute);
   let skipped = 0;
   const candidates = [];
   for (const dirent of dirents) {
     const always = ALWAYS_SKIP.has(dirent.name.toLowerCase());
     if (dirent.isSymbolicLink()) {
       try {
-        const target = await stat31(path53.join(absolute, dirent.name));
+        const linked = path56.join(absolute, dirent.name);
+        const target = await stat33(linked);
+        if (folders.holds(await realpath5(linked))) continue;
         candidates.push({
           name: dirent.name,
           isDirectory: target.isDirectory(),
@@ -19644,6 +20973,7 @@ async function readLevel(absolute) {
       skipped += 1;
       continue;
     }
+    if (folders.holds(path56.join(realLevel, dirent.name))) continue;
     candidates.push({
       name: dirent.name,
       isDirectory: dirent.isDirectory(),
@@ -19658,7 +20988,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(path53.relative(repoRoot2, path53.join(level.absolute, entry.name))));
+      keys.set(entry, toPosixPath(path56.relative(repoRoot2, path56.join(level.absolute, entry.name))));
     }
   }
   if (keys.size === 0) return;
@@ -19669,9 +20999,10 @@ async function markIgnored(repoRoot2, levels) {
     if (ignored.has(key)) entry.hidden = "ignored";
   }
 }
-async function searchFiles(cwd, query, options = {}) {
+async function searchFiles(cwd, query, folders, options = {}) {
   const needle = query.trim().toLowerCase();
   if (needle.length === 0) return { query, entries: [], truncated: false };
+  await resolveForFiles(cwd, "", folders);
   const repoRoot2 = await findRepoRoot(cwd).catch(() => null);
   const deadline = Date.now() + SEARCH_TIME_BUDGET_MS;
   const found = [];
@@ -19701,7 +21032,7 @@ async function searchFiles(cwd, query, options = {}) {
         continue;
       }
       try {
-        const level = await readLevel(absolute);
+        const level = await readLevel(absolute, folders);
         wave.push({ relative, absolute, entries: level.entries });
       } catch {
       }
@@ -19719,7 +21050,7 @@ async function searchFiles(cwd, query, options = {}) {
         let sizeBytes = 0;
         let modifiedAt = 0;
         try {
-          const info = await stat31(path53.join(level.absolute, candidate.name));
+          const info = await stat33(path56.join(level.absolute, candidate.name));
           sizeBytes = candidate.isDirectory ? 0 : info.size;
           modifiedAt = info.mtimeMs;
         } catch {
@@ -19751,25 +21082,31 @@ async function searchFiles(cwd, query, options = {}) {
     truncated: truncated || found.length > SEARCH_MAX_RESULTS
   };
 }
-async function existingFiles(cwd, relativePaths) {
+async function existingFiles(cwd, relativePaths, folders) {
   const existing = [];
   for (const relativePath of relativePaths) {
     try {
-      const absolute = await resolveInside(cwd, relativePath, { mustExist: true });
-      if ((await stat31(absolute)).isFile()) existing.push(relativePath);
+      const absolute = await resolveForFiles(cwd, relativePath, folders);
+      if ((await stat33(absolute)).isFile()) existing.push(relativePath);
     } catch {
     }
   }
   return existing;
 }
-async function readPreview(cwd, relativePath) {
-  const absolute = await resolveInside(cwd, relativePath, { mustExist: true });
-  const info = await stat31(absolute);
+function contentHash(content) {
+  return createHash4("sha256").update(content).digest("hex");
+}
+function isEditableText(content, text) {
+  return !/\r(?!\n)/.test(text) && Buffer.from(text, "utf8").equals(content);
+}
+async function readPreview(cwd, relativePath, folders) {
+  const absolute = await resolveForFiles(cwd, relativePath, folders);
+  const info = await stat33(absolute);
   if (info.isDirectory()) {
     throw new Error("It's a directory, not a file.");
   }
-  const content = await readFile20(absolute);
-  const fileName = path53.basename(absolute);
+  const content = await readFile21(absolute);
+  const fileName = path56.basename(absolute);
   if (looksBinary2(content)) {
     return {
       path: relativePath,
@@ -19781,14 +21118,71 @@ async function readPreview(cwd, relativePath) {
     };
   }
   const truncated = content.length > MAX_PREVIEW_BYTES;
-  return {
+  const text = content.subarray(0, MAX_PREVIEW_BYTES).toString("utf8");
+  const preview = {
     path: relativePath,
     language: languageFor(fileName),
-    text: content.subarray(0, MAX_PREVIEW_BYTES).toString("utf8"),
+    text,
     sizeBytes: info.size,
     truncated,
     binary: false
   };
+  return truncated || !isEditableText(content, text) ? preview : { ...preview, editable: true, hash: contentHash(content) };
+}
+
+// packages/server/src/file-write.ts
+import { constants } from "node:fs";
+import { access as access3, readFile as readFile22, realpath as realpath6, stat as stat34 } from "node:fs/promises";
+var FileWriteError = class extends ServerTextError {
+};
+function withLineEndings(text, original) {
+  const crlf = original.match(/\r\n/g)?.length ?? 0;
+  const lf = original.match(/(?<!\r)\n/g)?.length ?? 0;
+  const plain = text.replace(/\r\n/g, "\n");
+  return crlf > lf ? plain.replace(/\n/g, "\r\n") : plain;
+}
+function isMissing(error) {
+  return error instanceof InvalidPathError && error.text.key === "pathMissing";
+}
+function errorCode(error) {
+  return error?.code;
+}
+async function saveProjectFile(cwd, relativePath, text, baseHash, folders) {
+  let absolute;
+  try {
+    absolute = await resolveInside(cwd, relativePath, { mustExist: true });
+  } catch (error) {
+    if (isMissing(error)) return { outcome: "changed", preview: null };
+    throw error;
+  }
+  if (await folders.contains(absolute)) throw new InvalidPathError(serverText("cliFolderClosed"));
+  const target = await realpath6(absolute);
+  const info = await stat34(target);
+  if (!info.isFile()) throw new FileWriteError(serverText("fileSaveFailed"));
+  const current = await readFile22(target);
+  if (contentHash(current) !== baseHash) {
+    return { outcome: "changed", preview: await readPreview(cwd, relativePath, folders).catch(() => null) };
+  }
+  if (current.length > MAX_PREVIEW_BYTES || !isEditableText(current, current.toString("utf8"))) {
+    throw new FileWriteError(serverText("fileSaveFailed"));
+  }
+  try {
+    await access3(target, constants.W_OK);
+  } catch {
+    throw new FileWriteError(serverText("fileSaveBlocked"));
+  }
+  const content = Buffer.from(withLineEndings(text, current.toString("utf8")), "utf8");
+  if (content.length > MAX_PREVIEW_BYTES) {
+    throw new FileWriteError(serverText("fileSaveTooLarge", { max: `${MAX_PREVIEW_BYTES / 1024} KB` }));
+  }
+  try {
+    await writeAtomically(target, content, { mode: info.mode });
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "EPERM" || code === "EACCES" || code === "EBUSY") throw new FileWriteError(serverText("fileSaveBlocked"));
+    throw error;
+  }
+  return { outcome: "saved", preview: await readPreview(cwd, relativePath, folders) };
 }
 
 // packages/server/src/global-search.ts
@@ -20265,11 +21659,15 @@ var RECLAIM_POLL_MS = 250;
 var QueuedSubmitBook = class {
   submissions = /* @__PURE__ */ new Map();
   clearKeyAt = /* @__PURE__ */ new Map();
-  /** Un mensaje termino de escribirse en la pty, Enter incluido. */
-  note(terminalId, text, at) {
+  /**
+   * Un mensaje termino de escribirse en la pty, Enter incluido. `original`: el
+   * texto del cuadro sin las referencias a adjuntos (hito 44), si difiere.
+   */
+  note(terminalId, text, at, original) {
     if (text.trim().length === 0) return;
     const kept = (this.submissions.get(terminalId) ?? []).filter((each) => at - each.at < SUBMISSION_MAX_AGE_MS2);
-    this.submissions.set(terminalId, [...kept, { text, at }].slice(-SUBMISSIONS_KEPT2));
+    const submission = original === void 0 || original === text ? { text, at } : { text, original, at };
+    this.submissions.set(terminalId, [...kept, submission].slice(-SUBMISSIONS_KEPT2));
   }
   /** Se lleva lo anotado de esa pestana. */
   take(terminalId) {
@@ -20305,13 +21703,15 @@ async function reclaimQueuedSubmits(deps) {
   const pollMs = deps.pollMs ?? RECLAIM_POLL_MS;
   const deadline = deps.now() + timeoutMs;
   let undelivered = [];
+  let withdrawn = [];
   for (; ; ) {
     const target = deps.target();
     if (target === null) return "gone";
     const result = await deps.source.check(target, submissions, deps.interruptedAt);
-    if (result.undelivered.length === 0) return "nothing";
-    if (result.settled) {
+    if (result.undelivered.length === 0 && result.pending !== true) return "nothing";
+    if (result.settled && result.undelivered.length > 0) {
       undelivered = result.undelivered;
+      withdrawn = result.withdrawn ?? [];
       break;
     }
     if (deps.now() >= deadline) return "not-settled";
@@ -20324,7 +21724,8 @@ async function reclaimQueuedSubmits(deps) {
   }
   if (deps.target() === null) return "gone";
   if (!deps.writeClearKey()) return "refused";
-  deps.prefill(undelivered.join("\n\n"));
+  await deps.prefill(undelivered.join("\n\n"));
+  if (withdrawn.length > 0) deps.withdraw?.(withdrawn);
   return "reclaimed";
 }
 
@@ -20429,14 +21830,14 @@ var TerminalWriteQueue = class {
 };
 
 // packages/server/src/vault/service.ts
-import { mkdir as mkdir17, stat as stat35 } from "node:fs/promises";
+import { mkdir as mkdir17, stat as stat38 } from "node:fs/promises";
 import { homedir as homedir14 } from "node:os";
-import path57 from "node:path";
+import path60 from "node:path";
 
 // packages/server/src/vault/move.ts
-import { constants } from "node:fs";
-import { copyFile as copyFile2, lstat as lstat2, mkdir as mkdir15, readdir as readdir15, rm as rm5, stat as stat32, utimes, writeFile as writeFile9 } from "node:fs/promises";
-import path54 from "node:path";
+import { constants as constants2 } from "node:fs";
+import { copyFile as copyFile2, lstat as lstat2, mkdir as mkdir15, readdir as readdir15, rm as rm5, stat as stat35, utimes, writeFile as writeFile9 } from "node:fs/promises";
+import path57 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) {
@@ -20449,14 +21850,14 @@ async function copyTree(source, target, result) {
   if (info.isDirectory()) {
     await mkdir15(target, { recursive: true });
     for (const name of await readdir15(source)) {
-      await copyTree(path54.join(source, name), path54.join(target, name), result);
+      await copyTree(path57.join(source, name), path57.join(target, name), result);
     }
     return;
   }
   if (!info.isFile() || OWN_TEMP_FILE.test(source)) return;
-  await mkdir15(path54.dirname(target), { recursive: true });
+  await mkdir15(path57.dirname(target), { recursive: true });
   try {
-    await copyFile2(source, target, constants.COPYFILE_EXCL);
+    await copyFile2(source, target, constants2.COPYFILE_EXCL);
   } catch (error) {
     if (error.code === "EEXIST") {
       result.skipped += 1;
@@ -20471,11 +21872,11 @@ async function moveVault(from, to) {
   const result = { copied: 0, skipped: 0 };
   await mkdir15(to, { recursive: true });
   for (const entry of MOVED_ENTRIES) {
-    await copyTree(path54.join(from, entry), path54.join(to, entry), result);
+    await copyTree(path57.join(from, entry), path57.join(to, entry), result);
   }
   return result;
 }
-function isSameOrInside(child, parent, platform) {
+function isSameOrInside2(child, parent, platform) {
   const childKey = normalizeCwdKey(child, platform);
   const parentKey = normalizeCwdKey(parent, platform);
   if (childKey.length === 0 || parentKey.length === 0) return false;
@@ -20487,26 +21888,26 @@ function checkVaultTarget(current, target, options) {
   if (!isAbsoluteDir(target, options.platform)) {
     return { kind: "refused", text: serverText("vaultTargetNotAbsolute") };
   }
-  const isProtected = isInsideProtected(target, options.protectedDirs) || options.protectedDirs.some((dir) => isSameOrInside(target, dir, options.platform));
+  const isProtected = isInsideProtected(target, options.protectedDirs) || options.protectedDirs.some((dir) => isSameOrInside2(target, dir, options.platform));
   if (isProtected) {
     return { kind: "refused", text: serverText("vaultTargetCliFolder") };
   }
   if (normalizeCwdKey(current, options.platform) === normalizeCwdKey(target, options.platform)) {
     return { kind: "same" };
   }
-  if (isSameOrInside(target, current, options.platform)) {
+  if (isSameOrInside2(target, current, options.platform)) {
     return { kind: "refused", text: serverText("vaultTargetInsideCurrent") };
   }
-  if (isSameOrInside(current, target, options.platform)) {
+  if (isSameOrInside2(current, target, options.platform)) {
     return { kind: "refused", text: serverText("vaultCurrentInsideTarget") };
   }
   return { kind: "ok" };
 }
 async function canWriteInto(dir) {
-  const probe = temporaryPathFor(path54.join(dir, ".escritura"));
+  const probe = temporaryPathFor(path57.join(dir, ".escritura"));
   try {
     await mkdir15(dir, { recursive: true });
-    if (!(await stat32(dir)).isDirectory()) return false;
+    if (!(await stat35(dir)).isDirectory()) return false;
     await writeFile9(probe, "");
     return true;
   } catch {
@@ -20517,12 +21918,12 @@ async function canWriteInto(dir) {
 }
 
 // packages/server/src/vault/serialize.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function imageKey(eventId, source, index) {
   return `${eventId}|${source}|${index}`;
 }
 function assetName(bytes) {
-  const hash = createHash4("sha256").update(bytes).digest("hex").slice(0, 32);
+  const hash = createHash5("sha256").update(bytes).digest("hex").slice(0, 32);
   return `${hash}.${detectImageFormat(bytes)?.ext ?? "bin"}`;
 }
 function buildHeader(input) {
@@ -20609,12 +22010,12 @@ function serializeSession(input) {
 }
 
 // packages/server/src/vault/writer.ts
-import { readdir as readdir17, rm as rm6, stat as stat34 } from "node:fs/promises";
-import path56 from "node:path";
+import { readdir as readdir17, rm as rm6, stat as stat37 } from "node:fs/promises";
+import path59 from "node:path";
 
 // packages/server/src/vault/memory-copy.ts
-import { mkdir as mkdir16, readdir as readdir16, readFile as readFile21, stat as stat33, utimes as utimes2 } from "node:fs/promises";
-import path55 from "node:path";
+import { mkdir as mkdir16, readdir as readdir16, readFile as readFile23, stat as stat36, utimes as utimes2 } from "node:fs/promises";
+import path58 from "node:path";
 var MEMORY_FILE_MAX_BYTES = 1024 * 1024;
 var MEMORY_MAX_FILES = 500;
 var MEMORY_SOURCE_FILE = "source.json";
@@ -20639,7 +22040,7 @@ async function listMemoryNotes(cwd) {
     let absolute;
     try {
       absolute = await resolveInside(cwd, `${MEMORY_DIR}/${name}`, { mustExist: true });
-      const info = await stat33(absolute);
+      const info = await stat36(absolute);
       if (!info.isFile() || info.size > MEMORY_FILE_MAX_BYTES) continue;
       notes.push({ name, absolute, size: info.size, mtimeMs: info.mtimeMs });
     } catch {
@@ -20653,7 +22054,7 @@ async function measureProjectMemory(cwd) {
 }
 async function isUpToDate(target, note) {
   try {
-    const info = await stat33(target);
+    const info = await stat36(target);
     return info.isFile() && info.size === note.size && Math.abs(info.mtimeMs - note.mtimeMs) < SAME_MTIME_MS;
   } catch {
     return false;
@@ -20661,7 +22062,7 @@ async function isUpToDate(target, note) {
 }
 async function exists3(file) {
   try {
-    await stat33(file);
+    await stat36(file);
     return true;
   } catch {
     return false;
@@ -20680,11 +22081,11 @@ async function copyProjectMemory(dir, cwd, platform, deps = DEFAULT_WRITE_DEPS)
     await mkdir16(target, { recursive: true });
   };
   for (const note of notes) {
-    const destination = path55.join(target, note.name);
+    const destination = path58.join(target, note.name);
     if (await isUpToDate(destination, note)) continue;
     let content;
     try {
-      content = await readFile21(note.absolute);
+      content = await readFile23(note.absolute);
     } catch {
       continue;
     }
@@ -20696,7 +22097,7 @@ async function copyProjectMemory(dir, cwd, platform, deps = DEFAULT_WRITE_DEPS)
     result.files += 1;
     result.bytes += content.length;
   }
-  const source = path55.join(target, MEMORY_SOURCE_FILE);
+  const source = path58.join(target, MEMORY_SOURCE_FILE);
   if (result.files > 0 || !await exists3(source)) {
     await prepare();
     await writeFileAtomic(source, `${JSON.stringify({ cwd, copiedAt: deps.now() })}
@@ -21190,7 +22591,7 @@ var VaultWriter = class {
   }
   async assetOnDisk(dir, agent, sessionId, asset, bytes) {
     try {
-      const info = await stat34(assetFile(dir, agent, sessionId, asset));
+      const info = await stat37(assetFile(dir, agent, sessionId, asset));
       return info.isFile() && info.size === bytes;
     } catch {
       return false;
@@ -21290,17 +22691,17 @@ var VaultWriter = class {
     const folders = [dir];
     const subfolders = async (parent) => {
       try {
-        return (await readdir17(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path56.join(parent, entry.name));
+        return (await readdir17(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path59.join(parent, entry.name));
       } catch {
         return [];
       }
     };
     for (const agentDir of await subfolders(sessionsRoot2(dir))) {
-      if (!SESSION_AGENT_IDS.includes(path56.basename(agentDir))) continue;
+      if (!SESSION_AGENT_IDS.includes(path59.basename(agentDir))) continue;
       folders.push(agentDir);
       folders.push(...(await subfolders(agentDir)).filter((folder) => folder.endsWith(".assets")));
     }
-    folders.push(...await subfolders(path56.join(dir, "memory")));
+    folders.push(...await subfolders(path59.join(dir, "memory")));
     for (const folder of folders) {
       let names;
       try {
@@ -21310,9 +22711,9 @@ var VaultWriter = class {
       }
       for (const name of names) {
         if (!OWN_TEMP_FILE2.test(name)) continue;
-        const file = path56.join(folder, name);
+        const file = path59.join(folder, name);
         try {
-          const info = await stat34(file);
+          const info = await stat37(file);
           if (info.isFile() && now - info.mtimeMs > TEMP_MAX_AGE_MS) await rm6(file, { force: true });
         } catch {
         }
@@ -21500,14 +22901,14 @@ var VaultService = class {
   async setDir(target) {
     const { platform, agents, settings: settings2, catalog } = this.options;
     const current = this.dir();
-    const protectedDirs = [...agents.protectedDirs(), path57.join(this.options.homeDir ?? homedir14(), ".gemini")];
+    const protectedDirs = [...agents.protectedDirs(), path60.join(this.options.homeDir ?? homedir14(), ".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 stat35(vaultMarkerFile(current)).then(
+        const hadCopy = await stat38(vaultMarkerFile(current)).then(
           () => true,
           () => false
         );
@@ -21541,7 +22942,7 @@ var VaultService = class {
   /** Abre la carpeta de la copia con el explorador del sistema. */
   async reveal() {
     const dir = this.activeDir();
-    const isFolder = await stat35(dir).then(
+    const isFolder = await stat38(dir).then(
       (info) => info.isDirectory(),
       () => false
     );
@@ -21565,7 +22966,7 @@ var VaultService = class {
       fromCopy: true
     });
     const file = sessionExportFile(dir, agent, sessionId);
-    await mkdir17(path57.dirname(file), { recursive: true });
+    await mkdir17(path60.dirname(file), { recursive: true });
     await writeFileAtomic(file, text, this.writeDeps);
     this.openWithSystem(file);
     return file;
@@ -21669,7 +23070,7 @@ var VaultService = class {
         continue;
       }
       const fileName = this.exportFileName(summary, names);
-      await writeFileAtomic(path57.join(folder, fileName), text, this.writeDeps);
+      await writeFileAtomic(path60.join(folder, fileName), text, this.writeDeps);
       entries.push({
         updatedAt: summary.updatedAt,
         agentLabel: this.labelOf(summary.agent),
@@ -21680,9 +23081,9 @@ var VaultService = class {
       });
       await nextTurn3();
     }
-    const name = project.cwd.length > 0 ? path57.basename(project.cwd) || project.cwd : project.fallbackName;
+    const name = project.cwd.length > 0 ? path60.basename(project.cwd) || project.cwd : project.fallbackName;
     const index = renderProjectIndex({ name, cwd: project.cwd, exportedAt: this.now(), entries, skipped });
-    await writeFileAtomic(path57.join(folder, "index.md"), index, this.writeDeps);
+    await writeFileAtomic(path60.join(folder, "index.md"), index, this.writeDeps);
     this.openWithSystem(folder);
     return { sessions: entries.length, skipped, folder };
   }
@@ -21819,6 +23220,7 @@ var VaultService = class {
 
 // packages/server/src/terminal-socket.ts
 var NOTE_SEND_TIMEOUT_MS = 15e3;
+var REWIND_EXTRA_STEPS = 30;
 var NO_DEFAULTS = { model: null, effort: null, contextWindow: null };
 var PLAIN_INPUT = {
   imageReference: null,
@@ -21938,8 +23340,10 @@ function attachTerminalSocket(options) {
   };
   const onIndexStatus = (status) => broadcast({ type: "index.status", status });
   const onIndexProjects = (projects, replace) => broadcast({ type: "index.projects", projects, replace });
-  const onConversationAppend = (terminalId, events, usage, permissionMode) => {
-    broadcast({ type: "conversation.append", terminalId, events, usage, permissionMode });
+  const onConversationAppend = (terminalId, events, usage, permissionMode, queue) => {
+    broadcast(
+      queue === void 0 ? { type: "conversation.append", terminalId, events, usage, permissionMode } : { type: "conversation.append", terminalId, events, usage, permissionMode, queue }
+    );
     repos.onConversationActivity(terminalId);
   };
   const onGitStatus = (terminalId, status) => broadcast({ type: "git.status", terminalId, status });
@@ -21949,6 +23353,7 @@ function attachTerminalSocket(options) {
   const onConversationWaiting = (terminalId, waitingFor) => broadcast({ type: "conversation.waiting", terminalId, waitingFor });
   const onConversationToolCall = (terminalId, open9) => broadcast({ type: "conversation.toolCall", terminalId, open: open9 });
   const onConversationSubagents = (terminalId, subagents) => broadcast({ type: "conversation.subagents", terminalId, subagents });
+  const onConversationQueue = (terminalId, queue) => broadcast({ type: "conversation.queue", terminalId, queue });
   const onConversationPlans = (terminalId, plans) => broadcast({ type: "conversation.plans", terminalId, plans });
   const onConversationTurns = (terminalId, turns) => broadcast({ type: "conversation.turns", terminalId, turns });
   const onConversationParts = (terminalId, updates) => broadcast({ type: "conversation.parts", terminalId, updates });
@@ -21959,6 +23364,76 @@ function attachTerminalSocket(options) {
     return await adapter.defaults(descriptor.cwd, sessionModel) ?? NO_DEFAULTS;
   };
   const pieceWriter = (socket, terminalId) => (piece) => writeToTerminal(socket, terminalId, piece);
+  const interruptAgent = (socket, terminalId, options2) => {
+    writeQueue.interrupt(terminalId);
+    const [first, ...rest] = buildInterruptKeys(inputOf(terminalId).interruptPresses);
+    if (first === void 0 || !writeToTerminal(socket, terminalId, first)) return false;
+    const adapter = adapterOf(terminalId);
+    if (!options2.resend && adapter?.queuedSubmits !== void 0 && adapter.promptQueue?.source === "app") {
+      conversations.clearQueued(terminalId);
+    }
+    const reclaimFrom = adapter?.queuedSubmits;
+    if (reclaimFrom !== void 0) {
+      const taken = queuedSubmits.take(terminalId);
+      const interruptedAt = Date.now();
+      if (taken.length > 0) {
+        void writeQueue.enqueue(
+          terminalId,
+          async (lane) => {
+            const outcome = await reclaimQueuedSubmits({
+              source: reclaimFrom,
+              target: () => {
+                const tab = registry.get(terminalId);
+                return tab === null || !tab.alive || tab.sessionId.length === 0 ? null : { cwd: tab.cwd, sessionId: tab.sessionId };
+              },
+              submissions: taken,
+              interruptedAt,
+              lastClearKeyAt: () => queuedSubmits.lastClearKeyAt(terminalId),
+              writeClearKey: () => {
+                if (!registry.write(terminalId, CLEAR_EDITOR)) return false;
+                queuedSubmits.noteClearKey(terminalId, Date.now());
+                return true;
+              },
+              prefill: options2.resend ? async (returned) => {
+                const input = inputOf(terminalId);
+                const pieces = buildSubmissionWrites(returned, [], input, { send: true });
+                if (pieces === null) return;
+                registry.noteSubmitted(terminalId, returned);
+                const written = await lane.writePieces(pieces, input.pieceGapMs, pieceWriter(socket, terminalId));
+                if (written === "written") queuedSubmits.note(terminalId, returned, Date.now());
+                debugLog("write", `force send to ${terminalId.slice(0, 8)}: resent, ${written}`);
+              } : (returned) => send(socket, {
+                type: "composer.prefill",
+                terminalId,
+                text: returned,
+                reason: reclaimFrom.returnReason
+              }),
+              // La CLI deshizo el mensaje sin escribirlo (hito 44): el hilo lo esconde desde el primero.
+              withdraw: (eventIds) => {
+                const first2 = eventIds[0];
+                if (first2 !== void 0) conversations.withdraw(terminalId, first2);
+              },
+              wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+              now: Date.now
+            });
+            debugLog("write", `queued messages of ${terminalId.slice(0, 8)} after an interrupt: ${outcome}`);
+          },
+          { interruptible: false }
+        );
+      }
+    }
+    if (rest.length > 0) {
+      void writeQueue.enqueue(
+        terminalId,
+        async (lane) => {
+          await new Promise((resolve) => setTimeout(resolve, ANSWER_KEY_INTERVAL_MS));
+          await lane.writePieces(rest, ANSWER_KEY_INTERVAL_MS, pieceWriter(socket, terminalId));
+        },
+        { interruptible: false }
+      );
+    }
+    return true;
+  };
   const dropTab = (terminalId) => {
     const draftOwner = draftOwnerOf(registry.get(terminalId));
     if (!registry.close(terminalId)) return false;
@@ -22014,7 +23489,8 @@ function attachTerminalSocket(options) {
         // El de ahora y no el del snapshot: leer la configuracion es asincrono,
         // y un aviso que salio mientras tanto no puede quedar pisado por uno viejo.
         openToolCall: conversations.isToolCallOpen(terminalId),
-        subagents: conversations.getSubagents(terminalId)
+        subagents: conversations.getSubagents(terminalId),
+        queue: conversations.getQueue(terminalId)
       });
     });
   };
@@ -22030,6 +23506,7 @@ function attachTerminalSocket(options) {
   conversations.on("waiting", onConversationWaiting);
   conversations.on("toolCall", onConversationToolCall);
   conversations.on("subagents", onConversationSubagents);
+  conversations.on("queue", onConversationQueue);
   conversations.on("turns", onConversationTurns);
   conversations.on("plans", onConversationPlans);
   conversations.on("parts", onConversationParts);
@@ -22099,6 +23576,7 @@ function attachTerminalSocket(options) {
     const gitSubscriptions = /* @__PURE__ */ new Set();
     const memorySubscriptions = /* @__PURE__ */ new Set();
     const pickers = new DirectoryPickers(agents.protectedDirs());
+    const folders = cliFolders(agents.protectedDirs());
     const globalSearch = new GlobalSearchSlot();
     const cwdOf = (terminalId) => {
       const descriptor = registry.get(terminalId);
@@ -22156,7 +23634,8 @@ function attachTerminalSocket(options) {
       defaultCwd,
       shellName: appSettings.currentShell()?.name ?? null,
       remoteClient: deviceId !== null,
-      fileCheck: true
+      fileCheck: true,
+      fileWrite: true
     });
     send(socket, terminalListMessage());
     for (const entry of registry.activitySnapshot()) {
@@ -22330,11 +23809,15 @@ function attachTerminalSocket(options) {
                 { startAfterMs }
               );
               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()
+                  Date.now(),
+                  fullText
                 );
               }
               if (outcome === "interrupted") interrupted();
@@ -22505,59 +23988,156 @@ function attachTerminalSocket(options) {
           terminal se descarta antes, para que no caiga detras del Esc un
           Enter que mande lo que el usuario acaba de interrumpir.
         */
-        case "agent.interrupt": {
-          writeQueue.interrupt(message.terminalId);
-          const [first, ...rest] = buildInterruptKeys(inputOf(message.terminalId).interruptPresses);
-          if (first === void 0 || !writeToTerminal(socket, message.terminalId, first)) break;
-          const reclaimFrom = adapterOf(message.terminalId)?.queuedSubmits;
-          if (reclaimFrom !== void 0) {
-            const reclaimId = message.terminalId;
-            const taken = queuedSubmits.take(reclaimId);
-            const interruptedAt = Date.now();
-            if (taken.length > 0) {
-              void writeQueue.enqueue(
-                reclaimId,
-                async () => {
-                  const outcome = await reclaimQueuedSubmits({
-                    source: reclaimFrom,
-                    target: () => {
-                      const tab = registry.get(reclaimId);
-                      return tab === null || !tab.alive || tab.sessionId.length === 0 ? null : { cwd: tab.cwd, sessionId: tab.sessionId };
-                    },
-                    submissions: taken,
-                    interruptedAt,
-                    lastClearKeyAt: () => queuedSubmits.lastClearKeyAt(reclaimId),
-                    writeClearKey: () => {
-                      if (!registry.write(reclaimId, CLEAR_EDITOR)) return false;
-                      queuedSubmits.noteClearKey(reclaimId, Date.now());
-                      return true;
+        case "agent.interrupt":
+          interruptAgent(socket, message.terminalId, { resend: false });
+          break;
+        /*
+          "Forzar envio ahora" (hito 45, §6.35): que el agente lea ya lo que
+          espera en la cola de la CLI. Es para cuando va por mal camino. Se
+          comprueba todo antes de escribir nada: escribir de mas en una pty no
+          se deshace. Con su tecla de "enviar ya" (Claude Code, Antigravity), por
+          la fila de la pestana: no puede caer en medio de un pegado. Sin tecla
+          (Pi), se detiene y se vuelve a mandar lo que la CLI devuelve.
+        */
+        case "agent.forceSend": {
+          const { terminalId, requestId } = message;
+          let replied = false;
+          const reply = (sent) => {
+            if (replied) return;
+            replied = true;
+            send(socket, { type: "agent.forceSent", terminalId, requestId, sent });
+          };
+          const refuse = (code, text2) => {
+            sendError(socket, code, text2, void 0, requestId);
+            reply(false);
+          };
+          const adapter = adapterOf(terminalId);
+          const method = adapter !== null && adapter.capabilities.forceSend ? adapter.promptQueue?.forceSend ?? null : null;
+          if (method === null) {
+            refuse("agent-unsupported", serverText("forceSendUnsupported"));
+            break;
+          }
+          const tab = registry.get(terminalId);
+          if (tab === null || !tab.alive) {
+            refuse("force-send-failed", serverText("forceSendNoCli"));
+            break;
+          }
+          if (registry.activityOf(terminalId) === "waiting") {
+            refuse("force-send-failed", serverText("forceSendWaiting"));
+            break;
+          }
+          if (!conversations.hasQueue(terminalId)) {
+            refuse("force-send-failed", serverText("forceSendNothing"));
+            break;
+          }
+          conversations.markQueueForced(terminalId);
+          if (method === "interrupt-and-resend") {
+            if (interruptAgent(socket, terminalId, { resend: true })) reply(true);
+            else refuse("force-send-failed", serverText("forceSendFailed"));
+            break;
+          }
+          const keys = buildForceSendKeys(method);
+          void writeQueue.enqueue(
+            terminalId,
+            async (lane) => {
+              const outcome = await lane.writePieces([keys], 0, pieceWriter(socket, terminalId));
+              debugLog("write", `force send to ${terminalId.slice(0, 8)}: ${method}, ${outcome}`);
+              if (outcome === "written") reply(true);
+              else refuse("force-send-failed", serverText("forceSendFailed"));
+            },
+            { interruptible: false }
+          ).then(() => reply(false));
+          break;
+        }
+        /*
+          Volver a antes de un mensaje (hito 44, §4.16): la app maneja el menu de
+          rewind de la CLI mirando su pantalla en cada paso, y el mensaje vuelve
+          al cuadro. Por la fila de la pestana y sin dejarse cortar: un envio que
+          llegara en el medio caeria como teclas sobre el menu.
+        */
+        case "agent.rewind": {
+          const { terminalId, eventId, requestId } = message;
+          const adapter = adapterOf(terminalId);
+          const driver = adapter !== null && adapter.capabilities.rewind ? adapter.rewind ?? null : null;
+          if (driver === null) {
+            sendError(socket, "agent-unsupported", serverText("rewindUnsupported"), void 0, requestId);
+            break;
+          }
+          const tab = registry.get(terminalId);
+          if (tab === null || !tab.alive) {
+            sendError(socket, "rewind-failed", serverText("rewindNoCli"), void 0, requestId);
+            break;
+          }
+          if (registry.activityOf(terminalId) !== "idle") {
+            sendError(socket, "rewind-failed", serverText("rewindBusy"), void 0, requestId);
+            break;
+          }
+          const target = conversations.rewindTarget(terminalId, eventId);
+          if (target === null) {
+            sendError(socket, "rewind-failed", serverText("rewindUnknownMessage"), void 0, requestId);
+            break;
+          }
+          const restoreCode = message.restore === "conversation-and-code";
+          const session = { cwd: tab.cwd, sessionId: tab.sessionId };
+          void writeQueue.enqueue(
+            terminalId,
+            async () => {
+              const screen = registry.watchScreen(terminalId);
+              if (screen === null) {
+                sendError(socket, "rewind-failed", serverText("rewindNoCli"), void 0, requestId);
+                return;
+              }
+              const seen = [];
+              let outcome;
+              try {
+                outcome = await driver.run(
+                  {
+                    write: (data) => registry.write(terminalId, data),
+                    screen: async () => {
+                      const lines = await screen.lines();
+                      const text3 = lines.join("\n");
+                      if (seen.at(-1) !== text3) seen.push(text3);
+                      if (seen.length > 4) seen.shift();
+                      return lines;
                     },
-                    prefill: (returned) => send(socket, {
-                      type: "composer.prefill",
-                      terminalId: reclaimId,
-                      text: returned,
-                      reason: "returned-by-cli"
-                    }),
                     wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
                     now: Date.now
-                  });
-                  debugLog("write", `queued messages of ${reclaimId.slice(0, 8)} after an interrupt: ${outcome}`);
-                },
-                { interruptible: false }
-              );
-            }
-          }
-          if (rest.length > 0) {
-            const terminalId = message.terminalId;
-            void writeQueue.enqueue(
-              terminalId,
-              async (lane) => {
-                await new Promise((resolve) => setTimeout(resolve, ANSWER_KEY_INTERVAL_MS));
-                await lane.writePieces(rest, ANSWER_KEY_INTERVAL_MS, pieceWriter(socket, terminalId));
-              },
-              { interruptible: false }
-            );
-          }
+                  },
+                  {
+                    firstLine: target.firstLine,
+                    occurrence: Math.max(1, target.occurrence),
+                    maxSteps: target.promptsFromHere + REWIND_EXTRA_STEPS,
+                    restoreCode
+                  }
+                );
+              } catch (error) {
+                console.warn(`[rewind] ${terminalId.slice(0, 8)}:`, error);
+                outcome = { kind: "failed", reason: "gone" };
+              } finally {
+                screen.dispose();
+              }
+              debugLog("write", `rewind of ${terminalId.slice(0, 8)}: ${JSON.stringify(outcome)}`);
+              if (outcome.kind === "failed") debugLog("rewind", `last screens:
+${seen.join("\n-----\n")}`);
+              if (outcome.kind === "failed") {
+                sendError(
+                  socket,
+                  "rewind-failed",
+                  outcome.reason === "gone" ? serverText("rewindNoCli") : serverText("rewindFailed"),
+                  outcome.reason,
+                  requestId
+                );
+                return;
+              }
+              const text2 = target.truncated ? await driver.fullText(session, eventId) ?? target.text : target.text;
+              if (text2.trim().length > 0) {
+                send(socket, { type: "composer.prefill", terminalId, text: text2, reason: "rewound" });
+              }
+              conversations.withdraw(terminalId, eventId);
+              send(socket, { type: "agent.rewound", terminalId, requestId, codeRestored: outcome.codeRestored });
+            },
+            { interruptible: false }
+          );
           break;
         }
         case "resize":
@@ -22705,7 +24285,8 @@ function attachTerminalSocket(options) {
               defaults: await defaultsFor(message.terminalId, snapshot.usage.lastModel),
               waitingFor: snapshot.waitingFor,
               openToolCall: conversations.isToolCallOpen(message.terminalId),
-              subagents: conversations.getSubagents(message.terminalId)
+              subagents: conversations.getSubagents(message.terminalId),
+              queue: conversations.getQueue(message.terminalId)
             });
             if (snapshot.plans.length > 0) {
               send(socket, {
@@ -22918,7 +24499,7 @@ function attachTerminalSocket(options) {
               return;
             }
             try {
-              const listing = await listDirectory(cwd, message.path, {
+              const listing = await listDirectory(cwd, message.path, await folders, {
                 includeHidden: message.includeHidden === true
               });
               send(socket, { type: "files.listing", terminalId: message.terminalId, listing });
@@ -22941,7 +24522,7 @@ function attachTerminalSocket(options) {
               return;
             }
             try {
-              const result = await searchFiles(cwd, message.query, {
+              const result = await searchFiles(cwd, message.query, await folders, {
                 includeHidden: message.includeHidden === true
               });
               send(socket, { type: "files.results", terminalId: message.terminalId, result });
@@ -22958,13 +24539,54 @@ function attachTerminalSocket(options) {
               return;
             }
             try {
-              const preview = await readPreview(cwd, message.path);
+              const preview = await readPreview(cwd, message.path, await folders);
               send(socket, { type: "files.preview", terminalId: message.terminalId, preview });
             } catch (error) {
               sendPathError(error, serverText("fileReadFailed"));
             }
           })();
           break;
+        /*
+          Guardar un archivo editado en el visor (Hito 46, §6.36): la segunda
+          escritura de la app dentro de un proyecto. Lo que llega es la ruta
+          relativa, el texto y la huella de lo que se abrio; que se puede
+          escribir lo decide `saveProjectFile`. Un remoto tambien guarda: ya
+          puede pedirle al agente que lo haga (§14.4).
+        */
+        case "files.write":
+          void (async () => {
+            const { requestId } = message;
+            const cwd = cwdOf(message.terminalId);
+            if (cwd === null) {
+              sendError(socket, "unknown-terminal", serverText("terminalGone"), void 0, requestId);
+              return;
+            }
+            try {
+              const result = await saveProjectFile(cwd, message.path, message.text, message.baseHash, await folders);
+              send(socket, {
+                type: "files.saved",
+                terminalId: message.terminalId,
+                requestId,
+                path: message.path,
+                outcome: result.outcome,
+                preview: result.preview
+              });
+            } catch (error) {
+              if (error instanceof InvalidPathError) {
+                sendError(socket, "invalid-path", error.text, void 0, requestId);
+                return;
+              }
+              const detail = error instanceof Error ? error.message : String(error);
+              sendError(
+                socket,
+                "write-failed",
+                error instanceof FileWriteError ? error.text : serverText("fileSaveFailed"),
+                detail,
+                requestId
+              );
+            }
+          })();
+          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
@@ -22975,7 +24597,7 @@ function attachTerminalSocket(options) {
         case "files.check":
           void (async () => {
             const cwd = cwdOf(message.terminalId);
-            const existing = cwd === null ? [] : await existingFiles(cwd, message.paths).catch(() => []);
+            const existing = cwd === null ? [] : await existingFiles(cwd, message.paths, await folders).catch(() => []);
             send(socket, { type: "files.checked", terminalId: message.terminalId, requestId: message.requestId, existing });
           })();
           break;
@@ -22987,7 +24609,9 @@ function attachTerminalSocket(options) {
               return;
             }
             try {
-              revealPath(await resolveInside(cwd, message.path, { mustExist: true }));
+              const absolute = await resolveInside(cwd, message.path, { mustExist: true });
+              if (await (await folders).contains(absolute)) throw new InvalidPathError(serverText("cliFolderClosed"));
+              revealPath(absolute);
             } catch (error) {
               sendPathError(error, serverText("pathOpenFailed"));
             }
@@ -23407,6 +25031,7 @@ function attachTerminalSocket(options) {
     conversations.off("waiting", onConversationWaiting);
     conversations.off("toolCall", onConversationToolCall);
     conversations.off("subagents", onConversationSubagents);
+    conversations.off("queue", onConversationQueue);
     repos.off("status", onGitStatus);
     memory.off("status", onMemoryStatus);
     stopAgentChanges();
@@ -23420,9 +25045,9 @@ function attachTerminalSocket(options) {
 }
 
 // packages/server/src/vault/catalog.ts
-import { open as open8, readdir as readdir18, stat as stat36 } from "node:fs/promises";
-import path58 from "node:path";
-import { createInterface as createInterface3 } from "node:readline";
+import { open as open8, readdir as readdir18, stat as stat39 } from "node:fs/promises";
+import path61 from "node:path";
+import { createInterface as createInterface4 } from "node:readline";
 var HEADER_MAX_BYTES = 64 * 1024;
 var LOAD_CONCURRENCY = 16;
 var keyOf2 = (agent, sessionId) => `${agent}/${sessionId}`;
@@ -23441,7 +25066,7 @@ async function assetBytesOf(dir, agent, sessionId) {
   for (const name of names) {
     if (!VAULT_ASSET_NAME_PATTERN.test(name)) continue;
     try {
-      const info = await stat36(path58.join(folder, name));
+      const info = await stat39(path61.join(folder, name));
       if (info.isFile()) total += info.size;
     } catch {
     }
@@ -23452,7 +25077,7 @@ async function readEntry2(dir, agent, sessionId) {
   const file = sessionFile(dir, agent, sessionId);
   let sizeBytes;
   try {
-    const info = await stat36(file);
+    const info = await stat39(file);
     if (!info.isFile()) return { kind: "absent" };
     sizeBytes = info.size;
   } catch {
@@ -23609,7 +25234,7 @@ var VaultCatalog = class {
     const handle = await open8(sessionFile(dir, agent, sessionId), "r").catch(() => null);
     if (handle === null) return;
     const input = handle.createReadStream({ encoding: "utf8" });
-    const lines = createInterface3({ input, crlfDelay: Number.POSITIVE_INFINITY });
+    const lines = createInterface4({ input, crlfDelay: Number.POSITIVE_INFINITY });
     let sawHeader = false;
     try {
       for await (const raw of lines) {
@@ -23661,15 +25286,15 @@ var VaultCatalog = class {
 };
 
 // packages/server/src/index.ts
-var serverDir = path59.dirname(fileURLToPath2(import.meta.url));
+var serverDir = path62.dirname(fileURLToPath2(import.meta.url));
 var isPackaged = true;
-var webRoot = isPackaged ? serverDir : path59.resolve(serverDir, "../../web");
-var webDist = isPackaged ? path59.join(serverDir, "web") : path59.join(webRoot, "dist");
-var repoRoot = path59.resolve(serverDir, "../../..");
+var webRoot = isPackaged ? serverDir : path62.resolve(serverDir, "../../web");
+var webDist = isPackaged ? path62.join(serverDir, "web") : path62.join(webRoot, "dist");
+var repoRoot = path62.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 path59.resolve(override);
+  if (override !== void 0 && override.length > 0) return path62.resolve(override);
   if (isPackaged) return process.cwd();
   return repoRoot;
 }
@@ -23744,7 +25369,7 @@ async function mountDevUi(app, httpServer) {
 }
 var LOOKS_LIKE_FILE = /\.[a-zA-Z0-9]{1,8}$/;
 function mountBuiltUi(app) {
-  const indexHtml = path59.join(webDist, "index.html");
+  const indexHtml = path62.join(webDist, "index.html");
   if (!existsSync4(indexHtml)) {
     throw new Error(
       `There's no compiled interface in ${webDist}.
@@ -23886,6 +25511,7 @@ async function main() {
   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));