agent-workbench 0.5.4 → 0.6.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 path51 from "node:path";
+import path59 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import express from "express";
 
@@ -93,7 +93,7 @@ var ServerTextError = class extends Error {
 };
 
 // packages/shared/src/agents.ts
-var AGENT_IDS = ["claude-code", "codex", "opencode", "antigravity"];
+var AGENT_IDS = ["claude-code", "codex", "opencode", "antigravity", "pi"];
 var IMPORTED_AGENT_IDS = ["gemini-cli", "antigravity-ide"];
 var SESSION_AGENT_IDS = [...AGENT_IDS, ...IMPORTED_AGENT_IDS];
 var IMPORTED_AGENT_LABELS = {
@@ -204,7 +204,7 @@ function fitWindowToObserved(window, observedTokens) {
   if (window === null || observedTokens <= window) {
     return { window, estimated: false };
   }
-  const next = WINDOW_LADDER.find((step) => step > observedTokens);
+  const next = WINDOW_LADDER.find((step2) => step2 > observedTokens);
   return next === void 0 ? (
     // Mas grande que el mayor escalon conocido: el limite real se nos escapa,
     // y decirlo es mejor que dibujar una barra contra un numero inventado.
@@ -411,7 +411,8 @@ var MEMORY_AGENT_LABELS = {
   "claude-code": "Claude Code",
   codex: "Codex",
   antigravity: "Antigravity",
-  opencode: "OpenCode"
+  opencode: "OpenCode",
+  pi: "Pi"
 };
 var MEMORY_BLOCK_BODY = [
   "## Project memory",
@@ -646,12 +647,12 @@ function parseVaultBodyLine(value) {
   const record = asRecord(value);
   if (record === null) return null;
   if (record["kind"] === "event") {
-    const event = parseConversationEvent(record["event"]);
+    const event2 = parseConversationEvent(record["event"]);
     const images = asArrayOf(record["images"], parseVaultImageRef);
-    if (event === null || images === null) return null;
-    const imageParts = event.parts.filter((part) => part.kind === "image").length;
+    if (event2 === null || images === null) return null;
+    const imageParts = event2.parts.filter((part) => part.kind === "image").length;
     if (images.length !== imageParts) return null;
-    return { kind: "event", event, images };
+    return { kind: "event", event: event2, images };
   }
   if (record["kind"] === "document") {
     const name = asNonEmptyString(record["name"]);
@@ -721,6 +722,8 @@ 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 FILES_CHECK_MAX_PATHS = 100;
+var FILES_CHECK_MAX_PATH_CHARS = 512;
 var CONTINUE_LABEL_MAX_CHARS = 120;
 function parseSubmitImage(value) {
   const record = asRecord(value);
@@ -774,6 +777,7 @@ function parseClientMessage(raw) {
       if (record["send"] === false) message.send = false;
       const requestId = asNonEmptyString(record["requestId"]);
       if (requestId !== null) message.requestId = requestId;
+      if (record["keepDraft"] === true) message.keepDraft = true;
       return message;
     }
     case "agent.mode": {
@@ -916,6 +920,20 @@ function parseClientMessage(raw) {
       const readPath = asNonEmptyString(record["path"]);
       return terminalId === null || readPath === null ? null : { type: "files.read", terminalId, path: readPath };
     }
+    case "files.check": {
+      const terminalId = asNonEmptyString(record["terminalId"]);
+      const requestId = asNonEmptyString(record["requestId"]);
+      const rawPaths = record["paths"];
+      if (terminalId === null || requestId === null || !Array.isArray(rawPaths)) return null;
+      const paths = [];
+      for (const candidate of rawPaths) {
+        if (paths.length >= FILES_CHECK_MAX_PATHS) break;
+        if (typeof candidate === "string" && candidate.length > 0 && candidate.length <= FILES_CHECK_MAX_PATH_CHARS) {
+          paths.push(candidate);
+        }
+      }
+      return { type: "files.check", terminalId, requestId, paths };
+    }
     case "plans.read": {
       const terminalId = asNonEmptyString(record["terminalId"]);
       const fileName = asNonEmptyString(record["fileName"]);
@@ -1379,12 +1397,17 @@ async function readVersion(file, prefixArgs) {
     return null;
   }
 }
+function launcherFor(resolvedPath) {
+  const useInterpreter = needsCommandInterpreter(resolvedPath);
+  return {
+    file: useInterpreter ? process.env["ComSpec"] ?? "cmd.exe" : resolvedPath,
+    prefixArgs: useInterpreter ? ["/c", resolvedPath] : []
+  };
+}
 async function locateCommand(command) {
   const resolvedPath = await findInPath(command);
   if (resolvedPath === null) return null;
-  const useInterpreter = needsCommandInterpreter(resolvedPath);
-  const file = useInterpreter ? process.env["ComSpec"] ?? "cmd.exe" : resolvedPath;
-  const prefixArgs = useInterpreter ? ["/c", resolvedPath] : [];
+  const { file, prefixArgs } = launcherFor(resolvedPath);
   return {
     resolvedPath,
     file,
@@ -2554,7 +2577,7 @@ var JsonlFollower = class {
     return this.state;
   }
   find(eventId) {
-    return this.events.find((event) => event.eventId === eventId);
+    return this.events.find((event2) => event2.eventId === eventId);
   }
   eventCount() {
     return this.events.length;
@@ -2569,7 +2592,7 @@ var JsonlFollower = class {
   }
   /** Tramo anterior a un evento ya entregado. Vacio si ese id ya no esta. */
   getPageBefore(beforeEventId, limit) {
-    const index = this.events.findIndex((event) => event.eventId === beforeEventId);
+    const index = this.events.findIndex((event2) => event2.eventId === beforeEventId);
     if (index <= 0) return { events: [], hasMore: false };
     const start = Math.max(0, index - limit);
     return {
@@ -2653,8 +2676,8 @@ var JsonlFollower = class {
         while (newlineIndex !== -1) {
           const line = combined.subarray(start, newlineIndex).toString("utf8");
           start = newlineIndex + 1;
-          const event = this.consumeLine(line);
-          if (event !== null) added.push(event);
+          const event2 = this.consumeLine(line);
+          if (event2 !== null) added.push(event2);
           newlineIndex = combined.indexOf(NEWLINE, start);
         }
         this.pending = Buffer.from(combined.subarray(start));
@@ -2676,14 +2699,14 @@ var JsonlFollower = class {
     if (line.length === 0) return null;
     const record = parseJsonlLine(line);
     if (record === null) return null;
-    const event = this.sink.consume(record, this.lineNumber, this);
-    if (event === null) return null;
-    this.events.push(event);
+    const event2 = this.sink.consume(record, this.lineNumber, this);
+    if (event2 === null) return null;
+    this.events.push(event2);
     if (this.events.length > this.maxEvents) {
       this.events.shift();
       this.dropped += 1;
     }
-    return event;
+    return event2;
   }
 };
 
@@ -2705,9 +2728,9 @@ function cut(raw, limit) {
   if (raw.length <= limit) return { text: raw, truncated: false };
   return { text: raw.slice(0, limit), truncated: true };
 }
-function limitEvent(event, limits) {
+function limitEvent(event2, limits) {
   let changed = false;
-  const parts = event.parts.map((part) => {
+  const parts = event2.parts.map((part) => {
     if (part.kind === "text" && part.text.length > limits.textMaxChars) {
       changed = true;
       return { ...part, text: part.text.slice(0, limits.textMaxChars), truncated: true };
@@ -2722,7 +2745,7 @@ function limitEvent(event, limits) {
     }
     return part;
   });
-  return changed ? { ...event, parts } : event;
+  return changed ? { ...event2, parts } : event2;
 }
 
 // packages/server/src/agents/antigravity/model-label.ts
@@ -2751,12 +2774,12 @@ function blockPattern(name) {
   return new RegExp(`<${name}>([\\s\\S]*?)</${name}>`, "g");
 }
 function unwrapUserInput(content) {
-  const open8 = content.indexOf(REQUEST_OPEN);
-  const close = open8 === -1 ? -1 : content.indexOf(REQUEST_CLOSE, open8 + REQUEST_OPEN.length);
+  const open9 = content.indexOf(REQUEST_OPEN);
+  const close = open9 === -1 ? -1 : content.indexOf(REQUEST_CLOSE, open9 + REQUEST_OPEN.length);
   let text;
   let rest;
-  if (open8 !== -1 && close !== -1) {
-    text = content.slice(open8 + REQUEST_OPEN.length, close).trim();
+  if (open9 !== -1 && close !== -1) {
+    text = content.slice(open9 + REQUEST_OPEN.length, close).trim();
     rest = content.slice(close + REQUEST_CLOSE.length);
   } else {
     text = content.replace(blockPattern("ADDITIONAL_METADATA"), "").replace(blockPattern("USER_SETTINGS_CHANGE"), "").trim();
@@ -3068,7 +3091,7 @@ var AntigravitySessionFollower = class {
     if (jsonl !== null && mapper !== null) {
       mapper.takeParts(/* @__PURE__ */ new Set());
       const { reset, added } = await jsonl.poll();
-      const fresh = new Set(added.map((event) => event.eventId));
+      const fresh = new Set(added.map((event2) => event2.eventId));
       result = { reset, added, turns: [], plans: [], parts: reset ? [] : mapper.takeParts(fresh) };
       if (jsonl.getState() === "waiting") {
         this.jsonl = null;
@@ -3261,7 +3284,7 @@ function createAntigravityHistory(deps = {}) {
     const compact = await stamp(paths.compact);
     return compact === null ? null : { file: paths.compact, info: compact };
   };
-  const itemOf3 = async (ref) => {
+  const itemOf4 = async (ref) => {
     if (!CONVERSATION_ID_PATTERN.test(ref)) return null;
     if (!await isDirectory(path7.join(brainRoot(), ref))) return null;
     const files = conversationFiles(ref);
@@ -3336,7 +3359,7 @@ function createAntigravityHistory(deps = {}) {
       }
       const items = [];
       for (const name of names) {
-        const item = await itemOf3(name);
+        const item = await itemOf4(name);
         if (item !== null) items.push(item);
       }
       return items;
@@ -3354,7 +3377,7 @@ function createAntigravityHistory(deps = {}) {
       }
       return null;
     },
-    item: (ref) => itemOf3(ref),
+    item: (ref) => itemOf4(ref),
     async scan(item) {
       const id = item.ref;
       const { history, lastWorkspace, summary } = catalog.get(id);
@@ -4690,6 +4713,11 @@ async function resolveRef(ref, target) {
     return null;
   }
 }
+function shownPathOf(ref, target) {
+  if (ref.origin === "cli-plans") return path15.join(plansRoot(), ref.path);
+  if (ref.origin === "scratch") return path15.join(scratchRoot(target.cwd, target.sessionId), ref.path);
+  return path15.join(target.cwd, ref.path);
+}
 function titleOf(relative) {
   return (path15.posix.basename(relative) || relative).replace(/\.md$/i, "");
 }
@@ -4704,6 +4732,8 @@ async function describePlans(target, refs) {
       origin: parsed.origin,
       // La carpeta de un plan de la CLI no aporta nada: es siempre la misma.
       path: parsed.origin === "cli-plans" ? "" : parsed.path,
+      // Solo de uno que esta en disco y paso el guardia: abajo.
+      absolutePath: "",
       exists: false,
       modifiedAt: 0,
       sizeBytes: 0
@@ -4714,6 +4744,7 @@ async function describePlans(target, refs) {
         const info = await stat9(absolute);
         if (info.isFile()) {
           plan.exists = true;
+          plan.absolutePath = shownPathOf(parsed, target);
           plan.modifiedAt = info.mtimeMs;
           plan.sizeBytes = info.size;
         }
@@ -4781,8 +4812,9 @@ var HARNESS_TAGS = [
   "bash-stderr"
 ];
 var HARNESS_BLOCK = new RegExp(`<(${HARNESS_TAGS.join("|")})>[\\s\\S]*?</\\1>`, "g");
+var PASTED_CONTENT = /<pasted_content id="([0-9A-Za-z_-]{1,64})">\n?([\s\S]*?)\n?<\/pasted_content id="\1">/g;
 function cleanUserText(raw) {
-  return raw.replace(HARNESS_BLOCK, "").trim();
+  return raw.replace(PASTED_CONTENT, "$2").replace(HARNESS_BLOCK, "").trim();
 }
 function isHumanOrigin(origin) {
   if (typeof origin !== "object" || origin === null) return true;
@@ -5484,7 +5516,7 @@ var ConversationFollower = class {
     this.partUpdates = [];
     this.freshPlans = [];
     const { reset, added } = await this.jsonl.poll();
-    const fresh = new Set(added.map((event) => event.eventId));
+    const fresh = new Set(added.map((event2) => event2.eventId));
     const turns = this.turns.filter((turn) => !fresh.has(turn.eventId));
     const parts = [
       ...new Map(
@@ -5563,10 +5595,10 @@ var ConversationFollower = class {
       this.applyImageAttachment(attachment, events);
       return null;
     }
-    const event = toConversationEvent(record, lineNumber, this.limits);
-    if (event === null) return null;
-    this.accumulate(event);
-    return event;
+    const event2 = toConversationEvent(record, lineNumber, this.limits);
+    if (event2 === null) return null;
+    this.accumulate(event2);
+    return event2;
   }
   /**
    * De que mensaje cuelga cada linea `attachment` ya vista.
@@ -5658,12 +5690,12 @@ var ConversationFollower = class {
    * `input_tokens` daria cifras absurdamente bajas, porque con cache casi todo
    * el contexto viaja como `cache_read`.
    */
-  accumulate(event) {
-    const usage = event.usage;
-    if (usage === null || event.role !== "assistant") return;
+  accumulate(event2) {
+    const usage = event2.usage;
+    if (usage === null || event2.role !== "assistant") return;
     const lastRequestTokens = usage.inputTokens + usage.cacheReadInputTokens + usage.cacheCreationInputTokens;
-    this.lastRawModel = event.model;
-    const model2 = this.resolveModel(event.model);
+    this.lastRawModel = event2.model;
+    const model2 = this.resolveModel(event2.model);
     const fitted = fitWindowToObserved(contextWindowFor(model2), lastRequestTokens);
     this.usage = {
       lastRequestTokens,
@@ -6054,7 +6086,7 @@ async function scanSessionFile(filePath, sessionId) {
   let cwd = null;
   let customTitle = null;
   let aiTitle = null;
-  let firstUserText2 = null;
+  let firstUserText3 = null;
   const modelIds = /* @__PURE__ */ new Set();
   const inspect = (line) => {
     const record = parseJsonlLine(line);
@@ -6072,10 +6104,10 @@ async function scanSessionFile(filePath, sessionId) {
       customTitle = record["customTitle"];
     } else if (type === "ai-title" && typeof record["aiTitle"] === "string") {
       aiTitle = record["aiTitle"];
-    } else if (firstUserText2 === null && isRealUserMessage(record)) {
+    } else if (firstUserText3 === null && isRealUserMessage(record)) {
       const message = record["message"];
       if (typeof message === "object" && message !== null) {
-        firstUserText2 = extractMessageText(message["content"]);
+        firstUserText3 = extractMessageText(message["content"]);
       }
     }
   };
@@ -6089,8 +6121,8 @@ async function scanSessionFile(filePath, sessionId) {
   } else if (aiTitle !== null) {
     title = toTitle(aiTitle);
     titleSource = "ai";
-  } else if (firstUserText2 !== null) {
-    title = toTitle(firstUserText2);
+  } else if (firstUserText3 !== null) {
+    title = toTitle(firstUserText3);
     titleSource = "first-message";
   } else {
     title = UNTITLED_SESSION_TITLE;
@@ -7274,9 +7306,9 @@ var CodexRolloutSink = class {
     }));
     if (text.length > 0) parts.push({ kind: "text", ...cut(text, this.limits.textMaxChars) });
     if (parts.length === 0) return null;
-    const event = this.event("user", lineNumber, at, parts);
-    if (images.length > 0) this.contentLines.set(event.eventId, lineNumber - 1);
-    return event;
+    const event2 = this.event("user", lineNumber, at, parts);
+    if (images.length > 0) this.contentLines.set(event2.eventId, lineNumber - 1);
+    return event2;
   }
   assistantMessage(payload, lineNumber, at) {
     const content = payload["content"];
@@ -7385,7 +7417,7 @@ var CodexSessionFollower = class {
     }
     this.sink.takeTurns(/* @__PURE__ */ new Set());
     const { reset, added } = await this.jsonl.poll();
-    const fresh = new Set(added.map((event) => event.eventId));
+    const fresh = new Set(added.map((event2) => event2.eventId));
     return { reset, added, turns: this.sink.takeTurns(fresh), plans: [], parts: [] };
   }
   async lookup() {
@@ -8154,8 +8186,8 @@ function applyTurnDurations(messages, lastEventOf) {
     if (latest2.completed_at === null || latest2.finish === "tool-calls") continue;
     let target;
     for (let index = steps.length - 1; index >= 0 && target === void 0; index -= 1) {
-      const step = steps[index];
-      if (step !== void 0) target = lastEventOf.get(step.id);
+      const step2 = steps[index];
+      if (step2 !== void 0) target = lastEventOf.get(step2.id);
     }
     const durationMs = latest2.completed_at - (user.created_at ?? user.time_created);
     if (target === void 0 || durationMs < 0) continue;
@@ -8530,7 +8562,7 @@ var OpenCodeSessionFollower = class {
   }
   getPageBefore(beforeEventId, limit) {
     const { events: all, dropped } = this.window();
-    const index = all.findIndex((event) => event.eventId === beforeEventId);
+    const index = all.findIndex((event2) => event2.eventId === beforeEventId);
     if (index <= 0) return { events: [], hasMore: false };
     const start = Math.max(0, index - limit);
     return { events: all.slice(start, index), hasMore: start > 0 || dropped > 0 };
@@ -8593,30 +8625,30 @@ function maxUpdated(rows) {
   return max;
 }
 function diffEvents(previous, next) {
-  const nextIndex = new Map(next.map((event, index) => [event.eventId, index]));
+  const nextIndex = new Map(next.map((event2, index) => [event2.eventId, index]));
   const known = /* @__PURE__ */ new Set();
   const parts = [];
   const turns = [];
   let lastIndex = -1;
-  for (const event of previous) {
-    const index = nextIndex.get(event.eventId);
+  for (const event2 of previous) {
+    const index = nextIndex.get(event2.eventId);
     if (index === void 0 || index < lastIndex) return null;
     lastIndex = index;
-    known.add(event.eventId);
+    known.add(event2.eventId);
     const rebuilt = next[index];
     if (rebuilt === void 0) return null;
-    if (JSON.stringify(rebuilt.parts) !== JSON.stringify(event.parts)) {
+    if (JSON.stringify(rebuilt.parts) !== JSON.stringify(event2.parts)) {
       parts.push({ eventId: rebuilt.eventId, parts: rebuilt.parts });
     }
-    if (rebuilt.durationMs !== null && rebuilt.durationMs !== event.durationMs) {
+    if (rebuilt.durationMs !== null && rebuilt.durationMs !== event2.durationMs) {
       turns.push({ eventId: rebuilt.eventId, durationMs: rebuilt.durationMs });
     }
   }
   const added = [];
-  for (const [index, event] of next.entries()) {
-    if (known.has(event.eventId)) continue;
+  for (const [index, event2] of next.entries()) {
+    if (known.has(event2.eventId)) continue;
     if (index < lastIndex) return null;
-    added.push(event);
+    added.push(event2);
   }
   return { added, parts, turns };
 }
@@ -8899,7 +8931,7 @@ function parseSseChunk(state, chunk) {
   let afterCarriageReturn = state.afterCarriageReturn;
   let atStart = state.atStart;
   let dataLines = [...state.dataLines];
-  let event = state.event;
+  let event2 = state.event;
   let lastId = state.lastId;
   if (afterCarriageReturn && bytes.length > 0) {
     if (bytes[0] === LF) bytes = bytes.subarray(1);
@@ -8928,9 +8960,9 @@ function parseSseChunk(state, chunk) {
     index++;
     lineStart = index;
     if (line.length === 0) {
-      if (dataLines.length > 0) messages.push({ event: event ?? "message", data: dataLines.join("\n"), id: lastId });
+      if (dataLines.length > 0) messages.push({ event: event2 ?? "message", data: dataLines.join("\n"), id: lastId });
       dataLines = [];
-      event = null;
+      event2 = null;
       continue;
     }
     if (line.startsWith(":")) continue;
@@ -8939,7 +8971,7 @@ function parseSseChunk(state, chunk) {
     let value = colon === -1 ? "" : line.slice(colon + 1);
     if (value.startsWith(" ")) value = value.slice(1);
     if (field === "data") dataLines.push(value);
-    else if (field === "event") event = value;
+    else if (field === "event") event2 = value;
     else if (field === "id" && !value.includes("\0")) lastId = value;
   }
   return {
@@ -8948,7 +8980,7 @@ function parseSseChunk(state, chunk) {
       afterCarriageReturn,
       atStart,
       dataLines,
-      event,
+      event: event2,
       lastId
     },
     messages
@@ -9157,10 +9189,10 @@ var OpenCodeServeClient = class {
             const parsed = parseSseChunk(state, value);
             state = parsed.state;
             for (const message of parsed.messages) {
-              const event = parseGlobalEvent(message.data);
-              if (event === null) continue;
+              const event2 = parseGlobalEvent(message.data);
+              if (event2 === null) continue;
               try {
-                onEvent(event);
+                onEvent(event2);
               } catch {
               }
             }
@@ -9593,6 +9625,7 @@ var SHIFT_TAB = "\x1B[Z";
 var SUBMIT = "\r";
 var END_KEY = "\x1B[F";
 var INTERRUPT = "\x1B";
+var CLEAR_EDITOR = "";
 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, "");
@@ -9605,7 +9638,13 @@ var IMAGE_REFERENCE_BUILDERS = {
   "at-quoted": (absolutePath) => `@"${absolutePath}"`,
   // La ruta sola: la CLI adjunta si el pegado entero es la ruta de una imagen.
   // Sin comillas, porque las comillas harian que ya no lo fuera.
-  "bare-path-paste": (absolutePath) => absolutePath
+  "bare-path-paste": (absolutePath) => absolutePath,
+  // Una linea por imagen, en ingles como todo lo que se le dice a una CLI: la
+  // CLI no adjunta nada y el modelo abre la ruta con su herramienta de lectura.
+  "quoted-path-line": (absolutePath) => `Attached image: "${absolutePath}"`
+};
+var IMAGE_REFERENCE_SEPARATORS = {
+  "quoted-path-line": "\n"
 };
 var TAB = "	";
 var ANSWER_KEY_INTERVAL_MS = 120;
@@ -9698,13 +9737,22 @@ function buildInterruptKeys(presses) {
   const count = Number.isInteger(presses) && presses > 1 ? presses : 1;
   return Array.from({ length: count }, () => INTERRUPT);
 }
-function joinedPayload(text, attachments) {
+function joinedPayload(text, attachments, separator = " ") {
   const pieces = [...attachments];
   const clean = sanitizeForPaste(text).trim();
   if (clean.length > 0) pieces.push(clean);
-  const payload = pieces.join(" ").slice(0, MAX_SUBMIT_CHARS);
+  const payload = pieces.join(separator).slice(0, MAX_SUBMIT_CHARS);
   return payload.length === 0 ? null : payload;
 }
+function submissionPayload(text, imagePaths, style) {
+  if (imagePaths.length > 0 && (style === null || style === "bare-path-paste")) return null;
+  const effective = style ?? "at-quoted";
+  return joinedPayload(
+    text,
+    imagePaths.map((imagePath) => fileReference(imagePath, effective)),
+    IMAGE_REFERENCE_SEPARATORS[effective] ?? " "
+  );
+}
 function pasted(payload, markers) {
   return markers ? `${PASTE_START}${payload}${PASTE_END}` : payload;
 }
@@ -9714,10 +9762,7 @@ function buildSubmissionWrites(text, imagePaths, shape, options = {}) {
   if (imagePaths.length > 0 && style === null) return null;
   const submit = shape.endBeforeSubmit === true ? `${END_KEY}${SUBMIT}` : SUBMIT;
   if (style !== "bare-path-paste") {
-    const payload = joinedPayload(
-      text,
-      imagePaths.map((imagePath) => fileReference(imagePath, style ?? "at-quoted"))
-    );
+    const payload = submissionPayload(text, imagePaths, style);
     if (payload === null) return null;
     if (shape.enterSeparately === true) {
       return send ? [pasted(payload, shape.pasteMarkers), submit] : [pasted(payload, shape.pasteMarkers)];
@@ -9818,24 +9863,24 @@ function activityOfTracked(session) {
   if (session.status === "busy" || session.status === "retry") return { activity: "busy", waitingFor: null };
   return { activity: "idle", waitingFor: null };
 }
-function applyEvent(session, { event, fromChild }) {
-  switch (event.type) {
+function applyEvent(session, { event: event2, fromChild }) {
+  switch (event2.type) {
     case "session.status":
-      if (!fromChild) session.status = event.status;
+      if (!fromChild) session.status = event2.status;
       break;
     case "permission.asked":
-      session.permissions.add(event.requestId);
+      session.permissions.add(event2.requestId);
       break;
     case "permission.replied":
-      session.permissions.delete(event.requestId);
+      session.permissions.delete(event2.requestId);
       break;
     case "question.asked":
-      (fromChild ? session.childQuestions : session.questions).add(event.requestId);
+      (fromChild ? session.childQuestions : session.questions).add(event2.requestId);
       break;
     case "question.replied":
     case "question.rejected":
-      session.questions.delete(event.requestId);
-      session.childQuestions.delete(event.requestId);
+      session.questions.delete(event2.requestId);
+      session.childQuestions.delete(event2.requestId);
       break;
   }
 }
@@ -9964,7 +10009,7 @@ var OpenCodeServeStatus = class {
     this.forget();
     this.client = client;
     this.closeEvents = client.events(
-      (event) => this.onEvent(event),
+      (event2) => this.onEvent(event2),
       () => this.onConnected()
     );
   }
@@ -9980,8 +10025,8 @@ var OpenCodeServeStatus = class {
     const directories = new Set([...this.tracked.values()].map((session) => session.directory));
     for (const directory of directories) void this.snapshot(directory);
   }
-  onEvent(event) {
-    const routed = this.route(event);
+  onEvent(event2) {
+    const routed = this.route(event2);
     if (routed === null) return;
     const session = this.tracked.get(routed.rootId);
     if (session === void 0) return;
@@ -9994,12 +10039,12 @@ var OpenCodeServeStatus = class {
    * sub-agente. El estado de otra sesion no se atribuye a nadie, y no hace
    * buscar ningun padre.
    */
-  route(event) {
-    if (this.tracked.has(event.sessionId)) return { event, rootId: event.sessionId, fromChild: false };
-    if (event.type === "session.status") return null;
-    const rootId = this.rootOf(event.sessionId);
-    if (rootId === null || rootId === event.sessionId || !this.tracked.has(rootId)) return null;
-    return { event, rootId, fromChild: true };
+  route(event2) {
+    if (this.tracked.has(event2.sessionId)) return { event: event2, rootId: event2.sessionId, fromChild: false };
+    if (event2.type === "session.status") return null;
+    const rootId = this.rootOf(event2.sessionId);
+    if (rootId === null || rootId === event2.sessionId || !this.tracked.has(rootId)) return null;
+    return { event: event2, rootId, fromChild: true };
   }
   /**
    * La raiz de una sesion subiendo por `parent_id`, o null si la base no la
@@ -10166,169 +10211,2111 @@ var OPENCODE_CAPABILITIES = {
   contextWindowSource: "usage-with-catalog",
   // No hay planes en archivo.
   plans: false,
-  /*
-    D12: con un permiso o una pregunta abiertos, el pegado y su Enter caerian
-    en el menu del TUI. El candado de §10.8 (`hasOpenToolCall`) no sirve: se
-    apaga con `statusSource`.
-  */
+  /*
+    D12: con un permiso o una pregunta abiertos, el pegado y su Enter caerian
+    en el menu del TUI. El candado de §10.8 (`hasOpenToolCall`) no sirve: se
+    apaga con `statusSource`.
+  */
+  waitingBlocksSubmit: true
+};
+var OPENCODE_INPUT = {
+  imageReference: "bare-path-paste",
+  pieceGapMs: 400,
+  pasteMarkers: true,
+  enterSeparately: true,
+  interruptPresses: 2,
+  // `@` abre un buscador en el TUI (11.11): el transcript va entre comillas.
+  transcriptReference: "quoted-path"
+};
+function copyEnvironment(base) {
+  const env = {};
+  for (const [key, value] of Object.entries(base)) {
+    if (value !== void 0) env[key] = value;
+  }
+  return env;
+}
+function createOpenCodeAdapter(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const sqlite = options.sqlite ?? loadSqlite;
+  const paths = resolveOpenCodePaths(env, options.home ?? homedir8(), platform);
+  const db = new ReadOnlyDatabase(paths.dbFile ?? "", {
+    idleCloseMs: OPENCODE_DB_IDLE_CLOSE_MS,
+    required: OPENCODE_REQUIRED_COLUMNS,
+    label: OPENCODE_LABEL,
+    sqlite
+  });
+  const signal = new DbChangeSignal(
+    paths.dbFile === null || paths.walFile === null ? null : { db: paths.dbFile, wal: paths.walFile }
+  );
+  const catalog = new ModelCatalog(paths.modelsFile);
+  const serveEnv = options.serveEnv ?? (() => copyEnvironment(process.env));
+  let serve = null;
+  const status = new OpenCodeServeStatus({ ...options.serveStatus, parentOf: (id) => readSessionParent(db, id) });
+  let current = null;
+  const serveFor = (location) => {
+    if (serve !== null) return serve;
+    const created = new OpenCodeServeProcess({ ...options.serveProcess, location, baseEnv: serveEnv });
+    created.onExit((endpoint, exit) => {
+      status.detach(endpoint, exit.requested ? null : "server-closed");
+      if (current?.endpoint === endpoint) current = null;
+    });
+    serve = created;
+    return created;
+  };
+  const clientFor = (endpoint) => {
+    if (current?.endpoint === endpoint) return current.client;
+    current = { endpoint, client: new OpenCodeServeClient(endpoint, void 0, options.serveClient) };
+    return current.client;
+  };
+  const questions = new OpenCodeQuestions({
+    lookupCall: (partId, sessionId) => readPartCall(db, partId, sessionId),
+    client: () => current?.client ?? null
+  });
+  return {
+    id: "opencode",
+    label: OPENCODE_LABEL,
+    command: OPENCODE_COMMAND,
+    installUrl: OPENCODE_INSTALL_URL,
+    capabilities: OPENCODE_CAPABILITIES,
+    input: OPENCODE_INPUT,
+    // `--version` es seguro: medido, no toca la base ni escribe log.
+    locate: () => locateCommand(OPENCODE_COMMAND),
+    missingMessage: () => commandNotFoundMessage(OPENCODE_COMMAND, OPENCODE_INSTALL_URL),
+    /**
+     * `attach <url> --dir . --session <id> --password <hex>` (D5), con la
+     * sesion nueva creada por API (D6). No es `async` (M1b): un id de
+     * reanudacion invalido lanza aca mismo, sin tocar el `serve`, porque detras
+     * de `cmd.exe /c` un `&` se ejecuta. Lo que falla despues —el `serve` que no
+     * arranca, la sesion que no se crea— rechaza, y el registro lo muestra como
+     * `spawn-failed` con el motivo (D1). `proposedSessionId` no se usa: el id lo
+     * pone OpenCode.
+     */
+    launch(input) {
+      return launchWithServe(
+        {
+          ensure: () => serveFor(input.location).ensure(),
+          createSession: (endpoint, directory) => clientFor(endpoint).createSession(directory),
+          track: (endpoint, sessionId, directory) => status.track(sessionId, directory, clientFor(endpoint))
+        },
+        input
+      );
+    },
+    /** Copia del entorno, sin quitar nada: OpenCode no hereda ningun marcador que le estorbe. */
+    environment(base) {
+      return { env: copyEnvironment(base), notice: null };
+    },
+    /*
+      Toda pestana lanzada, nueva o reanudada, retiene el `serve` mientras viva
+      su pty, y al cerrarse corta la sesion si quedo trabajando o esperando
+      (D13): con `attach`, el trabajo seguiria en el `serve` sin ningun TUI que
+      lo muestre. El corte va al cliente vigente: el de un `serve` que ya murio
+      no esta, y su estado ya es null.
+    */
+    onSpawned(context) {
+      if (context.sessionId.length === 0) return null;
+      const { sessionId, cwd } = context;
+      return createServeLaunchHook({
+        sessionId,
+        cwd,
+        release: serve?.retain() ?? (() => {
+        }),
+        current: () => status.current(sessionId),
+        abort: (directory, id) => current?.client.abort(directory, id) ?? Promise.resolve()
+      });
+    },
+    history: createOpenCodeHistory({
+      dbFile: paths.dbFile,
+      db,
+      signal,
+      catalog,
+      platform,
+      sqlite
+    }),
+    status,
+    questions,
+    /**
+     * 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:
+     *
+     *  - con la base en memoria (`OPENCODE_DB=:memory:`, que alguien puso a
+     *    proposito), que no hay nada que leer;
+     *  - sin `node:sqlite`, el aviso de la version de Node, si hay una base que
+     *    no se va a ver o la CLI esta instalada;
+     *  - con la base en disco, su ruta.
+     *
+     * Con la base ausente no dice nada: `status()` es perezoso y no sabe si
+     * existe hasta la primera consulta, asi que se mira el archivo.
+     */
+    startupHistoryNote(cliAvailable) {
+      if (env["OPENCODE_DB"] === ":memory:") return "in memory (nothing to read)";
+      if (paths.dbFile === null) return null;
+      const present = existsSync2(paths.dbFile);
+      if ("unavailable" in sqlite()) return present || cliAvailable ? `not read: ${sqliteUnavailableText(OPENCODE_LABEL)}` : null;
+      return present ? `${paths.dbFile} (read-only)` : null;
+    },
+    // `opencode.json` no se abre (regla 2.1).
+    defaults: () => Promise.resolve(null),
+    /**
+     * Las cuatro carpetas de OpenCode: datos (la base, `auth.json`),
+     * configuracion, cache y estado. No se listan ni se entran (regla 2.1). La
+     * carpeta de un `OPENCODE_DB` propio no: puede ser la de un proyecto.
+     */
+    protectedDirs: () => [paths.dataDir, paths.configDir, paths.cacheDir, paths.stateDir],
+    /**
+     * Suelta el estado (sus oyentes reciben null y el flujo se cierra) antes de
+     * matar el `serve`: los ganchos de las pestanas, que se cancelan despues en
+     * el apagado, ya no piden ningun corte (M7). La promesa espera a que el
+     * proceso salga; la orden de matarlo sale antes de devolver.
+     */
+    dispose: () => {
+      status.dispose();
+      current = null;
+      signal.dispose();
+      db.close();
+      return serve?.dispose() ?? Promise.resolve();
+    }
+  };
+}
+
+// packages/server/src/agents/pi/index.ts
+import { stat as stat21 } from "node:fs/promises";
+import { homedir as homedir10 } from "node:os";
+import path37 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";
+var PI_CATALOG_RECHECK_MS = 3e4;
+var PI_MODEL_LIST_MAX = 300;
+var STORE_MAX_BYTES = 8 * 1024 * 1024;
+var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
+function storeModels(parsed) {
+  const providers = asRecord(parsed);
+  if (providers === null) return [];
+  const models = [];
+  for (const [provider, value] of Object.entries(providers)) {
+    const list = asRecord(value)?.["models"];
+    if (!Array.isArray(list)) continue;
+    for (const item of list) {
+      const model2 = asRecord(item);
+      const id = model2?.["id"];
+      if (model2 === null || typeof id !== "string" || id.length === 0) continue;
+      const name = model2["name"];
+      const window = model2["contextWindow"];
+      models.push({
+        provider,
+        id,
+        name: typeof name === "string" && name.trim().length > 0 ? name.trim() : id,
+        contextWindow: typeof window === "number" && Number.isFinite(window) && window > 0 ? window : null
+      });
+    }
+  }
+  return models;
+}
+function packageWindows(parsed) {
+  const windows = /* @__PURE__ */ new Map();
+  const apis = asRecord(parsed);
+  if (apis === null) return windows;
+  for (const group of Object.values(apis)) {
+    const entries = asRecord(group);
+    if (entries === null) continue;
+    for (const item of Object.values(entries)) {
+      const model2 = asRecord(item);
+      const id = model2?.["id"];
+      const window = model2?.["contextWindow"];
+      if (typeof id === "string" && id.length > 0 && typeof window === "number" && Number.isFinite(window) && window > 0) {
+        windows.set(id, window);
+      }
+    }
+  }
+  return windows;
+}
+function modelOptions(models) {
+  const several = new Set(models.map((model2) => model2.provider)).size > 1;
+  const seen = /* @__PURE__ */ new Set();
+  const options = [];
+  for (const model2 of models) {
+    const value = `${model2.provider}/${model2.id}`;
+    if (seen.has(value) || /\s/.test(value)) continue;
+    seen.add(value);
+    options.push({
+      value,
+      label: several ? `${model2.name} (${model2.provider})` : model2.name,
+      family: value,
+      long: false,
+      window: model2.contextWindow
+    });
+    if (options.length >= PI_MODEL_LIST_MAX) break;
+  }
+  return options;
+}
+var PiModelCatalog = class {
+  constructor(options) {
+    this.options = options;
+    this.readFile = options.readFile ?? ((file) => readFileFromDisk2(file, "utf8"));
+    this.stat = options.stat ?? statFromDisk2;
+    this.now = options.now ?? Date.now;
+    this.recheckMs = options.recheckMs ?? PI_CATALOG_RECHECK_MS;
+  }
+  options;
+  readFile;
+  stat;
+  now;
+  recheckMs;
+  models = [];
+  windows = /* @__PURE__ */ new Map();
+  /** La firma del archivo que dio `models`; null si nunca se leyo bien. */
+  loadedStamp = null;
+  checkedAt = null;
+  refreshing = null;
+  /** Proveedor -> ventanas del paquete. Un proveedor sin archivo queda con un mapa vacio. */
+  packageCache = /* @__PURE__ */ new Map();
+  /** La lista de la cuenta tal como quedo en la ultima lectura. Sincronica: la usan las capacidades. */
+  list() {
+    return this.models;
+  }
+  /**
+   * Vuelve a leer `models-store.json` si cambio. true si la lista de modelos
+   * quedo distinta. Nunca lanza.
+   */
+  async reload() {
+    const before = JSON.stringify(this.models);
+    this.checkedAt = this.now();
+    await this.load();
+    return JSON.stringify(this.models) !== before;
+  }
+  /** La ventana de ese modelo en ese proveedor, o null. Nunca lanza. */
+  async contextWindow(provider, modelId) {
+    if (provider === null || modelId === null || provider.length === 0 || modelId.length === 0) return null;
+    await this.refresh();
+    const known = this.windows.get(`${provider}/${modelId}`);
+    if (known !== void 0) return known;
+    return (await this.packageWindowsOf(provider)).get(modelId) ?? null;
+  }
+  refresh() {
+    const now = this.now();
+    if (this.checkedAt !== null && now - this.checkedAt < this.recheckMs) return this.refreshing ?? Promise.resolve();
+    if (this.refreshing === null) {
+      this.checkedAt = now;
+      this.refreshing = this.load().finally(() => {
+        this.refreshing = null;
+      });
+    }
+    return this.refreshing;
+  }
+  async load() {
+    const file = this.options.storeFile();
+    const forget = () => {
+      this.models = [];
+      this.windows = /* @__PURE__ */ new Map();
+      this.loadedStamp = null;
+    };
+    if (file === null) return forget();
+    let stamp2;
+    try {
+      const info = await this.stat(file);
+      if (info.size > STORE_MAX_BYTES) return forget();
+      stamp2 = `${info.mtimeMs}:${info.size}`;
+    } catch {
+      return forget();
+    }
+    if (stamp2 === this.loadedStamp) return;
+    try {
+      const models = storeModels(JSON.parse(await this.readFile(file)));
+      this.models = models;
+      this.windows = new Map(
+        models.flatMap(
+          (model2) => model2.contextWindow === null ? [] : [[`${model2.provider}/${model2.id}`, model2.contextWindow]]
+        )
+      );
+      this.loadedStamp = stamp2;
+    } catch {
+      forget();
+    }
+  }
+  async packageWindowsOf(provider) {
+    const cached = this.packageCache.get(provider);
+    if (cached !== void 0) return cached;
+    const packageDir = this.options.packageDir();
+    if (packageDir === null || !PROVIDER_ID_PATTERN.test(provider)) return /* @__PURE__ */ new Map();
+    let windows = /* @__PURE__ */ new Map();
+    for (const dataDir of packageDataDirs(packageDir)) {
+      try {
+        windows = packageWindows(JSON.parse(await this.readFile(path30.join(dataDir, `${provider}.json`))));
+        break;
+      } catch {
+      }
+    }
+    this.packageCache.set(provider, windows);
+    return windows;
+  }
+};
+function packageDataDirs(packageDir) {
+  const tail = ["pi-ai", "dist", "providers", "data"];
+  return [
+    path30.join(packageDir, "node_modules", "@earendil-works", ...tail),
+    path30.join(packageDir, "..", ...tail)
+  ];
+}
+
+// packages/server/src/agents/pi/constants.ts
+var PI_COMMAND = "pi";
+var PI_LABEL = "Pi";
+var PI_INSTALL_URL = "https://pi.dev";
+var PI_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+var PI_EFFORT_OPTIONS = [
+  { value: "off", label: "Apagado" },
+  { value: "minimal", label: "Minimo" },
+  { value: "low", label: "Bajo" },
+  { value: "medium", label: "Medio" },
+  { value: "high", label: "Alto" },
+  { value: "xhigh", label: "Muy alto" },
+  { value: "max", label: "Maximo" }
+];
+var SESSION_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
+var SESSION_ID_MAX_LENGTH = 128;
+function isPiSessionId(value) {
+  return value.length <= SESSION_ID_MAX_LENGTH && SESSION_ID_PATTERN.test(value);
+}
+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";
+
+// packages/server/src/agents/pi/paths.ts
+import { readdir as readdir9, stat as stat16 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import path31 from "node:path";
+var warned = /* @__PURE__ */ new Set();
+function isFullyQualified3(candidate) {
+  if (!path31.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);
+  const key = `${name}=${value}`;
+  if (!warned.has(key)) {
+    warned.add(key);
+    console.warn(`[pi] ${name} isn't an absolute path (${value}): the Pi history isn't read.`);
+  }
+  return null;
+}
+function piAgentDir() {
+  const configured = process.env["PI_CODING_AGENT_DIR"];
+  if (configured === void 0 || configured.length === 0) return path31.join(homedir9(), ".pi", "agent");
+  return resolveConfigured("PI_CODING_AGENT_DIR", configured);
+}
+function piSessionsLayout() {
+  const configured = process.env["PI_CODING_AGENT_SESSION_DIR"];
+  if (configured !== void 0 && configured.length > 0) {
+    const root = resolveConfigured("PI_CODING_AGENT_SESSION_DIR", configured);
+    return root === null ? null : { root, flat: true };
+  }
+  const agentDir = piAgentDir();
+  return agentDir === null ? null : { root: path31.join(agentDir, "sessions"), flat: false };
+}
+function piModelsStorePath() {
+  const agentDir = piAgentDir();
+  return agentDir === null ? null : path31.join(agentDir, "models-store.json");
+}
+function projectFolderName(cwd) {
+  const resolved = path31.resolve(cwd);
+  return `--${resolved.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+function isProjectFolderName(name) {
+  return name.length > 4 && name.startsWith("--") && name.endsWith("--");
+}
+var SESSION_FILE_STAMP = /^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/;
+var STAMP_LENGTH = 24;
+function parseSessionFileName(name) {
+  if (!name.endsWith(".jsonl") || name.charAt(STAMP_LENGTH) !== "_") return null;
+  const stamp2 = SESSION_FILE_STAMP.exec(name.slice(0, STAMP_LENGTH));
+  if (stamp2 === null) return null;
+  const sessionId = name.slice(STAMP_LENGTH + 1, -".jsonl".length);
+  if (!isPiSessionId(sessionId)) return null;
+  const [, year, month, day, hour, minute, second, millis] = stamp2;
+  const startedAt = Date.UTC(
+    Number(year),
+    Number(month) - 1,
+    Number(day),
+    Number(hour),
+    Number(minute),
+    Number(second),
+    Number(millis)
+  );
+  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);
+}
+function sessionDirFor(cwd, layout = piSessionsLayout()) {
+  if (layout === null) return null;
+  return layout.flat ? layout.root : path31.join(layout.root, projectFolderName(cwd));
+}
+async function sessionFilesIn(dir) {
+  try {
+    const entries = await readdir9(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile() && parseSessionFileName(entry.name) !== null).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+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();
+  } catch {
+    return [];
+  }
+}
+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));
+  }
+  return files;
+}
+async function findSessionFile(sessionId, cwd) {
+  if (!isPiSessionId(sessionId)) return null;
+  const layout = piSessionsLayout();
+  if (layout === null) return null;
+  const own = cwd === null || cwd.length === 0 ? null : sessionDirFor(cwd, layout);
+  const dirs = own === null ? [] : [own];
+  if (!layout.flat) {
+    for (const dir of await projectFolders(layout)) {
+      if (!dirs.includes(dir)) dirs.push(dir);
+    }
+  }
+  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] ?? "");
+    let best = null;
+    for (const name of matches) {
+      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 };
+      } catch {
+      }
+    }
+    if (best !== null) return best.file;
+  }
+  return null;
+}
+
+// packages/server/src/agents/pi/session-follower.ts
+import path33 from "node:path";
+
+// packages/server/src/agents/pi/session-entries.ts
+var NOTICE_DETAIL_MAX_CHARS2 = 300;
+function stampOf(value) {
+  if (typeof value !== "string") return 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function numberOf(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function readHeader(record) {
+  if (record["type"] !== "session") return null;
+  const sessionId = record["id"];
+  const cwd = record["cwd"];
+  if (typeof sessionId !== "string" || sessionId.length === 0) return null;
+  if (typeof cwd !== "string" || cwd.length === 0) return null;
+  const version = record["version"];
+  const parentSession = record["parentSession"];
+  return {
+    sessionId,
+    cwd,
+    version: typeof version === "number" && Number.isFinite(version) ? version : null,
+    parentSession: typeof parentSession === "string" && parentSession.length > 0 ? parentSession : null,
+    startedAt: stampOf(record["timestamp"])
+  };
+}
+var ATTACHED_IMAGE_LINE = /^Attached image: "([^"\r\n]+)"$/;
+function pastedImagePaths(text) {
+  const paths = [];
+  for (const line of text.split("\n")) {
+    const match = ATTACHED_IMAGE_LINE.exec(line.trim());
+    const target = match?.[1];
+    if (target !== void 0 && pastedImageMediaType(target) !== null) paths.push(target);
+  }
+  return paths;
+}
+function withoutPastedImageLines(text) {
+  return text.split("\n").filter((line) => {
+    const target = ATTACHED_IMAGE_LINE.exec(line.trim())?.[1];
+    return target === void 0 || pastedImageMediaType(target) === null;
+  }).join("\n");
+}
+function blocksOf(content) {
+  if (typeof content === "string") return content.length > 0 ? [{ type: "text", text: content }] : [];
+  if (!Array.isArray(content)) return [];
+  const blocks = [];
+  for (const item of content) {
+    const block = asRecord(item);
+    if (block !== null) blocks.push(block);
+  }
+  return blocks;
+}
+function textOf(blocks) {
+  return blocks.filter((block) => block["type"] === "text" && typeof block["text"] === "string").map((block) => block["text"]).join("\n");
+}
+function contentImageTypes(content) {
+  return blocksOf(content).filter((block) => block["type"] === "image").map((block) => typeof block["mimeType"] === "string" && block["mimeType"].length > 0 ? block["mimeType"] : "image/png");
+}
+function readUser(message, limits) {
+  const blocks = blocksOf(message["content"]);
+  const raw = textOf(blocks);
+  const parts = contentImageTypes(message["content"]).map((mediaType, index) => ({
+    kind: "image",
+    index,
+    mediaType,
+    source: "content"
+  }));
+  for (const [index, target] of pastedImagePaths(raw).entries()) {
+    parts.push({ kind: "image", index, mediaType: pastedImageMediaType(target) ?? "image/png", source: "pasted" });
+  }
+  const text = withoutPastedImageLines(raw).trim();
+  if (text.length > 0) parts.push({ kind: "text", ...cut(text, limits.textMaxChars) });
+  return { kind: "user", parts, plain: plainText(raw) };
+}
+var PLAIN_MAX_CHARS = 8e3;
+var PLAIN_NEEDLE_CHARS = 2e3;
+function plainText(raw) {
+  return raw.replace(/\s+/g, " ").trim().slice(0, PLAIN_MAX_CHARS);
+}
+function plainMatches(plain, submitted) {
+  const needle = plainText(submitted).slice(0, PLAIN_NEEDLE_CHARS);
+  return needle.length > 0 && plain.includes(needle);
+}
+function readUsage2(value) {
+  const usage = asRecord(value);
+  if (usage === null) return null;
+  const input = numberOf(usage["input"]);
+  const output = numberOf(usage["output"]);
+  const cacheRead = numberOf(usage["cacheRead"]);
+  const cacheWrite = numberOf(usage["cacheWrite"]);
+  const total = numberOf(usage["totalTokens"]);
+  return { input, output, cacheRead, cacheWrite, totalTokens: total > 0 ? total : input + output + cacheRead + cacheWrite };
+}
+function prettyArguments(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value ?? {}, null, 2);
+  } catch {
+    return "";
+  }
+}
+function readAssistant(message, limits) {
+  const parts = [];
+  let thought = false;
+  for (const block of blocksOf(message["content"])) {
+    const type = block["type"];
+    if (type === "text") {
+      const text2 = block["text"];
+      if (typeof text2 === "string" && text2.length > 0) parts.push({ kind: "text", ...cut(text2, limits.textMaxChars) });
+    } else if (type === "thinking") {
+      if (!thought) parts.push({ kind: "thinking" });
+      thought = true;
+    } else if (type === "toolCall") {
+      const id = block["id"];
+      const name = block["name"];
+      if (typeof id !== "string" || id.length === 0 || typeof name !== "string" || name.length === 0) continue;
+      const input = cut(prettyArguments(block["arguments"]), limits.toolInputMaxChars);
+      parts.push({ kind: "tool-call", toolUseId: id, name, input: input.text, truncated: input.truncated });
+    }
+  }
+  const text = (key) => {
+    const value = message[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+  };
+  return {
+    kind: "assistant",
+    parts,
+    provider: text("provider"),
+    model: text("model"),
+    usage: readUsage2(message["usage"]),
+    stopReason: text("stopReason"),
+    thinkingLevel: text("thinkingLevel"),
+    errorMessage: text("errorMessage")
+  };
+}
+function readToolResult(message, limits) {
+  const toolCallId = message["toolCallId"];
+  if (typeof toolCallId !== "string" || toolCallId.length === 0) return { kind: "other" };
+  const blocks = blocksOf(message["content"]);
+  const output = cut(textOf(blocks), limits.toolResultMaxChars);
+  return {
+    kind: "toolResult",
+    toolCallId,
+    part: {
+      kind: "tool-result",
+      toolUseId: toolCallId,
+      text: output.text,
+      isError: message["isError"] === true,
+      truncated: output.truncated,
+      imageCount: blocks.filter((block) => block["type"] === "image").length
+    }
+  };
+}
+function readBash(message, limits) {
+  const command = message["command"];
+  if (typeof command !== "string" || command.length === 0) return { kind: "other" };
+  const output = cut(typeof message["output"] === "string" ? message["output"] : "", limits.toolResultMaxChars);
+  const exitCode = message["exitCode"];
+  return {
+    kind: "bash",
+    command: cut(command, limits.toolInputMaxChars).text,
+    output: output.text,
+    failed: message["cancelled"] === true || typeof exitCode === "number" && exitCode !== 0,
+    truncated: output.truncated || message["truncated"] === true
+  };
+}
+function readFact(record, limits) {
+  switch (record["type"]) {
+    case "model_change": {
+      const provider = record["provider"];
+      const modelId = record["modelId"];
+      return typeof provider === "string" && provider.length > 0 && typeof modelId === "string" && modelId.length > 0 ? { kind: "model", provider, modelId } : { kind: "other" };
+    }
+    case "thinking_level_change": {
+      const level = record["thinkingLevel"];
+      return typeof level === "string" && level.length > 0 ? { kind: "thinking", level } : { kind: "other" };
+    }
+    case "session_info": {
+      const name = record["name"];
+      return typeof name === "string" && name.trim().length > 0 ? { kind: "info", name: name.trim() } : { kind: "other" };
+    }
+    case "compaction":
+    case "branch_summary":
+      return { kind: "compaction" };
+    case "message": {
+      const message = asRecord(record["message"]);
+      if (message === null) return { kind: "other" };
+      switch (message["role"]) {
+        case "user":
+          return readUser(message, limits);
+        case "assistant":
+          return readAssistant(message, limits);
+        case "toolResult":
+          return readToolResult(message, limits);
+        case "bashExecution":
+          return readBash(message, limits);
+        default:
+          return { kind: "other" };
+      }
+    }
+    default:
+      return { kind: "other" };
+  }
+}
+function readEntry(record, lineNumber, limits) {
+  const type = record["type"];
+  if (typeof type !== "string" || type === "session") return null;
+  const id = record["id"];
+  const parentId = record["parentId"];
+  return {
+    id: typeof id === "string" && id.length > 0 ? id : `line-${lineNumber}`,
+    parentId: typeof parentId === "string" && parentId.length > 0 ? parentId : parentId === null ? null : void 0,
+    at: stampOf(record["timestamp"]),
+    fact: readFact(record, 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";
+function tooBig2(data) {
+  return data.length > MAX_SUBMIT_IMAGE_BYTES * 1.4;
+}
+function imageOf(block) {
+  if (block === null || block["type"] !== "image") return null;
+  const data = block["data"];
+  const mediaType = block["mimeType"];
+  if (typeof data !== "string" || data.length === 0 || tooBig2(data)) return null;
+  return { mediaType: typeof mediaType === "string" && mediaType.length > 0 ? mediaType : "image/png", data };
+}
+function blocksOf2(message) {
+  const content = message?.["content"];
+  if (!Array.isArray(content)) return [];
+  return content.map((item) => asRecord(item)).filter((item) => item !== null);
+}
+function textOf2(message) {
+  const content = message?.["content"];
+  if (typeof content === "string") return content;
+  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);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+  };
+  return normalize(a) === normalize(b);
+}
+async function readPastedFile2(target, pastedDir) {
+  try {
+    const inside = await resolveInside(pastedDir, path32.relative(pastedDir, target), { mustExist: true });
+    const info = await stat17(inside);
+    if (!info.isFile() || info.size === 0 || info.size > MAX_SUBMIT_IMAGE_BYTES) return null;
+    const bytes = await readFile10(inside);
+    const format = detectImageFormat(bytes);
+    return format === null ? null : { mediaType: format.mediaType, data: bytes.toString("base64") };
+  } catch {
+    return null;
+  }
+}
+function readCallOf(record, target) {
+  const message = asRecord(record["message"]);
+  if (record["type"] !== "message" || message?.["role"] !== "assistant") return null;
+  for (const block of blocksOf2(message)) {
+    if (block["type"] !== "toolCall") continue;
+    const id = block["id"];
+    const filePath = asRecord(block["arguments"])?.["path"];
+    if (typeof id === "string" && id.length > 0 && typeof filePath === "string" && sameFile(filePath, target)) return id;
+  }
+  return null;
+}
+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;
+  } catch {
+    return null;
+  }
+  const stream = createReadStream2(file, { encoding: "utf8" });
+  const lines = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+  stream.on("error", () => lines.close());
+  let target = null;
+  let readId = null;
+  try {
+    for await (const line of lines) {
+      if (target === null) {
+        if (!line.includes(eventId)) continue;
+        const record2 = parseJsonlLine(line);
+        if (record2 === null || record2["id"] !== eventId || record2["type"] !== "message") continue;
+        const message2 = asRecord(record2["message"]);
+        if (message2?.["role"] !== "user") return null;
+        if (source === "content") {
+          const images = blocksOf2(message2).filter((block) => block["type"] === "image");
+          return imageOf(images[index] ?? null);
+        }
+        target = pastedImagePaths(textOf2(message2))[index] ?? null;
+        if (target === null) return null;
+        const fromDisk = await readPastedFile2(target, pastedDir);
+        if (fromDisk !== null) return fromDisk;
+        continue;
+      }
+      if (readId === null) {
+        if (!line.includes('"toolCall"')) continue;
+        const record2 = parseJsonlLine(line);
+        readId = record2 === null ? null : readCallOf(record2, target);
+        continue;
+      }
+      if (!line.includes('"toolResult"')) continue;
+      const record = parseJsonlLine(line);
+      const message = record === null ? null : asRecord(record["message"]);
+      if (message === null || message["role"] !== "toolResult" || message["toolCallId"] !== readId) continue;
+      for (const block of blocksOf2(message)) {
+        const image = imageOf(block);
+        if (image !== null) return image;
+      }
+      readId = null;
+    }
+  } catch {
+    return null;
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+  return null;
+}
+
+// packages/server/src/agents/pi/session-path.ts
+function emptyState() {
+  return {
+    events: [],
+    dropped: 0,
+    meter: {
+      provider: null,
+      modelId: null,
+      effort: null,
+      lastRequestTokens: 0,
+      lastOutputTokens: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCacheReadTokens: 0,
+      assistantMessages: 0
+    },
+    inFlight: false,
+    turnStartedAt: null
+  };
+}
+function modelKey(provider, modelId) {
+  if (modelId === null || modelId.length === 0) return null;
+  return provider === null || provider.length === 0 ? modelId : `${provider}/${modelId}`;
+}
+function messageUsage(usage) {
+  return {
+    inputTokens: usage.input,
+    outputTokens: usage.output,
+    cacheCreationInputTokens: usage.cacheWrite,
+    cacheReadInputTokens: usage.cacheRead
+  };
+}
+function event(eventId, role, at, parts, extra = {}) {
+  return {
+    eventId,
+    role,
+    at,
+    parts,
+    model: extra.model ?? null,
+    usage: extra.usage ?? null,
+    effort: extra.effort ?? null,
+    durationMs: extra.durationMs ?? null,
+    queued: extra.queued ?? false
+  };
+}
+function step(state, entry) {
+  const { fact } = entry;
+  const added = [];
+  switch (fact.kind) {
+    // El nombre (`info`) no depende de la rama: lo lee `session-scan.ts` de la cola del archivo.
+    case "other":
+    case "info":
+      break;
+    case "model":
+      state.meter = { ...state.meter, provider: fact.provider, modelId: fact.modelId };
+      break;
+    case "thinking":
+      state.meter = { ...state.meter, effort: fact.level };
+      break;
+    case "compaction":
+      added.push(event(`${entry.id}:notice`, "assistant", entry.at, [{ kind: "notice", notice: "compacted", detail: "" }]));
+      break;
+    case "user": {
+      const queued = state.inFlight;
+      if (!state.inFlight) state.turnStartedAt = entry.at;
+      state.inFlight = true;
+      if (fact.parts.length > 0) added.push(event(entry.id, "user", entry.at, fact.parts, { queued }));
+      break;
+    }
+    case "assistant": {
+      const provider = fact.provider ?? state.meter.provider;
+      const modelId = fact.model ?? state.meter.modelId;
+      const effort = fact.thinkingLevel ?? state.meter.effort;
+      state.meter = { ...state.meter, provider, modelId, effort };
+      const usage = fact.usage;
+      const counted = usage !== null && usage.totalTokens > 0;
+      if (usage !== null && counted) {
+        state.meter = {
+          ...state.meter,
+          lastRequestTokens: usage.totalTokens,
+          lastOutputTokens: usage.output,
+          totalInputTokens: state.meter.totalInputTokens + usage.input + usage.cacheWrite,
+          totalOutputTokens: state.meter.totalOutputTokens + usage.output,
+          totalCacheReadTokens: state.meter.totalCacheReadTokens + usage.cacheRead,
+          assistantMessages: state.meter.assistantMessages + 1
+        };
+      }
+      const final = fact.stopReason !== "toolUse";
+      let durationMs = null;
+      if (final) {
+        if (state.turnStartedAt !== null && state.turnStartedAt > 0 && entry.at >= state.turnStartedAt) {
+          durationMs = entry.at - state.turnStartedAt;
+        }
+        state.inFlight = false;
+        state.turnStartedAt = null;
+      } else {
+        state.inFlight = true;
+      }
+      const notice = fact.stopReason === "aborted" ? { kind: "notice", notice: "interrupted", detail: "" } : fact.stopReason === "error" ? { kind: "notice", notice: "error", detail: (fact.errorMessage ?? "").slice(0, NOTICE_DETAIL_MAX_CHARS2) } : null;
+      if (fact.parts.length > 0) {
+        added.push(
+          event(entry.id, "assistant", entry.at, fact.parts, {
+            model: modelKey(provider, modelId),
+            usage: usage !== null && counted ? messageUsage(usage) : null,
+            effort,
+            // Con un aviso detras, la duracion va en el aviso: es el ultimo del turno.
+            durationMs: notice === null ? durationMs : null
+          })
+        );
+      }
+      if (notice !== null) added.push(event(`${entry.id}:notice`, "assistant", entry.at, [notice], { durationMs }));
+      break;
+    }
+    case "toolResult":
+      state.inFlight = true;
+      added.push(event(entry.id, "user", entry.at, [fact.part]));
+      break;
+    case "bash": {
+      const toolUseId = `bash:${entry.id}`;
+      added.push(
+        event(entry.id, "user", entry.at, [
+          { kind: "tool-call", toolUseId, name: "bash", input: fact.command, truncated: false },
+          {
+            kind: "tool-result",
+            toolUseId,
+            text: fact.output,
+            isError: fact.failed,
+            truncated: fact.truncated,
+            imageCount: 0
+          }
+        ])
+      );
+      break;
+    }
+  }
+  return added;
+}
+var PiSessionTree = class {
+  /** Todas las entradas del archivo, con su padre ya resuelto. */
+  nodes = /* @__PURE__ */ new Map();
+  /** La ultima entrada del archivo: la punta de la rama activa. */
+  leafId = null;
+  state = emptyState();
+  maxEvents;
+  constructor(options = {}) {
+    this.maxEvents = options.maxEvents ?? Number.POSITIVE_INFINITY;
+  }
+  reset() {
+    this.nodes.clear();
+    this.leafId = null;
+    this.state = emptyState();
+  }
+  /** Agrega una entrada, en el orden del archivo. */
+  add(entry) {
+    const parent = entry.parentId === void 0 ? this.leafId : entry.parentId;
+    const linear = parent === this.leafId;
+    this.nodes.set(entry.id, { entry, parent });
+    this.leafId = entry.id;
+    if (linear) {
+      const added = step(this.state, entry);
+      this.keep(added);
+      return { rebuilt: false, added };
+    }
+    this.rebuild();
+    return { rebuilt: true, added: [] };
+  }
+  /** Rehace el estado recorriendo el camino de la raiz a la punta. */
+  rebuild() {
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    let cursor = this.leafId;
+    while (cursor !== null && !seen.has(cursor)) {
+      seen.add(cursor);
+      const node = this.nodes.get(cursor);
+      if (node === void 0) break;
+      chain.push(node.entry);
+      cursor = node.parent;
+    }
+    this.state = emptyState();
+    for (let index = chain.length - 1; index >= 0; index -= 1) {
+      const entry = chain[index];
+      if (entry !== void 0) this.keep(step(this.state, entry));
+    }
+  }
+  keep(added) {
+    for (const each of added) this.state.events.push(each);
+    while (this.state.events.length > this.maxEvents) {
+      this.state.events.shift();
+      this.state.dropped += 1;
+    }
+  }
+  /** Los eventos de la rama activa, en orden. No copiar ni modificar. */
+  get events() {
+    return this.state.events;
+  }
+  /** Eventos viejos descartados por el tope. */
+  get dropped() {
+    return this.state.dropped;
+  }
+  get meter() {
+    return this.state.meter;
+  }
+};
+
+// packages/server/src/agents/pi/session-follower.ts
+var LOOKUP_INTERVAL_MS2 = 2e3;
+var PI_MAX_EVENTS = 4e3;
+var PI_FINGERPRINT_BYTES = 64;
+var PiSessionFollower = class {
+  constructor(cwd, sessionId, options) {
+    this.cwd = cwd;
+    this.sessionId = sessionId;
+    const limits = options.limits ?? TRANSPORT_LIMITS;
+    this.catalog = options.catalog;
+    this.now = options.now ?? Date.now;
+    this.findFile = options.findFile ?? findSessionFile;
+    this.tree = new PiSessionTree({ maxEvents: options.maxEvents ?? PI_MAX_EVENTS });
+    const sink = {
+      // Nunca devuelve un evento: los guarda el arbol, que sabe de que rama son.
+      consume: (record, lineNumber) => {
+        const entry = readEntry(record, lineNumber, limits);
+        if (entry !== null) this.incoming.push(entry);
+        return null;
+      },
+      reset: () => {
+        this.tree.reset();
+        this.incoming = [];
+      }
+    };
+    this.jsonl = new JsonlFollower(null, sink, { fingerprintBytes: PI_FINGERPRINT_BYTES });
+  }
+  cwd;
+  sessionId;
+  tree;
+  jsonl;
+  catalog;
+  now;
+  findFile;
+  /** Las entradas leidas en esta vuelta, en orden de archivo, todavia sin aplicar. */
+  incoming = [];
+  usage = { ...EMPTY_CONTEXT_USAGE };
+  /** El modelo para el que vale `window`. */
+  windowKey = null;
+  window = null;
+  lastLookupAt = null;
+  get label() {
+    const filePath = this.jsonl.filePath;
+    if (filePath !== null) return filePath;
+    return this.sessionId.length > 0 ? `pi:${this.sessionId.slice(0, 8)}` : "pi:(no session)";
+  }
+  async start() {
+    await this.lookup();
+  }
+  async poll() {
+    if (this.jsonl.filePath === null && (this.lastLookupAt === null || this.now() - this.lastLookupAt >= LOOKUP_INTERVAL_MS2)) {
+      await this.lookup();
+    }
+    const before = JSON.stringify(this.usage);
+    const { reset } = await this.jsonl.poll();
+    let rebuilt = reset;
+    const added = [];
+    for (const entry of this.incoming.splice(0)) {
+      const result = this.tree.add(entry);
+      if (result.rebuilt) rebuilt = true;
+      else if (!rebuilt) added.push(...result.added);
+    }
+    await this.refreshUsage();
+    if (rebuilt) return { reset: true, added: [], turns: [], plans: [], parts: [] };
+    return {
+      reset: false,
+      added,
+      turns: [],
+      plans: [],
+      parts: [],
+      // `/model` y `/thinking` escriben su entrada en el acto (16.10): cambian el uso sin eventos.
+      usageChanged: added.length === 0 && JSON.stringify(this.usage) !== before
+    };
+  }
+  async lookup() {
+    if (!isPiSessionId(this.sessionId) || this.jsonl.filePath !== null) return;
+    this.lastLookupAt = this.now();
+    const found = await this.findFile(this.sessionId, this.cwd);
+    if (found !== null && this.jsonl.filePath === null) this.jsonl.setPath(found);
+  }
+  /** El medidor de la rama activa, con la ventana que el catalogo le da a su modelo. */
+  async refreshUsage() {
+    const meter = this.tree.meter;
+    const key = modelKey(meter.provider, meter.modelId);
+    if (key !== this.windowKey) {
+      this.window = await this.catalog.contextWindow(meter.provider, meter.modelId);
+      this.windowKey = key;
+    } else if (this.window === null && key !== null) {
+      this.window = await this.catalog.contextWindow(meter.provider, meter.modelId);
+    }
+    this.usage = {
+      lastRequestTokens: meter.lastRequestTokens,
+      lastOutputTokens: meter.lastOutputTokens,
+      lastModel: key,
+      contextWindow: this.window,
+      contextWindowEstimated: false,
+      totalInputTokens: meter.totalInputTokens,
+      totalOutputTokens: meter.totalOutputTokens,
+      totalCacheReadTokens: meter.totalCacheReadTokens,
+      assistantMessages: meter.assistantMessages,
+      ...meter.effort !== null ? { lastEffort: meter.effort } : {}
+    };
+  }
+  /**
+   * true si el aviso es de su archivo. Si todavia no tiene uno y el aviso es un
+   * archivo con su id, se queda con ese: es el watcher llegando antes que el
+   * reintento de busqueda.
+   */
+  noticeChange(filePath) {
+    const own = this.jsonl.filePath;
+    if (own !== null) {
+      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;
+    this.jsonl.setPath(filePath);
+    return true;
+  }
+  async readImage(eventId, index, source) {
+    const filePath = this.jsonl.filePath;
+    if (filePath === null) return null;
+    return loadPiImage(filePath, eventId, index, source);
+  }
+  /**
+   * Siempre false: Pi no pide permiso antes de usar sus herramientas, asi que
+   * una llamada sin resultado nunca es un menu de aprobacion abierto. Lo unico
+   * que frena el cuadro es su dialogo de confianza, y eso lo dice el estado
+   * (`status.ts`).
+   */
+  hasOpenToolCall() {
+    return false;
+  }
+  getState() {
+    return this.jsonl.getState();
+  }
+  getUsage() {
+    return this.usage;
+  }
+  /** Pi no tiene modos de permiso. */
+  getPermissionMode() {
+    return null;
+  }
+  getTail(limit) {
+    const all = this.tree.events;
+    const events = all.slice(-limit);
+    return { events, hasMore: all.length > events.length || this.tree.dropped > 0 };
+  }
+  getPageBefore(beforeEventId, limit) {
+    const all = this.tree.events;
+    const index = all.findIndex((event2) => event2.eventId === beforeEventId);
+    if (index <= 0) return { events: [], hasMore: false };
+    const start = Math.max(0, index - limit);
+    return { events: all.slice(start, index), hasMore: start > 0 || this.tree.dropped > 0 };
+  }
+  getPlanFiles() {
+    return [];
+  }
+};
+
+// packages/server/src/agents/pi/session-scan.ts
+var PI_HEAD_MAX_LINES = 40;
+var PI_HEAD_MAX_BYTES = 512 * 1024;
+var TAIL_MAX_BYTES3 = 128 * 1024;
+async function readSessionHeader(file) {
+  const [first] = await readHeadLines(file, { maxLines: 1, maxBytes: 64 * 1024 });
+  const record = first === void 0 ? null : parseJsonlLine(first);
+  return record === null ? null : readHeader(record);
+}
+function firstUserText2(lines) {
+  for (const [index, line] of lines.entries()) {
+    const record = parseJsonlLine(line);
+    const entry = record === null ? null : readEntry(record, index + 1, TRANSPORT_LIMITS);
+    if (entry === null || entry.fact.kind !== "user") continue;
+    for (const part of entry.fact.parts) {
+      if (part.kind === "text" && part.text.trim().length > 0) return part.text;
+    }
+  }
+  return "";
+}
+function lastSessionName(lines) {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index];
+    if (line === void 0 || !line.includes('"session_info"')) continue;
+    const record = parseJsonlLine(line);
+    const entry = record === null ? null : readEntry(record, index + 1, TRANSPORT_LIMITS);
+    if (entry !== null && entry.fact.kind === "info") return entry.fact.name;
+  }
+  return "";
+}
+async function scanPiSession(item) {
+  const found = { header: null };
+  const head = await readHeadLines(item.ref, {
+    maxLines: PI_HEAD_MAX_LINES,
+    maxBytes: PI_HEAD_MAX_BYTES,
+    // Se decide con la primera linea: si no es una cabecera, no se lee mas.
+    stopAfter: (line, index) => {
+      if (index > 0) return false;
+      const record = parseJsonlLine(line);
+      found.header = record === null ? null : readHeader(record);
+      return found.header === null;
+    }
+  });
+  const header = found.header;
+  if (header === null || header.sessionId !== item.sessionId) return null;
+  const tail = await readTailLines(item.ref, { maxBytes: TAIL_MAX_BYTES3 });
+  const name = toTitle(lastSessionName(tail) || lastSessionName(head));
+  const first = name.length > 0 ? "" : toTitle(firstUserText2(head));
+  const title = name.length > 0 ? name : first;
+  return {
+    cwd: header.cwd,
+    summary: {
+      sessionId: item.sessionId,
+      title: title.length > 0 ? title : UNTITLED_SESSION_TITLE,
+      titleSource: name.length > 0 ? "custom" : first.length > 0 ? "first-message" : "none",
+      updatedAt: item.mtimeMs,
+      sizeBytes: item.sizeBytes
+    },
+    extra: {}
+  };
+}
+
+// packages/server/src/agents/pi/history.ts
+var PI_FOLLOW_POLL_MS = 1e3;
+var accepts2 = (filePath) => parseSessionFileName(path34.basename(filePath)) !== null;
+function toItem3(ref, info) {
+  const name = parseSessionFileName(path34.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)),
+    mtimeMs: info.mtimeMs,
+    sizeBytes: info.size
+  };
+}
+async function itemOf3(ref) {
+  try {
+    const info = await stat18(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("/");
+  if (relative.length === 0) return false;
+  if (relative.startsWith("..")) return true;
+  const parts = relative.split("/");
+  const [folder, file] = parts;
+  if (folder === void 0 || !isProjectFolderName(folder)) return true;
+  if (parts.length === 1) return false;
+  return parts.length > 2 || file === void 0 || parseSessionFileName(file) === null;
+}
+function createPiHistory(catalog) {
+  return {
+    /*
+      La raiz siempre, exista o no: `sessions/` no existe hasta que Pi se abre
+      por primera vez. Que hacer con una raiz que todavia no esta es del
+      watcher, que la espera sin vigilar a su padre.
+    */
+    roots() {
+      const layout = piSessionsLayout();
+      if (layout === null) return [];
+      const awaitWriteFinish = { stabilityThreshold: 300, pollInterval: 100 };
+      if (layout.flat) return [{ path: layout.root, depth: 0, accepts: accepts2, awaitWriteFinish }];
+      const root = layout.root;
+      return [{ path: root, depth: 1, accepts: accepts2, ignore: (filePath) => ignoresPath(root, filePath), awaitWriteFinish }];
+    },
+    async list() {
+      const layout = piSessionsLayout();
+      if (layout === null) return null;
+      try {
+        if (!(await stat18(layout.root)).isDirectory()) return null;
+      } catch {
+        return null;
+      }
+      const items = [];
+      for (const ref of await listSessionFiles(layout)) {
+        const item = await itemOf3(ref);
+        if (item !== null) items.push(item);
+      }
+      return items;
+    },
+    async changedRefs(filePath) {
+      if (!accepts2(filePath)) return null;
+      const layout = piSessionsLayout();
+      return layout !== null && isInside3(layout.root, filePath) ? [filePath] : null;
+    },
+    item: (ref) => itemOf3(ref),
+    scan: (item) => scanPiSession(item),
+    // Pi no aprende nada de la instalacion al leer una sesion.
+    restored: () => void 0,
+    /** true si esa sesion tiene archivo: Pi lo crea con el primer mensaje. */
+    exists: async (cwd, sessionId) => await findSessionFile(sessionId, cwd) !== null,
+    follow(target, options) {
+      return new PiSessionFollower(target.cwd, target.sessionId, {
+        catalog,
+        limits: options?.limits,
+        maxEvents: options?.maxEvents
+      });
+    },
+    // `follow` respeta `FollowOptions`: el respaldo puede leer de aca.
+    wholeRead: true,
+    plans: null,
+    /*
+      Pi escribe cada entrada cuando termina su mensaje. Releer cada segundo es
+      un `stat` y los bytes nuevos, y no depende de que el watcher vea lo que se
+      agrega a un archivo que otro proceso tiene abierto (lo que obligo a lo
+      mismo con Codex).
+    */
+    followPollMs: PI_FOLLOW_POLL_MS
+  };
+}
+
+// packages/server/src/agents/pi/live.ts
+import { open as open6, stat as stat19 } from "node:fs/promises";
+var PI_LIVE_POLL_MS = 500;
+var PI_ERROR_CALM_MS = 2e3;
+var PI_TRUST_WAITING = "trust dialog";
+var USER_MESSAGES_KEPT = 30;
+var CLOCK_SLACK_MS = 2e3;
+var READ_CHUNK_BYTES2 = 256 * 1024;
+var NEWLINE3 = 10;
+function isPiCommandText(text) {
+  return /^\s*[/!]/.test(text);
+}
+var PiLiveSessions = class {
+  sessions = /* @__PURE__ */ new Map();
+  subscriptions = /* @__PURE__ */ new Set();
+  findFile;
+  now;
+  pollMs;
+  timer = null;
+  constructor(deps = {}) {
+    this.findFile = deps.findFile ?? findSessionFile;
+    this.now = deps.now ?? Date.now;
+    this.pollMs = deps.pollMs ?? PI_LIVE_POLL_MS;
+  }
+  /**
+   * Una sesion gana un proceso. `file` es su archivo si ya se conoce; `fromStart`
+   * lo lee desde el principio (una sesion a la que la pestana acaba de pasar),
+   * y si no, desde donde esta ahora: lo anterior es de otro proceso.
+   */
+  attach(sessionId, options) {
+    const live = {
+      sessionId,
+      cwd: options.cwd,
+      launchedAt: options.launchedAt,
+      file: options.file ?? null,
+      offset: 0,
+      pending: Buffer.alloc(0),
+      lineNumber: 0,
+      blocked: false,
+      turn: null,
+      userMessages: [],
+      settledAt: null,
+      reading: Promise.resolve()
+    };
+    this.sessions.set(sessionId, live);
+    live.reading = this.prime(live, options.fromStart === true).then(() => this.publish(sessionId));
+    this.start();
+  }
+  /** El proceso de esa sesion termino, o la pestana paso a otra. */
+  detach(sessionId) {
+    if (!this.sessions.delete(sessionId)) return;
+    this.publish(sessionId);
+    if (this.sessions.size === 0) this.stop();
+  }
+  /** El archivo que se esta leyendo para esa sesion, o null. */
+  fileOf(sessionId) {
+    return this.sessions.get(sessionId)?.file ?? null;
+  }
+  /** El dialogo de confianza se abrio o se cerro. */
+  setBlocked(sessionId, blocked) {
+    const live = this.sessions.get(sessionId);
+    if (live === void 0 || live.blocked === blocked) return;
+    live.blocked = blocked;
+    this.publish(sessionId);
+  }
+  /** true si la sesion ya recibio un mensaje del usuario con ese texto, mandado en `since` o despues. */
+  delivered(sessionId, submission) {
+    const live = this.sessions.get(sessionId);
+    if (live === void 0) return false;
+    return live.userMessages.some(
+      (message) => message.at >= submission.at - CLOCK_SLACK_MS && plainMatches(message.plain, submission.text)
+    );
+  }
+  /** true si la sesion recibio algun mensaje del usuario en `since` o despues. */
+  userMessageSince(sessionId, since) {
+    return this.sessions.get(sessionId)?.userMessages.some((message) => message.at >= since) ?? false;
+  }
+  /**
+   * Despues de interrumpir desde la app: si el turno ya quedo cerrado en el
+   * archivo, y cuales de esos mensajes no llegaron nunca a la sesion (los que Pi
+   * tenia en cola y devolvio a su editor, 16.5). Lee el archivo en el acto.
+   */
+  async check(sessionId, submissions, interruptedAt) {
+    const live = this.sessions.get(sessionId);
+    if (live === void 0) return { settled: false, undelivered: [] };
+    await this.advance(live);
+    return {
+      settled: live.settledAt !== null && live.settledAt >= interruptedAt - CLOCK_SLACK_MS / 4,
+      undelivered: submissions.filter((submission) => !isPiCommandText(submission.text) && !this.delivered(sessionId, submission)).map((each) => each.text)
+    };
+  }
+  /** El estado de esa sesion ahora, o null si no tiene proceso. */
+  statusOf(sessionId) {
+    const live = this.sessions.get(sessionId);
+    if (live === void 0) return null;
+    if (live.blocked) return { activity: "waiting", waitingFor: PI_TRUST_WAITING };
+    const turn = live.turn;
+    if (turn === null) return { activity: "idle", waitingFor: null };
+    if (turn.state === "working") return { activity: "busy", waitingFor: null };
+    if (turn.state === "errored" && this.now() - turn.seenAt < PI_ERROR_CALM_MS) return { activity: "busy", waitingFor: null };
+    return { activity: "idle", waitingFor: null };
+  }
+  subscribe(sessionId, listener) {
+    const subscription = { sessionId, listener, last: null };
+    this.subscriptions.add(subscription);
+    this.deliver(subscription);
+    return () => {
+      this.subscriptions.delete(subscription);
+    };
+  }
+  /** Lee ya lo nuevo de esa sesion y avisa lo que cambio. */
+  async refresh(sessionId) {
+    const live = this.sessions.get(sessionId);
+    if (live === void 0) return;
+    await this.advance(live);
+    this.publish(sessionId);
+  }
+  /** Una vuelta del sondeo. Publica para el chequeo. */
+  async tick() {
+    for (const live of [...this.sessions.values()]) {
+      await this.advance(live);
+      this.publish(live.sessionId);
+    }
+  }
+  dispose() {
+    this.subscriptions.clear();
+    this.sessions.clear();
+    this.stop();
+  }
+  start() {
+    if (this.timer !== null) return;
+    this.timer = setInterval(() => void this.tick(), this.pollMs);
+    this.timer.unref();
+  }
+  stop() {
+    if (this.timer === null) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+  publish(sessionId) {
+    for (const subscription of this.subscriptions) {
+      if (subscription.sessionId === sessionId) this.deliver(subscription);
+    }
+  }
+  deliver(subscription) {
+    const status = this.statusOf(subscription.sessionId);
+    const key = status === null ? "none" : `${status.activity}|${status.waitingFor ?? ""}`;
+    if (key === subscription.last) return;
+    subscription.last = key;
+    subscription.listener(status);
+  }
+  /** Fija desde donde se lee: el final de lo que ya habia, salvo `fromStart`. */
+  async prime(live, fromStart) {
+    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;
+    } catch {
+      live.offset = 0;
+    }
+  }
+  /** Lee las lineas nuevas del archivo, en serie con la lectura anterior. Nunca lanza. */
+  advance(live) {
+    live.reading = live.reading.then(() => this.readNew(live)).catch(() => void 0);
+    return live.reading;
+  }
+  async readNew(live) {
+    if (this.sessions.get(live.sessionId) !== live) return;
+    if (live.file === null) {
+      live.file = await this.findFile(live.sessionId, live.cwd).catch(() => null);
+      if (live.file === null) return;
+    }
+    let size;
+    try {
+      size = (await stat19(live.file)).size;
+    } catch {
+      return;
+    }
+    if (size < live.offset) {
+      live.offset = 0;
+      live.pending = Buffer.alloc(0);
+      live.lineNumber = 0;
+    }
+    if (size === live.offset) return;
+    const handle = await open6(live.file, "r");
+    try {
+      const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES2);
+      while (live.offset < size) {
+        const { bytesRead } = await handle.read(buffer, 0, Math.min(READ_CHUNK_BYTES2, size - live.offset), live.offset);
+        if (bytesRead === 0) break;
+        live.offset += bytesRead;
+        const combined = Buffer.concat([live.pending, buffer.subarray(0, bytesRead)]);
+        let start = 0;
+        let newline = combined.indexOf(NEWLINE3, start);
+        while (newline !== -1) {
+          this.consume(live, combined.subarray(start, newline).toString("utf8"));
+          start = newline + 1;
+          newline = combined.indexOf(NEWLINE3, start);
+        }
+        live.pending = Buffer.from(combined.subarray(start));
+      }
+    } finally {
+      await handle.close();
+    }
+  }
+  consume(live, line) {
+    live.lineNumber += 1;
+    if (line.trim().length === 0) return;
+    const record = parseJsonlLine(line);
+    const entry = record === null ? null : readEntry(record, live.lineNumber, TRANSPORT_LIMITS);
+    if (entry === null) return;
+    if (entry.at !== 0 && entry.at < live.launchedAt - CLOCK_SLACK_MS) return;
+    const seenAt = this.now();
+    const { fact } = entry;
+    if (fact.kind === "user") {
+      live.turn = { state: "working", at: entry.at, seenAt };
+      live.userMessages.push({ plain: fact.plain, at: entry.at });
+      if (live.userMessages.length > USER_MESSAGES_KEPT) live.userMessages.shift();
+    } else if (fact.kind === "toolResult") {
+      live.turn = { state: "working", at: entry.at, seenAt };
+    } else if (fact.kind === "assistant") {
+      if (fact.stopReason === "toolUse") {
+        live.turn = { state: "working", at: entry.at, seenAt };
+      } else {
+        live.turn = { state: fact.stopReason === "error" ? "errored" : "idle", at: entry.at, seenAt };
+        live.settledAt = entry.at === 0 ? seenAt : entry.at;
+      }
+    } else if (fact.kind === "bash") {
+      live.settledAt = entry.at === 0 ? seenAt : entry.at;
+      if (live.turn === null || live.turn.state !== "working") live.turn = { state: "idle", at: entry.at, seenAt };
+    }
+  }
+};
+var PiStatusSource = class {
+  constructor(live) {
+    this.live = live;
+  }
+  live;
+  subscribe(sessionId, listener) {
+    return this.live.subscribe(sessionId, listener);
+  }
+  /**
+   * Siempre false: que el archivo diga "libre" no dice que la interfaz de Pi
+   * este lista para un pegado, y antes del primer mensaje ni siquiera hay
+   * archivo (`readySignal` es false).
+   */
+  waitUntilReady() {
+    return Promise.resolve(false);
+  }
+  refresh(sessionId) {
+    return this.live.refresh(sessionId);
+  }
+  dispose() {
+    this.live.dispose();
+  }
+};
+
+// packages/server/src/agents/pi/locate.ts
+import { readFile as readFile11, realpath as realpath2 } from "node:fs/promises";
+import path35 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"))));
+    if (manifest === null || manifest["name"] !== PI_PACKAGE_NAME) return null;
+    const version = manifest["version"];
+    return typeof version === "string" && version.length > 0 ? version : null;
+  } catch {
+    return null;
+  }
+}
+async function candidateDirs(resolvedPath, deps) {
+  const dir = path35.dirname(resolvedPath);
+  const candidates = [
+    path35.join(dir, "node_modules", ...PACKAGE_PARTS),
+    path35.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();
+    if (version !== "." && version !== ".." && MANAGED_VERSION_PATTERN.test(version)) {
+      candidates.push(path35.join(installRoot, "releases", version, "node_modules", ...PACKAGE_PARTS));
+    }
+  } catch {
+  }
+  try {
+    let cursor = path35.dirname(await deps.realpath(resolvedPath));
+    for (let level = 0; level < WALK_UP_LEVELS; level += 1) {
+      candidates.push(cursor);
+      const parent = path35.dirname(cursor);
+      if (parent === cursor) break;
+      cursor = parent;
+    }
+  } catch {
+  }
+  return candidates;
+}
+var warnedForeign = /* @__PURE__ */ new Set();
+async function locatePi(overrides = {}) {
+  const deps = {
+    findInPath: overrides.findInPath ?? findInPath,
+    readFile: overrides.readFile ?? ((file) => readFile11(file, "utf8")),
+    realpath: overrides.realpath ?? realpath2
+  };
+  const resolvedPath = await deps.findInPath(PI_COMMAND);
+  if (resolvedPath === null) return null;
+  for (const packageDir of await candidateDirs(resolvedPath, deps)) {
+    const version = await packageVersion(packageDir, deps.readFile);
+    if (version !== null) return { resolvedPath, ...launcherFor(resolvedPath), version, packageDir };
+  }
+  if (!warnedForeign.has(resolvedPath)) {
+    warnedForeign.add(resolvedPath);
+    console.warn(
+      `[pi] found a "pi" command at ${resolvedPath}, but not the ${PI_PACKAGE_NAME} package next to it: it isn't used.`
+    );
+  }
+  return null;
+}
+
+// packages/server/src/agents/pi/tab-watch.ts
+import { readdir as readdir10, stat as stat20 } from "node:fs/promises";
+import path36 from "node:path";
+var TRUST_TITLE = "Trust project folder?";
+var INTERFACE_STARTED = "\x1B[?1049h";
+function trustDialogOpen(output) {
+  const title = output.lastIndexOf(TRUST_TITLE);
+  return title !== -1 && output.lastIndexOf(INTERFACE_STARTED) < title;
+}
+function interfaceStarted(output) {
+  return output.includes(INTERFACE_STARTED) && !trustDialogOpen(output);
+}
+var STARTUP_CHECK_MS = 300;
+var STARTUP_DEADLINE_MS = 6e4;
+var SCAN_DELAYS_MS = [400, 1500, 4e3];
+var TYPED_WINDOW_MS = 3e3;
+var CLOCK_SLACK_MS2 = 2e3;
+var SUBMISSIONS_KEPT = 20;
+var SUBMISSION_MAX_AGE_MS = 5 * 6e4;
+var PEEK_TAIL_BYTES = 256 * 1024;
+async function listSessionsIn(dir) {
+  let names;
+  try {
+    names = await readdir10(dir);
+  } catch {
+    return [];
+  }
+  const files = [];
+  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 });
+    } catch {
+    }
+  }
+  return files;
+}
+async function peekSession(file) {
+  try {
+    const header = await readSessionHeader(file);
+    if (header === null) return null;
+    const tail = await readTailLines(file, { maxBytes: PEEK_TAIL_BYTES });
+    for (let index = tail.length - 1; index >= 0; index -= 1) {
+      const line = tail[index];
+      if (line === void 0 || !line.includes('"user"')) continue;
+      const record = parseJsonlLine(line);
+      const entry = record === null ? null : readEntry(record, index + 1, TRANSPORT_LIMITS);
+      if (entry !== null && entry.fact.kind === "user") return { header, lastUser: { plain: entry.fact.plain, at: entry.at } };
+    }
+    return { header, lastUser: null };
+  } catch {
+    return null;
+  }
+}
+var PiTabWatch = class {
+  constructor(context, deps) {
+    this.context = context;
+    this.live = deps.live;
+    this.tabs = deps.tabs;
+    this.listSessions = deps.listSessions ?? listSessionsIn;
+    this.peek = deps.peek ?? peekSession;
+    this.sessionDir = deps.sessionDir ?? ((cwd) => sessionDirFor(cwd));
+    this.now = deps.now ?? Date.now;
+    this.platform = deps.platform ?? process.platform;
+    this.useTimers = deps.timers ?? true;
+    this.sessionId = isPiSessionId(context.sessionId) ? context.sessionId : "";
+  }
+  context;
+  live;
+  tabs;
+  listSessions;
+  peek;
+  sessionDir;
+  now;
+  platform;
+  useTimers;
+  /** La sesion en la que esta la pestana ahora. `''` si el id con que nacio no es de Pi. */
+  sessionId;
+  /** El archivo de esa sesion, si ya se sabe cual es. */
+  file = null;
+  /** Tamano de cada archivo de la carpeta la ultima vez que se miro. null: todavia no se miro. */
+  sizes = null;
+  submissions = [];
+  enterAt = null;
+  closed = false;
+  scanning = Promise.resolve();
+  startupTimer = null;
+  scanTimers = /* @__PURE__ */ new Set();
+  /** El archivo de la sesion en curso, para que otra pestana no se la quede. */
+  get currentFile() {
+    return this.file ?? (this.sessionId.length > 0 ? this.live.fileOf(this.sessionId) : null);
+  }
+  get cwd() {
+    return this.context.cwd;
+  }
+  /** Epoch ms del ultimo Enter escrito en la pty de esta pestana, o null. */
+  get lastEnterAt() {
+    return this.enterAt;
+  }
+  start() {
+    if (this.sessionId.length > 0) {
+      this.live.attach(this.sessionId, { cwd: this.context.cwd, launchedAt: this.context.launchedAt });
+    }
+    void this.scan();
+    if (!this.useTimers) return;
+    this.startupTimer = setInterval(() => this.checkTrust(), STARTUP_CHECK_MS);
+    this.startupTimer.unref();
+  }
+  hook() {
+    return {
+      cancel: () => this.close(),
+      onInput: (data) => {
+        if (data.includes("\r")) this.noteEnter();
+      },
+      onSubmitted: (text) => this.noteSubmitted(text)
+    };
+  }
+  /** Mira la salida: el dialogo de confianza abierto frena el cuadro. Publica para el chequeo. */
+  checkTrust() {
+    if (this.closed || this.sessionId.length === 0) return;
+    const output = this.context.readOutput();
+    const open9 = trustDialogOpen(output);
+    this.live.setBlocked(this.sessionId, open9);
+    if (open9) return;
+    if (interfaceStarted(output) || this.now() - this.context.launchedAt > STARTUP_DEADLINE_MS) {
+      if (this.startupTimer !== null) clearInterval(this.startupTimer);
+      this.startupTimer = null;
+    }
+  }
+  /** Alguien apreto Enter en la pty: puede ser el que cambia de sesion. */
+  noteEnter() {
+    if (this.closed) return;
+    this.enterAt = this.now();
+    this.scheduleScans();
+  }
+  /** La app va a mandar este texto. */
+  noteSubmitted(text) {
+    if (this.closed || text.trim().length === 0) return;
+    const now = this.now();
+    this.submissions = [
+      ...this.submissions.filter((each) => now - each.at < SUBMISSION_MAX_AGE_MS),
+      { text, at: now }
+    ].slice(-SUBMISSIONS_KEPT);
+  }
+  scheduleScans() {
+    if (!this.useTimers) return;
+    for (const timer of this.scanTimers) clearTimeout(timer);
+    this.scanTimers.clear();
+    for (const delay2 of SCAN_DELAYS_MS) {
+      const timer = setTimeout(() => {
+        this.scanTimers.delete(timer);
+        void this.scan();
+      }, delay2);
+      timer.unref();
+      this.scanTimers.add(timer);
+    }
+  }
+  /** Una pasada por la carpeta de sesiones del proyecto, en serie con la anterior. Nunca lanza. */
+  scan() {
+    this.scanning = this.scanning.then(() => this.scanOnce()).catch(() => void 0);
+    return this.scanning;
+  }
+  async scanOnce() {
+    if (this.closed) return;
+    const dir = this.sessionDir(this.context.cwd);
+    if (dir === null) return;
+    const files = await this.listSessions(dir);
+    if (this.closed) return;
+    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;
+    }
+    if (previous === null) return;
+    const own = this.currentFile;
+    const taken = /* @__PURE__ */ new Set();
+    for (const tab of this.tabs()) {
+      const file = tab === this ? null : tab.currentFile;
+      if (file !== null) taken.add(this.fileKey(file));
+    }
+    const candidates = files.filter((each) => {
+      if (own !== null && this.fileKey(each.file) === this.fileKey(own)) return false;
+      if (taken.has(this.fileKey(each.file))) return false;
+      const before = previous.get(each.file);
+      if (before !== void 0 && each.size <= before) return false;
+      return each.mtimeMs >= this.context.launchedAt - CLOCK_SLACK_MS2;
+    }).sort((a, b) => b.mtimeMs - a.mtimeMs);
+    for (const candidate of candidates) {
+      const info = await this.peek(candidate.file);
+      if (this.closed) return;
+      if (info === null || !isPiSessionId(info.header.sessionId)) continue;
+      if (normalizeCwdKey(info.header.cwd, this.platform) !== normalizeCwdKey(this.context.cwd, this.platform)) continue;
+      const reason2 = this.claims(info, !previous.has(candidate.file));
+      if (reason2 === null) continue;
+      this.switchTo(info.header.sessionId, candidate.file, reason2);
+      return;
+    }
+  }
+  fileKey(file) {
+    return normalizeCwdKey(file, this.platform);
+  }
+  /** Por que ese archivo es la sesion nueva de esta pestana, o null si no se puede decir. */
+  claims(info, isNew) {
+    const own = this.currentFile;
+    if (isNew && own !== null && info.header.parentSession !== null && this.fileKey(info.header.parentSession) === this.fileKey(own)) {
+      return "fork";
+    }
+    const last = info.lastUser;
+    if (last === null) return null;
+    const now = this.now();
+    const sent = this.submissions.some(
+      (each) => now - each.at < SUBMISSION_MAX_AGE_MS && last.at >= each.at - CLOCK_SLACK_MS2 && plainMatches(last.plain, each.text) && // Si ya llego a la sesion en curso, no es de la otra.
+      (this.sessionId.length === 0 || !this.live.delivered(this.sessionId, each))
+    );
+    if (sent) return "submitted";
+    const enterAt = this.enterAt;
+    if (enterAt === null || last.at < enterAt - CLOCK_SLACK_MS2 / 4 || last.at > enterAt + TYPED_WINDOW_MS) return null;
+    if (this.sessionId.length > 0 && this.live.userMessageSince(this.sessionId, enterAt - CLOCK_SLACK_MS2 / 4)) return null;
+    const key = normalizeCwdKey(this.context.cwd, this.platform);
+    let rivals = 0;
+    for (const tab of this.tabs()) {
+      if (tab === this || normalizeCwdKey(tab.cwd, this.platform) !== key) continue;
+      const other = tab.lastEnterAt;
+      if (other === null || last.at < other - CLOCK_SLACK_MS2 / 4 || last.at > other + TYPED_WINDOW_MS) continue;
+      if (Math.abs(last.at - other) < Math.abs(last.at - enterAt)) return null;
+      rivals += 1;
+    }
+    if (rivals > 0) {
+      console.warn(
+        `[pi] ${rivals + 1} Pi tabs in ${this.context.cwd} typed at the same time: session ${info.header.sessionId.slice(0, 8)} was assigned to the closest one without confirmation.`
+      );
+    }
+    return "typed";
+  }
+  switchTo(sessionId, file, reason2) {
+    const previous = this.sessionId;
+    if (sessionId === previous) return;
+    debugLog("registry", `pi tab ${this.context.terminalId.slice(0, 8)}: session ${sessionId.slice(0, 8)} (${reason2})`);
+    this.sessionId = sessionId;
+    this.file = file;
+    this.submissions = [];
+    this.live.attach(sessionId, { cwd: this.context.cwd, launchedAt: this.context.launchedAt, file, fromStart: true });
+    this.context.reportSessionId(sessionId);
+    if (previous.length > 0) this.live.detach(previous);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.startupTimer !== null) clearInterval(this.startupTimer);
+    this.startupTimer = null;
+    for (const timer of this.scanTimers) clearTimeout(timer);
+    this.scanTimers.clear();
+    if (this.sessionId.length > 0) this.live.detach(this.sessionId);
+  }
+};
+
+// packages/server/src/agents/pi/index.ts
+var PI_MODELS_POLL_MS = 2e3;
+var PI_BASE_CAPABILITIES = {
+  // `--session-id <id>` con un id que pone la app (16.4).
+  sessionIdAtLaunch: true,
+  // El mismo comando abre la sesion si existe.
+  resume: true,
+  // Del archivo de sesion: trabajando desde el mensaje hasta la respuesta final (16.6).
+  statusSource: true,
+  // "Libre" no dice que la interfaz ya acepte un pegado, y antes del primer mensaje no hay archivo.
+  readySignal: false,
+  // Pi no tiene modos de permiso.
+  permissionCycle: null,
+  // Los de la cuenta, cuando se leen (`capabilities`).
+  models: null,
+  // `/thinking <nivel>` se aplica directo y escribe su entrada en el acto (16.10).
+  efforts: PI_EFFORT_OPTIONS,
+  // No tiene herramienta de preguntas.
+  questionCards: false,
+  // Pi no adjunta lo pegado: la ruta va en el texto y el modelo la abre (16.5).
+  imagesByPath: "quoted-path-line",
+  // `@` abre un buscador de archivos y queda como texto.
+  fileMentions: null,
+  // Dos Esc abren `/tree`: otro flujo.
+  rewind: false,
+  // Tokens por respuesta en la sesion, y la ventana en el catalogo (16.9).
+  contextWindowSource: "usage-with-catalog",
+  plans: false,
+  // Con el dialogo de confianza abierto, el Enter de un mensaje lo aceptaria (16.11).
   waitingBlocksSubmit: true
 };
-var OPENCODE_INPUT = {
-  imageReference: "bare-path-paste",
-  pieceGapMs: 400,
+var PI_INPUT = {
+  imageReference: "quoted-path-line",
+  pieceGapMs: 0,
   pasteMarkers: true,
-  enterSeparately: true,
-  interruptPresses: 2,
-  // `@` abre un buscador en el TUI (11.11): el transcript va entre comillas.
-  transcriptReference: "quoted-path"
+  enterSeparately: false,
+  interruptPresses: 1,
+  // Con la ruta entre comillas el modelo abre el archivo (medido); `@` abre un buscador.
+  transcriptReference: "quoted-path",
+  // Antes de que dibuje su interfaz, un Enter no envia: el texto queda en su editor (16.4).
+  readyAfterLaunchMs: PI_READY_AFTER_LAUNCH_MS
 };
-function copyEnvironment(base) {
-  const env = {};
-  for (const [key, value] of Object.entries(base)) {
-    if (value !== void 0) env[key] = value;
-  }
-  return env;
-}
-function createOpenCodeAdapter(options = {}) {
-  const platform = options.platform ?? process.platform;
-  const env = options.env ?? process.env;
-  const sqlite = options.sqlite ?? loadSqlite;
-  const paths = resolveOpenCodePaths(env, options.home ?? homedir8(), platform);
-  const db = new ReadOnlyDatabase(paths.dbFile ?? "", {
-    idleCloseMs: OPENCODE_DB_IDLE_CLOSE_MS,
-    required: OPENCODE_REQUIRED_COLUMNS,
-    label: OPENCODE_LABEL,
-    sqlite
-  });
-  const signal = new DbChangeSignal(
-    paths.dbFile === null || paths.walFile === null ? null : { db: paths.dbFile, wal: paths.walFile }
-  );
-  const catalog = new ModelCatalog(paths.modelsFile);
-  const serveEnv = options.serveEnv ?? (() => copyEnvironment(process.env));
-  let serve = null;
-  const status = new OpenCodeServeStatus({ ...options.serveStatus, parentOf: (id) => readSessionParent(db, id) });
-  let current = null;
-  const serveFor = (location) => {
-    if (serve !== null) return serve;
-    const created = new OpenCodeServeProcess({ ...options.serveProcess, location, baseEnv: serveEnv });
-    created.onExit((endpoint, exit) => {
-      status.detach(endpoint, exit.requested ? null : "server-closed");
-      if (current?.endpoint === endpoint) current = null;
-    });
-    serve = created;
-    return created;
-  };
-  const clientFor = (endpoint) => {
-    if (current?.endpoint === endpoint) return current.client;
-    current = { endpoint, client: new OpenCodeServeClient(endpoint, void 0, options.serveClient) };
-    return current.client;
+function createPiAdapter(options = {}) {
+  let packageDir = null;
+  const catalog = new PiModelCatalog({ storeFile: piModelsStorePath, packageDir: () => packageDir });
+  const live = new PiLiveSessions(options.live);
+  const status = new PiStatusSource(live);
+  const tabs = /* @__PURE__ */ new Set();
+  const pollers = /* @__PURE__ */ new Set();
+  const storeStamp = async () => {
+    const file = piModelsStorePath();
+    if (file === null) return "none";
+    try {
+      const info = await stat21(file);
+      return `${info.mtimeMs}:${info.size}`;
+    } catch {
+      return "none";
+    }
   };
-  const questions = new OpenCodeQuestions({
-    lookupCall: (partId, sessionId) => readPartCall(db, partId, sessionId),
-    client: () => current?.client ?? null
-  });
   return {
-    id: "opencode",
-    label: OPENCODE_LABEL,
-    command: OPENCODE_COMMAND,
-    installUrl: OPENCODE_INSTALL_URL,
-    capabilities: OPENCODE_CAPABILITIES,
-    input: OPENCODE_INPUT,
-    // `--version` es seguro: medido, no toca la base ni escribe log.
-    locate: () => locateCommand(OPENCODE_COMMAND),
-    missingMessage: () => commandNotFoundMessage(OPENCODE_COMMAND, OPENCODE_INSTALL_URL),
+    id: "pi",
+    label: PI_LABEL,
+    command: PI_COMMAND,
+    installUrl: PI_INSTALL_URL,
+    get capabilities() {
+      const models = modelOptions(catalog.list());
+      return models.length === 0 ? PI_BASE_CAPABILITIES : { ...PI_BASE_CAPABILITIES, models };
+    },
+    input: PI_INPUT,
+    async locate() {
+      const found = await locatePi(options.locate);
+      packageDir = found?.packageDir ?? null;
+      if (found === null) return null;
+      return { resolvedPath: found.resolvedPath, file: found.file, prefixArgs: found.prefixArgs, version: found.version };
+    },
+    missingMessage: () => commandNotFoundMessage(PI_COMMAND, PI_INSTALL_URL),
     /**
-     * `attach <url> --dir . --session <id> --password <hex>` (D5), con la
-     * sesion nueva creada por API (D6). No es `async` (M1b): un id de
-     * reanudacion invalido lanza aca mismo, sin tocar el `serve`, porque detras
-     * de `cmd.exe /c` un `&` se ejecuta. Lo que falla despues —el `serve` que no
-     * arranca, la sesion que no se crea— rechaza, y el registro lo muestra como
-     * `spawn-failed` con el motivo (D1). `proposedSessionId` no se usa: el id lo
-     * pone OpenCode.
+     * `--session-id <id>` para una sesion nueva y para una que se reanuda: Pi
+     * decide sola cual es. El id se valida antes de tocar la linea de comando,
+     * porque va detras de `cmd /c` (CLAUDE.md 3.1): con la forma que exige Pi es
+     * un token sin espacios ni comillas, y no puede leerse como una opcion.
      */
     launch(input) {
-      return launchWithServe(
-        {
-          ensure: () => serveFor(input.location).ensure(),
-          createSession: (endpoint, directory) => clientFor(endpoint).createSession(directory),
-          track: (endpoint, sessionId, directory) => status.track(sessionId, directory, clientFor(endpoint))
-        },
-        input
-      );
+      const sessionId = input.resumeSessionId ?? input.proposedSessionId;
+      if (!isPiSessionId(sessionId)) throw new Error("Invalid Pi session id.");
+      return {
+        file: input.location.file,
+        args: [...input.location.prefixArgs, "--session-id", sessionId],
+        session: { kind: "known", sessionId }
+      };
     },
-    /** Copia del entorno, sin quitar nada: OpenCode no hereda ningun marcador que le estorbe. */
+    /**
+     * Copia del entorno, sin quitar nada y sin agregar nada: ni
+     * `PI_PROGRAM_STATUS`, que encenderia los avisos de estado, ni
+     * `PI_TELEMETRY`, que apagaria el aviso de instalacion a pi.dev. Las dos son
+     * del usuario (regla 2.1).
+     */
     environment(base) {
-      return { env: copyEnvironment(base), notice: null };
+      const env = {};
+      for (const [key, value] of Object.entries(base)) {
+        if (value !== void 0) env[key] = value;
+      }
+      return { env, notice: null };
     },
     /*
-      Toda pestana lanzada, nueva o reanudada, retiene el `serve` mientras viva
-      su pty, y al cerrarse corta la sesion si quedo trabajando o esperando
-      (D13): con `attach`, el trabajo seguiria en el `serve` sin ningun TUI que
-      lo muestre. El corte va al cliente vigente: el de un `serve` que ya murio
-      no esta, y su estado ya es null.
+      El gancho vive toda la vida de la pestana: mira el dialogo de confianza al
+      arrancar y, despues de cada Enter, si Pi paso a escribir en otra sesion
+      (`/new`, `/fork`, `/resume`). Declara `onInput` para que el primer write no
+      lo suelte.
     */
     onSpawned(context) {
-      if (context.sessionId.length === 0) return null;
-      const { sessionId, cwd } = context;
-      return createServeLaunchHook({
-        sessionId,
-        cwd,
-        release: serve?.retain() ?? (() => {
-        }),
-        current: () => status.current(sessionId),
-        abort: (directory, id) => current?.client.abort(directory, id) ?? Promise.resolve()
-      });
+      const watch = new PiTabWatch(context, { live, tabs: () => tabs });
+      tabs.add(watch);
+      watch.start();
+      const hook = watch.hook();
+      return {
+        ...hook,
+        cancel: () => {
+          tabs.delete(watch);
+          hook.cancel();
+        }
+      };
     },
-    history: createOpenCodeHistory({
-      dbFile: paths.dbFile,
-      db,
-      signal,
-      catalog,
-      platform,
-      sqlite
-    }),
+    history: createPiHistory(catalog),
     status,
-    questions,
-    /**
-     * 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:
-     *
-     *  - con la base en memoria (`OPENCODE_DB=:memory:`, que alguien puso a
-     *    proposito), que no hay nada que leer;
-     *  - sin `node:sqlite`, el aviso de la version de Node, si hay una base que
-     *    no se va a ver o la CLI esta instalada;
-     *  - con la base en disco, su ruta.
-     *
-     * Con la base ausente no dice nada: `status()` es perezoso y no sabe si
-     * existe hasta la primera consulta, asi que se mira el archivo.
-     */
-    startupHistoryNote(cliAvailable) {
-      if (env["OPENCODE_DB"] === ":memory:") return "in memory (nothing to read)";
-      if (paths.dbFile === null) return null;
-      const present = existsSync2(paths.dbFile);
-      if ("unavailable" in sqlite()) return present || cliAvailable ? `not read: ${sqliteUnavailableText(OPENCODE_LABEL)}` : null;
-      return present ? `${paths.dbFile} (read-only)` : null;
+    queuedSubmits: {
+      clearGapMs: PI_CLEAR_GAP_MS,
+      check: (target, submissions, interruptedAt) => live.check(target.sessionId, submissions, interruptedAt)
     },
-    // `opencode.json` no se abre (regla 2.1).
+    // `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),
     /**
-     * Las cuatro carpetas de OpenCode: datos (la base, `auth.json`),
-     * configuracion, cache y estado. No se listan ni se entran (regla 2.1). La
-     * carpeta de un `OPENCODE_DB` propio no: puede ser la de un proyecto.
-     */
-    protectedDirs: () => [paths.dataDir, paths.configDir, paths.cacheDir, paths.stateDir],
-    /**
-     * Suelta el estado (sus oyentes reciben null y el flujo se cierra) antes de
-     * matar el `serve`: los ganchos de las pestanas, que se cancelan despues en
-     * el apagado, ya no piden ningun corte (M7). La promesa espera a que el
-     * proceso salga; la orden de matarlo sale antes de devolver.
+     * `~/.pi` entera y, si `PI_CODING_AGENT_DIR` apunta a otro lado, esa
+     * tambien: las credenciales de antes de cambiarla siguen en la primera. La
+     * carpeta de sesiones de `PI_CODING_AGENT_SESSION_DIR` no: puede ser la de
+     * un proyecto.
      */
+    protectedDirs: () => {
+      const dirs = [path37.join(homedir10(), ".pi")];
+      const agentDir = piAgentDir();
+      if (agentDir !== null && !dirs.some((dir) => agentDir === dir || agentDir.startsWith(`${dir}${path37.sep}`))) {
+        dirs.unshift(agentDir);
+      }
+      return dirs;
+    },
+    /** Lee el catalogo de la cuenta. Solo corre con Pi encontrada. */
+    async prepare() {
+      await catalog.reload();
+    },
+    refreshSetup: () => catalog.reload(),
+    /** Avisa cuando la lista de modelos de la cuenta cambia: un `/login` nuevo, o Pi que la refresca. */
+    subscribeChanges(listener) {
+      let last = null;
+      let busy = false;
+      const timer = setInterval(() => {
+        if (busy) return;
+        busy = true;
+        void (async () => {
+          const stamp2 = await storeStamp();
+          if (last !== null && stamp2 !== last && await catalog.reload()) listener();
+          last = stamp2;
+        })().catch(() => void 0).finally(() => {
+          busy = false;
+        });
+      }, options.modelsPollMs ?? PI_MODELS_POLL_MS);
+      timer.unref();
+      pollers.add(timer);
+      return () => {
+        clearInterval(timer);
+        pollers.delete(timer);
+      };
+    },
     dispose: () => {
+      for (const timer of pollers) clearInterval(timer);
+      pollers.clear();
+      tabs.clear();
       status.dispose();
-      current = null;
-      signal.dispose();
-      db.close();
-      return serve?.dispose() ?? Promise.resolve();
     }
   };
 }
@@ -10536,7 +12523,8 @@ function createAgentRegistry(disabled = []) {
     createClaudeCodeAdapter(),
     createCodexAdapter(),
     createOpenCodeAdapter({ serveEnv: () => registry.composedEnvironment(process.env) }),
-    createAntigravityAdapter()
+    createAntigravityAdapter(),
+    createPiAdapter()
   ], disabled);
   return registry;
 }
@@ -10554,7 +12542,7 @@ async function migrateLegacyConfigDir() {
 
 // packages/server/src/conversation-hub.ts
 import { EventEmitter } from "node:events";
-import path30 from "node:path";
+import path38 from "node:path";
 var INITIAL_EVENT_LIMIT = 300;
 var MAX_PAGE_LIMIT = 500;
 var PENDING_QUESTION_LOOKBACK = 50;
@@ -10615,7 +12603,7 @@ var ConversationHub = class extends EventEmitter {
       await entry.follower.start();
       debugLog(
         "conversation",
-        `following ${path30.basename(entry.follower.label)} for ${terminalId.slice(0, 8)}`
+        `following ${path38.basename(entry.follower.label)} for ${terminalId.slice(0, 8)}`
       );
       entry = this.entries.get(terminalId) ?? entry;
     }
@@ -10721,10 +12709,10 @@ var ConversationHub = class extends EventEmitter {
    */
   refreshOpenToolCall(terminalId, entry) {
     const launchedAt = this.isBlind(entry) ? this.registry.launchedAtOf(terminalId) : null;
-    const open8 = launchedAt !== null && entry.follower.hasOpenToolCall(launchedAt);
-    if (open8 === entry.openToolCall) return;
-    entry.openToolCall = open8;
-    this.emit("toolCall", terminalId, open8);
+    const open9 = launchedAt !== null && entry.follower.hasOpenToolCall(launchedAt);
+    if (open9 === entry.openToolCall) return;
+    entry.openToolCall = open9;
+    this.emit("toolCall", terminalId, open9);
   }
   /**
    * Recalcula los subagentes que siguen trabajando y avisa si cambiaron
@@ -10780,7 +12768,7 @@ var ConversationHub = class extends EventEmitter {
     this.startFollowTicker(terminalId, next);
     debugLog(
       "conversation",
-      `${terminalId.slice(0, 8)} changed session: following ${path30.basename(next.follower.label)}`
+      `${terminalId.slice(0, 8)} changed session: following ${path38.basename(next.follower.label)}`
     );
     await next.follower.start();
     next.primed = true;
@@ -11015,8 +13003,8 @@ var ConversationHub = class extends EventEmitter {
     if (entry === void 0) return null;
     const { events } = entry.follower.getTail(PENDING_QUESTION_LOOKBACK);
     const answered = /* @__PURE__ */ new Set();
-    for (const event of events) {
-      for (const part of event.parts) {
+    for (const event2 of events) {
+      for (const part of event2.parts) {
         if (part.kind === "tool-result") answered.add(part.toolUseId);
       }
     }
@@ -11144,18 +13132,18 @@ function openBrowser(url) {
 // packages/server/src/pty-helper.ts
 import { chmodSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
-import path31 from "node:path";
+import path39 from "node:path";
 function helperCandidates(packageDir, platform, arch) {
   return [
-    path31.join(packageDir, "build", "Release", "spawn-helper"),
-    path31.join(packageDir, "build", "Debug", "spawn-helper"),
-    path31.join(packageDir, "prebuilds", `${platform}-${arch}`, "spawn-helper")
+    path39.join(packageDir, "build", "Release", "spawn-helper"),
+    path39.join(packageDir, "build", "Debug", "spawn-helper"),
+    path39.join(packageDir, "prebuilds", `${platform}-${arch}`, "spawn-helper")
   ];
 }
 function locateNodePty() {
   try {
     const require2 = createRequire(import.meta.url);
-    return path31.resolve(path31.dirname(require2.resolve("node-pty")), "..");
+    return path39.resolve(path39.dirname(require2.resolve("node-pty")), "..");
   } catch {
     return null;
   }
@@ -11816,24 +13804,24 @@ var RemoteAccessService = class {
 };
 
 // packages/server/src/remote-devices-store.ts
-import { chmod, mkdir as mkdir6, readFile as readFile10, stat as stat17 } from "node:fs/promises";
-import path33 from "node:path";
+import { chmod, mkdir as mkdir6, readFile as readFile12, stat as stat23 } from "node:fs/promises";
+import path41 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 stat16, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir5, rename as rename3, rm as rm2, stat as stat22, writeFile as writeFile3 } from "node:fs/promises";
 
 // packages/server/src/vault/paths.ts
 import { createHash as createHash2 } from "node:crypto";
-import path32 from "node:path";
+import path40 from "node:path";
 function defaultVaultDir() {
-  return path32.join(appConfigDir(), "vault");
+  return path40.join(appConfigDir(), "vault");
 }
 function vaultMarkerFile(dir) {
-  return path32.join(dir, "vault.json");
+  return path40.join(dir, "vault.json");
 }
 function sessionsRoot2(dir) {
-  return path32.join(dir, "sessions");
+  return path40.join(dir, "sessions");
 }
 function isSafeSessionId(sessionId) {
   return isVaultSessionId(sessionId);
@@ -11847,41 +13835,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 path32.join(sessionsRoot2(dir), agent);
+  return path40.join(sessionsRoot2(dir), agent);
 }
 function sessionFile(dir, agent, sessionId) {
   assertSessionKey(agent, sessionId);
-  return path32.join(sessionsRoot2(dir), agent, `${sessionId}.jsonl`);
+  return path40.join(sessionsRoot2(dir), agent, `${sessionId}.jsonl`);
 }
 function assetsDir(dir, agent, sessionId) {
   assertSessionKey(agent, sessionId);
-  return path32.join(sessionsRoot2(dir), agent, `${sessionId}.assets`);
+  return path40.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 path32.join(assetsDir(dir, agent, sessionId), asset);
+  return path40.join(assetsDir(dir, agent, sessionId), asset);
 }
-function projectFolderName(cwd, platform) {
+function projectFolderName2(cwd, platform) {
   const hash = createHash2("sha256").update(normalizeCwdKey(cwd, platform)).digest("hex").slice(0, 8);
-  const base = (platform === "win32" ? path32.win32 : path32.posix).basename(cwd);
+  const base = (platform === "win32" ? path40.win32 : path40.posix).basename(cwd);
   const name = base.length === 0 ? "proyecto" : sanitizeFileName(base, 60);
   return `${name}-${hash}`;
 }
 function memoryDir(dir, cwd, platform) {
-  return path32.join(dir, "memory", projectFolderName(cwd, platform));
+  return path40.join(dir, "memory", projectFolderName2(cwd, platform));
 }
 function projectExportDir(dir, cwd, platform) {
-  return path32.join(dir, "export", projectFolderName(cwd, platform));
+  return path40.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 path32.join(dir, "export", `${name}-${hash}`);
+  return path40.join(dir, "export", `${name}-${hash}`);
 }
 function sessionExportFile(dir, agent, sessionId) {
   assertSessionKey(agent, sessionId);
-  return path32.join(dir, "export", "sesiones", `${agent}-${sessionId}.md`);
+  return path40.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) {
@@ -11936,7 +13924,7 @@ async function writeFileAtomic(target, data, deps = DEFAULT_WRITE_DEPS) {
 async function ensureVaultMarker(dir, deps = DEFAULT_WRITE_DEPS) {
   const marker = vaultMarkerFile(dir);
   try {
-    await stat16(marker);
+    await stat22(marker);
     return;
   } catch {
   }
@@ -11946,7 +13934,7 @@ async function ensureVaultMarker(dir, deps = DEFAULT_WRITE_DEPS) {
 }
 async function assetPresent(file, size) {
   try {
-    const info = await stat16(file);
+    const info = await stat22(file);
     return info.isFile() && info.size === size;
   } catch {
     return false;
@@ -11988,7 +13976,7 @@ var RemoteDevicesStore = class {
   async load() {
     let raw;
     try {
-      raw = await readFile10(this.filePath, "utf8");
+      raw = await readFile12(this.filePath, "utf8");
     } catch {
       return [];
     }
@@ -12009,7 +13997,7 @@ var RemoteDevicesStore = class {
   save(devices) {
     const text = serializeRemoteDevices(devices);
     const run = async () => {
-      await mkdir6(path33.dirname(this.filePath), { recursive: true });
+      await mkdir6(path41.dirname(this.filePath), { recursive: true });
       await writeFileAtomic(this.filePath, text);
       await chmod(this.filePath, 384).catch(() => void 0);
     };
@@ -12028,7 +14016,7 @@ var RemoteDevicesStore = class {
    */
   async stamp() {
     try {
-      const info = await stat17(this.filePath);
+      const info = await stat23(this.filePath);
       return `${info.mtimeMs}:${info.size}`;
     } catch {
       return "";
@@ -12142,8 +14130,8 @@ import chokidar from "chokidar";
 
 // packages/server/src/git-repo.ts
 import { execFile as execFile4 } from "node:child_process";
-import { readFile as readFile11 } from "node:fs/promises";
-import path34 from "node:path";
+import { readFile as readFile13 } from "node:fs/promises";
+import path42 from "node:path";
 function gitOutputText(output, command) {
   return output.length > 0 ? serverText("raw", { text: output }) : serverText("gitCommandFailed", { command });
 }
@@ -12204,7 +14192,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: path34.resolve(root), message: null };
+    if (root.length > 0) return { state: "ready", root: path42.resolve(root), message: null };
   }
   const stderr = result.stderr.trim();
   if (/not a git repository|no es un repositorio/i.test(stderr)) {
@@ -12231,7 +14219,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 ? path34.resolve(dir) : null;
+  return dir.length > 0 ? path42.resolve(dir) : null;
 }
 function letterToKind(letter) {
   switch (letter) {
@@ -12334,7 +14322,7 @@ function parseWorktrees(raw, currentRoot) {
     worktrees.push({
       path: current.path,
       branch: current.branch,
-      isCurrent: path34.resolve(current.path) === path34.resolve(currentRoot)
+      isCurrent: path42.resolve(current.path) === path42.resolve(currentRoot)
     });
     current = null;
   };
@@ -12477,7 +14465,7 @@ function looksBinary(buffer) {
 async function readUntrackedAsDiff(absolutePath, relativePath) {
   let content;
   try {
-    content = await readFile11(absolutePath);
+    content = await readFile13(absolutePath);
   } catch {
     return {
       path: relativePath,
@@ -12525,7 +14513,7 @@ async function readUntrackedAsDiff(absolutePath, relativePath) {
 async function readDiff(options) {
   const { repoRoot: repoRoot2, relativePath, staged, untracked } = options;
   if (untracked && !staged) {
-    return readUntrackedAsDiff(path34.join(repoRoot2, relativePath), relativePath);
+    return readUntrackedAsDiff(path42.join(repoRoot2, relativePath), relativePath);
   }
   const args = [
     "diff",
@@ -12744,8 +14732,8 @@ var RepoHub = class extends EventEmitter2 {
 
 // packages/server/src/memory-hub.ts
 import { EventEmitter as EventEmitter3 } from "node:events";
-import { homedir as homedir10 } from "node:os";
-import path36 from "node:path";
+import { homedir as homedir12 } from "node:os";
+import path44 from "node:path";
 import chokidar2 from "chokidar";
 
 // packages/server/src/memory-bridge.ts
@@ -12753,16 +14741,16 @@ import { execFile as execFile5 } from "node:child_process";
 import { randomBytes as randomBytes4 } from "node:crypto";
 import {
   mkdir as mkdir7,
-  open as open6,
-  readdir as readdir9,
-  readFile as readFile12,
-  realpath as realpath2,
+  open as open7,
+  readdir as readdir11,
+  readFile as readFile14,
+  realpath as realpath3,
   rename as rename4,
-  stat as stat18,
+  stat as stat24,
   unlink as unlink3
 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
-import path35 from "node:path";
+import { homedir as homedir11 } from "node:os";
+import path43 from "node:path";
 var MemoryBridgeError = class extends ServerTextError {
 };
 var MAX_LISTED_NOTES = 500;
@@ -12778,11 +14766,11 @@ var GITIGNORE_REL = ".gitignore";
 var GITIGNORE_COMMENT = "# Memoria compartida de los agentes (Agent Workbench)";
 var GITIGNORE_MEMORY_LINE = `${MEMORY_DIR}/`;
 var BOM2 = Buffer.from([239, 187, 191]);
-async function inspectMemory(cwd, home = homedir9()) {
+async function inspectMemory(cwd, home = homedir11()) {
   await assertMemoryDirInside(cwd);
-  const folder = path35.join(cwd, MEMORY_DIR);
+  const folder = path43.join(cwd, MEMORY_DIR);
   const folderExists = await isDirectory2(folder);
-  const indexExists = folderExists && await isFile(path35.join(folder, MEMORY_INDEX_FILE));
+  const indexExists = folderExists && await isFile(path43.join(folder, MEMORY_INDEX_FILE));
   const noteNames = folderExists ? await listNoteFiles(folder) : [];
   const notes = await describeNotes(folder, noteNames);
   const files = await Promise.all(
@@ -12803,18 +14791,18 @@ async function inspectMemory(cwd, home = homedir9()) {
     globalFragments: buildGlobalFragments(home)
   };
 }
-async function planMemoryInstall(cwd, options, home = homedir9()) {
+async function planMemoryInstall(cwd, options, home = homedir11()) {
   const plan = await buildInstallPlan(cwd, options, home);
   return plan.changes();
 }
-async function installMemory(cwd, options, home = homedir9()) {
+async function installMemory(cwd, options, home = homedir11()) {
   const plan = await buildInstallPlan(cwd, options, home);
   await plan.apply();
   return plan.changes();
 }
-async function importNativeMemory(cwd, home = homedir9()) {
+async function importNativeMemory(cwd, home = homedir11()) {
   await assertMemoryDirInside(cwd);
-  if (!await isDirectory2(path35.join(cwd, MEMORY_DIR))) {
+  if (!await isDirectory2(path43.join(cwd, MEMORY_DIR))) {
     throw new MemoryBridgeError(serverText("memoryNotInstalled"));
   }
   const plan = new PlanBuilder(cwd);
@@ -12832,9 +14820,9 @@ async function readMemoryNote(cwd, name) {
   }
   const absolute = await resolveInside(cwd, `${MEMORY_DIR}/${name}`);
   try {
-    const info = await stat18(absolute);
+    const info = await stat24(absolute);
     if (!info.isFile()) return null;
-    const content = await readFile12(absolute);
+    const content = await readFile14(absolute);
     return {
       name,
       text: content.subarray(0, MAX_NOTE_BYTES).toString("utf8"),
@@ -12849,7 +14837,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 (path35.basename(name) !== name) return false;
+  if (path43.basename(name) !== name) return false;
   if (/[\\/:*?"<>|\u0000-\u001f]/.test(name)) return false;
   return name.toLowerCase().endsWith(".md");
 }
@@ -12886,7 +14874,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(path35.join(this.cwd, MEMORY_DIR))) {
+    for (const name of await listNoteFiles(path43.join(this.cwd, MEMORY_DIR))) {
       names.set(name.toLowerCase(), name);
     }
     for (const rel of this.files.keys()) {
@@ -12928,8 +14916,8 @@ var PlanBuilder = class {
         file.target = absolute;
         continue;
       }
-      const target = await realpath2(absolute);
-      const info = await stat18(target);
+      const target = await realpath3(absolute);
+      const info = await stat24(target);
       if (info.nlink > 1) {
         throw new MemoryBridgeError(serverText("memoryHardLinks", { file: file.rel }));
       }
@@ -12948,7 +14936,7 @@ var PlanBuilder = class {
     );
     if (pending.length === 0) return;
     if (pending.some((file) => file.rel.startsWith(`${MEMORY_DIR}/`))) {
-      await mkdir7(path35.join(this.cwd, MEMORY_DIR), { recursive: true });
+      await mkdir7(path43.join(this.cwd, MEMORY_DIR), { recursive: true });
     }
     for (const file of pending) {
       if (file.target === null) throw new Error(`Unvalidated plan: ${file.rel}`);
@@ -13059,7 +15047,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(path35.join(folder, name), name);
+      const content = await readIfFile(path43.join(folder, name), name);
       if (content === null) continue;
       const already = chosen.get(key);
       if (already !== void 0) {
@@ -13073,7 +15061,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", "", path35.join(folder, name));
+      plan.put(`${MEMORY_DIR}/${name}`, null, content, "copy", "", path43.join(folder, name));
       copied.push(name);
     }
   }
@@ -13083,7 +15071,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(path35.join(folder, MEMORY_INDEX_FILE), MEMORY_INDEX_FILE);
+      const nativeIndex = await readIfFile(path43.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];
@@ -13158,9 +15146,9 @@ function findMarkers(content, lines, ignoredFences) {
       }
       continue;
     }
-    const open8 = FENCE_OPEN.exec(text);
-    const opening = open8?.[1];
-    if (opening !== void 0 && !ignoredFences.has(index) && !(opening[0] === "`" && (open8?.[2] ?? "").includes("`"))) {
+    const open9 = FENCE_OPEN.exec(text);
+    const opening = open9?.[1];
+    if (opening !== void 0 && !ignoredFences.has(index) && !(opening[0] === "`" && (open9?.[2] ?? "").includes("`"))) {
       fence = { line: index, char: opening[0] ?? "`", length: opening.length };
       continue;
     }
@@ -13301,14 +15289,18 @@ function computeReach(folderExists, indexExists, files) {
     ),
     entry("codex", agentsHasBlock, viaAgents),
     entry("antigravity", agentsHasBlock, viaAgents),
-    entry("opencode", openCode.reaches, openCode.via)
+    entry("opencode", openCode.reaches, openCode.via),
+    // Pi busca igual que OpenCode: `AGENTS.md`, y `CLAUDE.md` solo si el primero no
+    // esta (medido que con los dos carga solo el primero; el respaldo, segun su
+    // documentacion, §16.11).
+    entry("pi", openCode.reaches, openCode.via)
   ];
 }
 async function describeNotes(folder, names) {
   const stated = [];
   for (const name of names) {
     try {
-      const info = await stat18(path35.join(folder, name));
+      const info = await stat24(path43.join(folder, name));
       if (info.isFile()) stated.push({ name, sizeBytes: info.size, modifiedAt: info.mtimeMs });
     } catch {
     }
@@ -13316,7 +15308,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(path35.join(folder, item.name));
+    const head = await readHead(path43.join(folder, item.name));
     notes.push({ ...item, ...describeNoteText(head, item.name) });
   }
   return notes;
@@ -13374,28 +15366,29 @@ async function countNativeMemory(cwd, home, sharedNames) {
   return { available: names.size, pending };
 }
 async function nativeMemoryFolders(cwd, home) {
-  const root = path35.join(home, ".claude", "projects");
+  const root = path43.join(home, ".claude", "projects");
   const slug = projectSlugFor(cwd).toLowerCase();
   try {
-    const entries = await readdir9(root, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory() && entry.name.toLowerCase() === slug).map((entry) => entry.name).sort().map((name) => path35.join(root, name, "memory"));
+    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"));
   } catch {
     return [];
   }
 }
 function buildGlobalFragments(home) {
   const windows = process.platform === "win32";
-  const globalFile = path35.join(home, ...GLOBAL_MEMORY_RELATIVE.split("/"));
+  const globalFile = path43.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 = path35.join(home, ".codex", "AGENTS.md");
-  const geminiTarget = path35.join(home, ".gemini", "GEMINI.md");
+  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 homeSlashes = home.replace(/\\/g, "/").replace(/\/+$/, "");
   return [
     {
       agent: "claude-code",
       label: MEMORY_AGENT_LABELS["claude-code"],
-      target: path35.join(home, ".claude", "CLAUDE.md"),
+      target: path43.join(home, ".claude", "CLAUDE.md"),
       kind: "line",
       text: `@~/${GLOBAL_MEMORY_RELATIVE}`,
       note: serverText("memoryNoteClaude")
@@ -13419,10 +15412,18 @@ function buildGlobalFragments(home) {
     {
       agent: "opencode",
       label: MEMORY_AGENT_LABELS.opencode,
-      target: path35.join(home, ".config", "opencode", "opencode.json"),
+      target: path43.join(home, ".config", "opencode", "opencode.json"),
       kind: "json",
       text: `"instructions": ["${homeSlashes}/${GLOBAL_MEMORY_RELATIVE}"]`,
       note: serverText("memoryNoteOpenCode")
+    },
+    {
+      agent: "pi",
+      label: MEMORY_AGENT_LABELS.pi,
+      target: piTarget,
+      kind: "command",
+      text: hardLink(piTarget),
+      note: hardLinkNote
     }
   ];
 }
@@ -13467,17 +15468,17 @@ async function readGit(cwd) {
   if (!toplevel || !gitDir || !commonDir) return fail(serverText("gitUnexpected", { command: "rev-parse" }));
   const ignored = await checkIgnored(cwd, INDEX_REL);
   if (typeof ignored !== "boolean") return fail(ignored);
-  const absoluteGitDir = path35.resolve(cwd, gitDir);
-  const absoluteCommonDir = path35.resolve(cwd, commonDir);
+  const absoluteGitDir = path43.resolve(cwd, gitDir);
+  const absoluteCommonDir = path43.resolve(cwd, commonDir);
   let worktree = null;
   let main2 = null;
   if (!await samePath(absoluteGitDir, absoluteCommonDir)) {
-    if (path35.basename(absoluteCommonDir).toLowerCase() === ".git") {
-      const mainRoot = path35.dirname(absoluteCommonDir);
-      const inner = path35.relative(path35.resolve(toplevel), path35.resolve(cwd));
-      const sameFolder = inner.length === 0 || inner.startsWith("..") || path35.isAbsolute(inner);
-      const mainPath = sameFolder ? mainRoot : path35.join(mainRoot, inner);
-      const memoryRel = sameFolder ? MEMORY_DIR : [...inner.split(path35.sep), MEMORY_DIR].join("/");
+    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("/");
       main2 = { root: mainRoot, memoryRel };
       worktree = {
         mainPath,
@@ -13500,9 +15501,9 @@ async function checkIgnored(cwd, rel) {
 async function samePath(a, b) {
   const resolve = async (value) => {
     try {
-      return await realpath2(value);
+      return await realpath3(value);
     } catch {
-      return path35.resolve(value);
+      return path43.resolve(value);
     }
   };
   const [left, right] = await Promise.all([resolve(a), resolve(b)]);
@@ -13534,7 +15535,7 @@ async function existingInside(root, rel, kind) {
 }
 async function listNoteFiles(folder) {
   try {
-    const entries = await readdir9(folder, { withFileTypes: true });
+    const entries = await readdir11(folder, { withFileTypes: true });
     return entries.filter(
       (entry) => entry.isFile() && isNoteName(entry.name) && entry.name.toLowerCase() !== MEMORY_INDEX_FILE.toLowerCase()
     ).map((entry) => entry.name).sort();
@@ -13544,9 +15545,9 @@ async function listNoteFiles(folder) {
 }
 async function readIfFile(absolute, label) {
   try {
-    const info = await stat18(absolute);
+    const info = await stat24(absolute);
     if (!info.isFile()) throw new MemoryBridgeError(serverText("memoryNotAFile", { label }));
-    return await readFile12(absolute);
+    return await readFile14(absolute);
   } catch (error) {
     if (isNotFound(error)) return null;
     throw error;
@@ -13554,7 +15555,7 @@ async function readIfFile(absolute, label) {
 }
 async function readHead(absolute) {
   try {
-    const handle = await open6(absolute, "r");
+    const handle = await open7(absolute, "r");
     try {
       const buffer = Buffer.alloc(NOTE_HEAD_BYTES);
       const { bytesRead } = await handle.read(buffer, 0, NOTE_HEAD_BYTES, 0);
@@ -13568,14 +15569,14 @@ async function readHead(absolute) {
 }
 async function isFile(absolute) {
   try {
-    return (await stat18(absolute)).isFile();
+    return (await stat24(absolute)).isFile();
   } catch {
     return false;
   }
 }
 async function isDirectory2(absolute) {
   try {
-    return (await stat18(absolute)).isDirectory();
+    return (await stat24(absolute)).isDirectory();
   } catch {
     return false;
   }
@@ -13593,7 +15594,7 @@ async function writeAtomic(target, content, mustNotExist) {
       await handle.close();
     }
     if (mustNotExist && await exists2(target)) {
-      throw new MemoryBridgeError(serverText("memoryAppeared", { file: path35.basename(target) }));
+      throw new MemoryBridgeError(serverText("memoryAppeared", { file: path43.basename(target) }));
     }
     await renameWithRetry(temporary, target);
   } catch (error) {
@@ -13604,12 +15605,12 @@ async function writeAtomic(target, content, mustNotExist) {
 async function createTemporary(target) {
   for (let attempt = 1; ; attempt += 1) {
     const suffix = randomBytes4(6).toString("hex");
-    const temporary = path35.join(
-      path35.dirname(target),
-      `.${path35.basename(target)}.${process.pid}.${suffix}.tmp`
+    const temporary = path43.join(
+      path43.dirname(target),
+      `.${path43.basename(target)}.${process.pid}.${suffix}.tmp`
     );
     try {
-      return { temporary, handle: await open6(temporary, "wx") };
+      return { temporary, handle: await open7(temporary, "wx") };
     } catch (error) {
       const code = error.code;
       if (code !== "EEXIST" || attempt >= TEMPORARY_ATTEMPTS) throw error;
@@ -13618,7 +15619,7 @@ async function createTemporary(target) {
 }
 async function exists2(absolute) {
   try {
-    await stat18(absolute);
+    await stat24(absolute);
     return true;
   } catch {
     return false;
@@ -13648,7 +15649,7 @@ var UnknownTerminalError = class extends Error {
 };
 var MemoryHub = class extends EventEmitter3 {
   /** `home` es inyectable por lo mismo que en el puente: probar sin tocar el real. */
-  constructor(registry, home = homedir10()) {
+  constructor(registry, home = homedir12()) {
     super();
     this.registry = registry;
     this.home = home;
@@ -13844,13 +15845,13 @@ var MemoryHub = class extends EventEmitter3 {
   }
 };
 function keyFor(cwd) {
-  const resolved = path36.resolve(cwd);
+  const resolved = path44.resolve(cwd);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function isRelevantPath(cwd, candidate) {
-  const relative = path36.relative(cwd, candidate);
+  const relative = path44.relative(cwd, candidate);
   if (relative.length === 0) return true;
-  if (relative.startsWith("..") || path36.isAbsolute(relative)) return false;
+  if (relative.startsWith("..") || path44.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;
@@ -13868,8 +15869,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 readdir10, rm as rm3, stat as stat19, writeFile as writeFile4 } from "node:fs/promises";
-import path37 from "node:path";
+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";
 
 // packages/server/src/vault/markdown.ts
 var pad2 = (value) => String(value).padStart(2, "0");
@@ -13960,10 +15961,10 @@ ${fenced(part.input)}`;
       return `> ${sentence(noticeText(part))}`;
   }
 }
-function renderEvent(event, images, previousDay, options) {
+function renderEvent(event2, images, previousDay, options) {
   const blocks = [];
   let imageNumber = 0;
-  for (const part of event.parts) {
+  for (const part of event2.parts) {
     let image;
     if (part.kind === "image") {
       image = images[imageNumber];
@@ -13973,17 +15974,17 @@ function renderEvent(event, images, previousDay, options) {
     if (rendered !== null) blocks.push(rendered);
   }
   if (blocks.length === 0) return null;
-  const day = event.at > 0 ? formatLocalDay(event.at) : null;
-  const heading = [event.role === "user" ? "Usuario" : "Asistente"];
+  const day = event2.at > 0 ? formatLocalDay(event2.at) : null;
+  const heading = [event2.role === "user" ? "Usuario" : "Asistente"];
   if (day !== null) {
-    heading.push(event.role === "user" || day !== previousDay ? formatLocalDateTime(event.at) : formatTime(event.at));
+    heading.push(event2.role === "user" || day !== previousDay ? formatLocalDateTime(event2.at) : formatTime(event2.at));
   }
-  if (event.role === "assistant") {
-    if (event.model !== null && event.model.length > 0) heading.push(event.model);
-    if (event.effort !== null && event.effort.length > 0) heading.push(event.effort);
-    if (event.durationMs !== null) heading.push(formatDuration(event.durationMs));
+  if (event2.role === "assistant") {
+    if (event2.model !== null && event2.model.length > 0) heading.push(event2.model);
+    if (event2.effort !== null && event2.effort.length > 0) heading.push(event2.effort);
+    if (event2.durationMs !== null) heading.push(formatDuration(event2.durationMs));
   }
-  if (event.queued) heading.push("enviado mientras trabajaba");
+  if (event2.queued) heading.push("enviado mientras trabajaba");
   return { text: `## ${heading.join(" \xB7 ")}
 
 ${blocks.join("\n\n")}`, day: day ?? previousDay };
@@ -14075,17 +16076,17 @@ var QUESTION_LABEL_CHARS = 200;
 var TEXT_CHAR_STEPS = [4e3, 2e3, 1e3, 500, 250];
 var HANDOFF_EMPTY_TEXT = serverText("handoffEmpty");
 var HANDOFF_NO_TRANSCRIPT_TEXT = serverText("handoffNoTranscript");
-function opensTurn(event) {
-  return event.role === "user" && event.parts.some((part) => part.kind === "text" && part.text.trim().length > 0);
+function opensTurn(event2) {
+  return event2.role === "user" && event2.parts.some((part) => part.kind === "text" && part.text.trim().length > 0);
 }
 function splitTurns(events) {
   const turns = [];
-  for (const event of events) {
-    if (opensTurn(event)) {
-      turns.push({ number: turns.length + 1, events: [event] });
+  for (const event2 of events) {
+    if (opensTurn(event2)) {
+      turns.push({ number: turns.length + 1, events: [event2] });
       continue;
     }
-    turns.at(-1)?.events.push(event);
+    turns.at(-1)?.events.push(event2);
   }
   return turns;
 }
@@ -14172,9 +16173,9 @@ function renderQuestionLine(part, result) {
   const answer = `"${cut2 ? `${text}\u2026` : text}"`;
   return `${title}: ${result.isError ? "not answered" : "answered"} ${answer}`;
 }
-function renderRequestBody(event, textChars) {
+function renderRequestBody(event2, textChars) {
   const blocks = [];
-  for (const part of event.parts) {
+  for (const part of event2.parts) {
     if (part.kind === "text") {
       const text = renderText(part.text, part.truncated, textChars);
       if (text !== null) blocks.push(text);
@@ -14189,8 +16190,8 @@ function renderTurn(turn, textChars) {
   if (request === void 0) return `## Turn ${turn.number} \xB7 user`;
   const results = /* @__PURE__ */ new Map();
   const calls = /* @__PURE__ */ new Set();
-  for (const event of turn.events) {
-    for (const part of event.parts) {
+  for (const event2 of turn.events) {
+    for (const part of event2.parts) {
       if (part.kind === "tool-result" && !results.has(part.toolUseId)) results.set(part.toolUseId, part);
       if (part.kind === "tool-call" || part.kind === "question") calls.add(part.toolUseId);
     }
@@ -14209,7 +16210,7 @@ ${line}`;
     answer.push(text);
     listOpen = false;
   };
-  const renderAnswerPart = (event, part) => {
+  const renderAnswerPart = (event2, part) => {
     switch (part.kind) {
       case "text": {
         const text = renderText(part.text, part.truncated, textChars);
@@ -14226,7 +16227,7 @@ ${line}`;
         if (!calls.has(part.toolUseId)) pushLine(`- Result of an earlier tool call \u2192 ${renderResult(part)}`);
         return;
       case "image":
-        pushLine(event.role === "user" ? `- ${imagesText(1)} (from the user)` : `- ${imagesText(1)}`);
+        pushLine(event2.role === "user" ? `- ${imagesText(1)} (from the user)` : `- ${imagesText(1)}`);
         return;
       case "notice":
         pushLine(`- Notice: ${oneLine2(noticeLine(part))}`);
@@ -14238,8 +16239,8 @@ ${line}`;
   for (const part of request.parts) {
     if (part.kind !== "text" && part.kind !== "image") renderAnswerPart(request, part);
   }
-  for (const event of rest) {
-    for (const part of event.parts) renderAnswerPart(event, part);
+  for (const event2 of rest) {
+    for (const part of event2.parts) renderAnswerPart(event2, part);
   }
   const blocks = [userBlocks.join("\n\n")];
   if (answer.length > 0) blocks.push([`## Turn ${turn.number} \xB7 assistant`, ...answer].join("\n\n"));
@@ -14384,8 +16385,8 @@ function buildContinuationMessage(input) {
   }
   return sanitizeForPaste(lines.join("\n"));
 }
-function transcriptReferenceFor(path52, style) {
-  return style === "at-quoted" ? fileReference(path52, "at-quoted") : `"${path52}"`;
+function transcriptReferenceFor(path60, style) {
+  return style === "at-quoted" ? fileReference(path60, "at-quoted") : `"${path60}"`;
 }
 function planTranscript(input) {
   const turns = splitTurns(input.events);
@@ -14561,11 +16562,11 @@ var PasteStore = class {
     if (signature === null) {
       throw new PasteImageError(serverText("imageUnknownFormat"));
     }
-    const directory = path37.join(this.root, safeSegment(terminalId));
+    const directory = path45.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 = path37.join(directory, name);
+    const file = path45.join(directory, name);
     await writeFile4(file, bytes, { mode: FILE_MODE });
     return { path: file, bytes: bytes.length };
   }
@@ -14583,11 +16584,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 = path37.join(this.root, safeSegment(terminalId));
+    const directory = path45.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 = path37.join(directory, name);
+    const file = path45.join(directory, name);
     await writeFile4(file, bytes, { mode: FILE_MODE });
     return { path: file, bytes: bytes.length };
   }
@@ -14617,17 +16618,17 @@ var PasteStore = class {
         })
       );
     }
-    const directory = path37.join(this.root, safeSegment(terminalId));
+    const directory = path45.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 = path37.join(directory, name);
+    const file = path45.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(path37.join(this.root, safeSegment(terminalId)), {
+    await rm3(path45.join(this.root, safeSegment(terminalId)), {
       recursive: true,
       force: true
     }).catch(() => {
@@ -14643,15 +16644,15 @@ var PasteStore = class {
   async purgeStale(now = Date.now()) {
     let entries;
     try {
-      entries = await readdir10(this.root);
+      entries = await readdir12(this.root);
     } catch {
       return;
     }
     await Promise.all(
       entries.map(async (entry) => {
-        const full = path37.join(this.root, entry);
+        const full = path45.join(this.root, entry);
         try {
-          const info = await stat19(full);
+          const info = await stat25(full);
           if (now - info.mtimeMs > STALE_AFTER_MS) {
             await rm3(full, { recursive: true, force: true });
           }
@@ -14668,8 +16669,8 @@ function safeSegment(value) {
 
 // packages/server/src/session-index.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
-import { mkdir as mkdir9, readFile as readFile13, stat as stat20, writeFile as writeFile5 } from "node:fs/promises";
-import path38 from "node:path";
+import { mkdir as mkdir9, readFile as readFile15, stat as stat26, writeFile as writeFile5 } from "node:fs/promises";
+import path46 from "node:path";
 var CACHE_VERSION = 4;
 var vaultPairKey = (agent, sessionId) => `${agent}/${sessionId}`;
 function vaultOnlySessions(natives, vault, listState, ready) {
@@ -14721,7 +16722,7 @@ function cacheKey(agent, ref) {
 }
 async function pathExists3(candidate) {
   try {
-    await stat20(candidate);
+    await stat26(candidate);
     return true;
   } catch {
     return false;
@@ -14771,7 +16772,7 @@ function migrateEntryV3(filePath, value) {
   return {
     agent: "claude-code",
     ref: filePath,
-    group: path38.basename(path38.dirname(filePath)),
+    group: path46.basename(path46.dirname(filePath)),
     mtimeMs,
     sizeBytes,
     cwd,
@@ -15036,7 +17037,7 @@ var SessionIndex = class extends EventEmitter4 {
   }
   async loadCache() {
     try {
-      const raw = await readFile13(sessionIndexCachePath(), "utf8");
+      const raw = await readFile15(sessionIndexCachePath(), "utf8");
       const parsed = JSON.parse(raw);
       const migrated = migrateIndexCache(parsed);
       if (migrated === null) return;
@@ -15264,8 +17265,8 @@ var SessionIndex = class extends EventEmitter4 {
 };
 
 // packages/server/src/settings-store.ts
-import { mkdir as mkdir10, readFile as readFile14, stat as stat21 } from "node:fs/promises";
-import path39 from "node:path";
+import { mkdir as mkdir10, readFile as readFile16, stat as stat27 } from "node:fs/promises";
+import path47 from "node:path";
 var SETTINGS_VERSION = 1;
 var VAULT_TOOL_RESULT_DEFAULT_CHARS = 64e3;
 var VAULT_TOOL_RESULT_MIN_CHARS = 4e3;
@@ -15282,7 +17283,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 path39.posix.isAbsolute(dir);
+  return path47.posix.isAbsolute(dir);
 }
 function clampToolResultMaxChars(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return VAULT_TOOL_RESULT_DEFAULT_CHARS;
@@ -15341,7 +17342,7 @@ var SettingsStore = class {
   async load() {
     let raw;
     try {
-      raw = await readFile14(this.filePath, "utf8");
+      raw = await readFile16(this.filePath, "utf8");
     } catch {
       this.current = frozen(defaultAppSettings());
       return;
@@ -15369,7 +17370,7 @@ var SettingsStore = class {
   async reloadRemote() {
     let parsed;
     try {
-      parsed = JSON.parse(await readFile14(this.filePath, "utf8"));
+      parsed = JSON.parse(await readFile16(this.filePath, "utf8"));
     } catch {
       return;
     }
@@ -15380,7 +17381,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 stat21(this.filePath);
+      const info = await stat27(this.filePath);
       return `${info.mtimeMs}:${info.size}`;
     } catch {
       return "";
@@ -15424,7 +17425,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(path39.dirname(this.filePath), { recursive: true });
+      await mkdir10(path47.dirname(this.filePath), { recursive: true });
       await writeFileAtomic(this.filePath, `${JSON.stringify(next, null, 2)}
 `);
       this.current = frozen(next);
@@ -15512,8 +17513,8 @@ function supportStartupLineColored() {
 
 // packages/server/src/notes-store.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { mkdir as mkdir11, readFile as readFile15, rename as rename5, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
-import path40 from "node:path";
+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";
 var STATE_VERSION2 = 1;
 var WRITE_DEBOUNCE_MS2 = 500;
 var NotesError = class extends ServerTextError {
@@ -15556,7 +17557,7 @@ var NotesStore = class {
   }
   async load() {
     try {
-      const raw = await readFile15(this.statePath, "utf8");
+      const raw = await readFile17(this.statePath, "utf8");
       this.notes = parseState2(raw) ?? [];
     } catch {
       this.notes = [];
@@ -15673,7 +17674,7 @@ var NotesStore = class {
     const image = this.findImage(imageId);
     if (image === null) return null;
     try {
-      const bytes = await readFile15(this.imagePath(image));
+      const bytes = await readFile17(this.imagePath(image));
       return { mediaType: image.mediaType, data: bytes.toString("base64") };
     } catch {
       return null;
@@ -15693,7 +17694,7 @@ var NotesStore = class {
     const images = [];
     for (const image of note.images) {
       try {
-        const bytes = await readFile15(this.imagePath(image));
+        const bytes = await readFile17(this.imagePath(image));
         images.push({ mediaType: image.mediaType, data: bytes.toString("base64") });
       } catch {
       }
@@ -15717,7 +17718,7 @@ var NotesStore = class {
   }
   imagePath(image) {
     const safe = image.imageId.replace(/[^a-zA-Z0-9-]/g, "");
-    return path40.join(this.imagesDir, `${safe}.${extensionFor(image.mediaType)}`);
+    return path48.join(this.imagesDir, `${safe}.${extensionFor(image.mediaType)}`);
   }
   async unlinkImage(image) {
     await rm4(this.imagePath(image), { force: true }).catch(() => {
@@ -15735,8 +17736,8 @@ var NotesStore = class {
   async writeNow() {
     this.dirty = false;
     try {
-      await mkdir11(path40.dirname(this.statePath), { recursive: true });
-      const temporary = path40.join(path40.dirname(this.statePath), `notes.${process.pid}.tmp`);
+      await mkdir11(path48.dirname(this.statePath), { recursive: true });
+      const temporary = path48.join(path48.dirname(this.statePath), `notes.${process.pid}.tmp`);
       await writeFile6(
         temporary,
         JSON.stringify({ version: STATE_VERSION2, notes: this.notes }, null, 2),
@@ -15750,11 +17751,14 @@ var NotesStore = class {
 };
 
 // packages/server/src/draft-store.ts
-import { mkdir as mkdir12, readFile as readFile16, rename as rename6, writeFile as writeFile7 } from "node:fs/promises";
-import path41 from "node:path";
+import { mkdir as mkdir12, readFile as readFile18, rename as rename6, writeFile as writeFile7 } from "node:fs/promises";
+import path49 from "node:path";
 var STATE_VERSION3 = 1;
 var WRITE_DEBOUNCE_MS3 = 500;
 var MAX_STORED_DRAFTS = 100;
+function submitClearsDraft(message) {
+  return message.keepDraft !== true;
+}
 function draftOwnerOf(descriptor) {
   if (descriptor === null || descriptor.kind !== "agent" || descriptor.agent === null) return null;
   if (descriptor.sessionId.length === 0) return null;
@@ -15854,7 +17858,7 @@ var DraftStore = class {
   }
   async load() {
     try {
-      this.drafts = parseState3(await readFile16(this.statePath, "utf8"));
+      this.drafts = parseState3(await readFile18(this.statePath, "utf8"));
     } catch {
       this.drafts = /* @__PURE__ */ new Map();
     }
@@ -15945,7 +17949,7 @@ var DraftStore = class {
   async writeNow() {
     let onDisk = /* @__PURE__ */ new Map();
     try {
-      onDisk = parseState3(await readFile16(this.statePath, "utf8"));
+      onDisk = parseState3(await readFile18(this.statePath, "utf8"));
     } catch {
     }
     const changed = this.changed;
@@ -15959,8 +17963,8 @@ var DraftStore = class {
     trimOldest(merged);
     this.drafts = new Map(merged);
     try {
-      await mkdir12(path41.dirname(this.statePath), { recursive: true });
-      const temporary = path41.join(path41.dirname(this.statePath), `composer-drafts.${process.pid}.tmp`);
+      await mkdir12(path49.dirname(this.statePath), { recursive: true });
+      const temporary = path49.join(path49.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 }))
@@ -15977,7 +17981,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 path42 from "node:path";
+import path50 from "node:path";
 async function isExecutable(candidate) {
   try {
     await access2(candidate, process.platform === "win32" ? fsConstants2.R_OK : fsConstants2.X_OK);
@@ -15995,21 +17999,21 @@ var SYSTEM_PROBE = {
 function windowsPowerShellPath(env) {
   const systemRoot = env["SystemRoot"] ?? env["windir"];
   if (systemRoot === void 0 || systemRoot.length === 0) return null;
-  return path42.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  return path50.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
 }
 function gitBashCandidates(gitPath, env) {
   const candidates = [];
   if (gitPath !== null) {
-    let dir = path42.win32.dirname(gitPath);
+    let dir = path50.win32.dirname(gitPath);
     for (let level = 0; level < 3; level++) {
-      candidates.push(path42.win32.join(dir, "bin", "bash.exe"));
-      const parent = path42.win32.dirname(dir);
+      candidates.push(path50.win32.join(dir, "bin", "bash.exe"));
+      const parent = path50.win32.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
   }
-  for (const base of [env["ProgramFiles"], env["LOCALAPPDATA"] === void 0 ? void 0 : path42.win32.join(env["LOCALAPPDATA"], "Programs")]) {
-    if (base !== void 0 && base.length > 0) candidates.push(path42.win32.join(base, "Git", "bin", "bash.exe"));
+  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"));
   }
   const systemRoot = (env["SystemRoot"] ?? env["windir"] ?? "").toLowerCase();
   return [...new Set(candidates)].filter((candidate) => systemRoot.length === 0 || !candidate.toLowerCase().startsWith(systemRoot));
@@ -16040,7 +18044,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 = path42.posix.basename(preferred);
+    const name = path50.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"]]) {
@@ -16112,13 +18116,13 @@ var AppSettingsService = class extends EventEmitter5 {
 };
 
 // packages/server/src/session-watcher.ts
-import { stat as stat22 } from "node:fs/promises";
+import { stat as stat28 } 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 stat22(target)).isDirectory();
+    return (await stat28(target)).isDirectory();
   } catch {
     return false;
   }
@@ -16221,7 +18225,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 stat23 } from "node:fs/promises";
+import { stat as stat29 } from "node:fs/promises";
 
 // packages/server/src/launch-hook-slot.ts
 var LaunchHookSlot = class {
@@ -16483,8 +18487,8 @@ async function resolveLaunchPlan(launch) {
 }
 
 // packages/server/src/workspace-store.ts
-import { mkdir as mkdir13, readFile as readFile17, writeFile as writeFile8 } from "node:fs/promises";
-import path43 from "node:path";
+import { mkdir as mkdir13, readFile as readFile19, writeFile as writeFile8 } from "node:fs/promises";
+import path51 from "node:path";
 var STATE_VERSION4 = 1;
 var WRITE_DEBOUNCE_MS4 = 400;
 var LEGACY_TAB_AGENT = "claude-code";
@@ -16606,7 +18610,7 @@ var WorkspaceStore = class {
   pending = null;
   async load() {
     try {
-      const raw = await readFile17(workspaceStatePath(), "utf8");
+      const raw = await readFile19(workspaceStatePath(), "utf8");
       return parseState4(raw) ?? EMPTY_STATE();
     } catch {
       return EMPTY_STATE();
@@ -16638,7 +18642,7 @@ var WorkspaceStore = class {
     try {
       await mkdir13(appConfigDir(), { recursive: true });
       const target = workspaceStatePath();
-      const temporary = path43.join(path43.dirname(target), `workspace.${process.pid}.tmp`);
+      const temporary = path51.join(path51.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);
@@ -16876,7 +18880,7 @@ var TerminalRegistry = class extends EventEmitter6 {
   async assertDirectory(cwd) {
     let info;
     try {
-      info = await stat23(cwd);
+      info = await stat29(cwd);
     } catch {
       throw new TerminalOpenError("invalid-cwd", serverText("cwdMissing", { cwd }));
     }
@@ -17307,26 +19311,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 readdir11, stat as stat24 } from "node:fs/promises";
-import { homedir as homedir11 } from "node:os";
-import path44 from "node:path";
+import { lstat, mkdir as mkdir14, readdir as readdir13, stat as stat30 } from "node:fs/promises";
+import { homedir as homedir13 } from "node:os";
+import path52 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 = path44.resolve(target);
+  const resolved = path52.resolve(target);
   return dirs.some((dir) => {
-    const protectedDir = path44.resolve(dir);
-    return resolved === protectedDir || resolved.startsWith(protectedDir + path44.sep);
+    const protectedDir = path52.resolve(dir);
+    return resolved === protectedDir || resolved.startsWith(protectedDir + path52.sep);
   });
 }
 async function isListedDirectory(parent, entry, readLink = lstat) {
   if (entry.isDirectory()) return true;
   if (!entry.isSymbolicLink()) return false;
   try {
-    const info = await readLink(path44.join(parent, entry.name));
+    const info = await readLink(path52.join(parent, entry.name));
     return info.isDirectory() && !info.isSymbolicLink();
   } catch {
     return false;
@@ -17334,14 +19338,14 @@ async function isListedDirectory(parent, entry, readLink = lstat) {
 }
 async function listRoots() {
   const roots = [];
-  const home = homedir11();
+  const home = homedir13();
   if (process.platform === "win32") {
     const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
     const found = await Promise.all(
       letters.map(async (letter) => {
         const drive = `${letter}:\\`;
         try {
-          await stat24(drive);
+          await stat30(drive);
           return drive;
         } catch {
           return null;
@@ -17368,7 +19372,7 @@ var DirectoryPickers = class {
     if (this.pickers.size >= MAX_PICKERS) {
       throw new DirectoryPickerError(serverText("pickerTooMany"));
     }
-    const picker = { id: randomUUID6(), current: homedir11(), entries: /* @__PURE__ */ new Set() };
+    const picker = { id: randomUUID6(), current: homedir13(), entries: /* @__PURE__ */ new Set() };
     this.pickers.set(picker.id, picker);
     return this.listing(picker);
   }
@@ -17393,14 +19397,14 @@ var DirectoryPickers = class {
   async enter(pickerId, name) {
     const picker = this.require(pickerId);
     if (name === "..") {
-      const parent = path44.dirname(picker.current);
+      const parent = path52.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 = path44.join(picker.current, name);
+    const target = path52.join(picker.current, name);
     if (isInsideProtected(target, this.protectedDirs)) {
       throw new DirectoryPickerError(serverText("pickerCliFolder"));
     }
@@ -17440,7 +19444,7 @@ var DirectoryPickers = class {
         throw new DirectoryPickerError(serverText("pickerNameChars"));
       }
     }
-    const target = path44.join(picker.current, clean);
+    const target = path52.join(picker.current, clean);
     if (isInsideProtected(target, this.protectedDirs)) {
       throw new DirectoryPickerError(serverText("pickerNoProjectsHere"));
     }
@@ -17476,9 +19480,9 @@ var DirectoryPickers = class {
     let names = [];
     let truncated = false;
     try {
-      const found = await readdir11(picker.current, { withFileTypes: true });
+      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(path44.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(path52.join(picker.current, name), this.protectedDirs)).sort((a, b) => a.localeCompare(b));
       truncated = dirs.length > MAX_ENTRIES;
       names = dirs.slice(0, MAX_ENTRIES);
     } catch {
@@ -17489,15 +19493,15 @@ var DirectoryPickers = class {
       path: picker.current,
       entries: names,
       roots,
-      canGoUp: path44.dirname(picker.current) !== picker.current,
+      canGoUp: path52.dirname(picker.current) !== picker.current,
       truncated
     };
   }
 };
 
 // packages/server/src/file-browser.ts
-import { readFile as readFile18, readdir as readdir12, stat as stat25 } from "node:fs/promises";
-import path45 from "node:path";
+import { readFile as readFile20, readdir as readdir14, stat as stat31 } from "node:fs/promises";
+import path53 from "node:path";
 var MAX_ENTRIES2 = 1e3;
 var SEARCH_MAX_RESULTS = 200;
 var SEARCH_MAX_DIRECTORIES = 4e3;
@@ -17560,7 +19564,7 @@ function languageFor(fileName) {
   const lower = fileName.toLowerCase();
   const byName = LANGUAGE_BY_NAME[lower];
   if (byName !== void 0) return byName;
-  const extension = path45.extname(lower);
+  const extension = path53.extname(lower);
   return LANGUAGE_BY_EXTENSION[extension] ?? null;
 }
 function looksBinary2(buffer) {
@@ -17592,7 +19596,7 @@ async function listDirectory(cwd, relativePath, options = {}) {
     let sizeBytes = 0;
     let modifiedAt = 0;
     try {
-      const info = await stat25(path45.join(absolute, candidate.name));
+      const info = await stat31(path53.join(absolute, candidate.name));
       sizeBytes = candidate.isDirectory ? 0 : info.size;
       modifiedAt = info.mtimeMs;
     } catch {
@@ -17618,14 +19622,14 @@ async function scanLevel(absolute, repoRoot2) {
   return level;
 }
 async function readLevel(absolute) {
-  const dirents = await readdir12(absolute, { withFileTypes: true });
+  const dirents = await readdir14(absolute, { withFileTypes: true });
   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 stat25(path45.join(absolute, dirent.name));
+        const target = await stat31(path53.join(absolute, dirent.name));
         candidates.push({
           name: dirent.name,
           isDirectory: target.isDirectory(),
@@ -17654,7 +19658,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(path45.relative(repoRoot2, path45.join(level.absolute, entry.name))));
+      keys.set(entry, toPosixPath(path53.relative(repoRoot2, path53.join(level.absolute, entry.name))));
     }
   }
   if (keys.size === 0) return;
@@ -17715,7 +19719,7 @@ async function searchFiles(cwd, query, options = {}) {
         let sizeBytes = 0;
         let modifiedAt = 0;
         try {
-          const info = await stat25(path45.join(level.absolute, candidate.name));
+          const info = await stat31(path53.join(level.absolute, candidate.name));
           sizeBytes = candidate.isDirectory ? 0 : info.size;
           modifiedAt = info.mtimeMs;
         } catch {
@@ -17747,14 +19751,25 @@ async function searchFiles(cwd, query, options = {}) {
     truncated: truncated || found.length > SEARCH_MAX_RESULTS
   };
 }
+async function existingFiles(cwd, relativePaths) {
+  const existing = [];
+  for (const relativePath of relativePaths) {
+    try {
+      const absolute = await resolveInside(cwd, relativePath, { mustExist: true });
+      if ((await stat31(absolute)).isFile()) existing.push(relativePath);
+    } catch {
+    }
+  }
+  return existing;
+}
 async function readPreview(cwd, relativePath) {
   const absolute = await resolveInside(cwd, relativePath, { mustExist: true });
-  const info = await stat25(absolute);
+  const info = await stat31(absolute);
   if (info.isDirectory()) {
     throw new Error("It's a directory, not a file.");
   }
-  const content = await readFile18(absolute);
-  const fileName = path45.basename(absolute);
+  const content = await readFile20(absolute);
+  const fileName = path53.basename(absolute);
   if (looksBinary2(content)) {
     return {
       path: relativePath,
@@ -17883,7 +19898,7 @@ async function runGlobalSearch(deps, rawQuery, options) {
     }
     return false;
   };
-  const add = (session, event, text, found) => {
+  const add = (session, event2, text, found) => {
     if (hits.length >= GLOBAL_SEARCH_MAX_RESULTS) {
       truncated = "results";
       return false;
@@ -17893,9 +19908,9 @@ async function runGlobalSearch(deps, rawQuery, options) {
       sessionId: session.sessionId,
       cwd: session.cwd.length > 0 ? session.cwd : null,
       title: session.title,
-      eventId: event?.eventId ?? null,
-      role: event?.role ?? null,
-      at: event !== null && event.at > 0 ? event.at : null,
+      eventId: event2?.eventId ?? null,
+      role: event2?.role ?? null,
+      at: event2 !== null && event2.at > 0 ? event2.at : null,
       ...makeSnippet(text, found.start, found.end)
     });
     return true;
@@ -17918,13 +19933,13 @@ async function runGlobalSearch(deps, rawQuery, options) {
         }
         if (line.length > GLOBAL_SEARCH_LINE_MAX_CHARS) continue;
         if (!lineMayMatch(line, needle, usePrefilter)) continue;
-        const event = decode(line);
-        if (event === null) continue;
-        for (const part of event.parts) {
+        const event2 = decode(line);
+        if (event2 === null) continue;
+        for (const part of event2.parts) {
           if (part.kind !== "text") continue;
           const found = findFolded(part.text, needle);
           if (found === null) continue;
-          if (!add(session, event, part.text, found)) break sessionLoop;
+          if (!add(session, event2, part.text, found)) break sessionLoop;
           break;
         }
       }
@@ -18242,6 +20257,77 @@ async function readEvents(deps, agent, summary) {
   return read === null ? null : { ...read, partial: false };
 }
 
+// packages/server/src/queued-submits.ts
+var SUBMISSIONS_KEPT2 = 20;
+var SUBMISSION_MAX_AGE_MS2 = 30 * 6e4;
+var RECLAIM_TIMEOUT_MS = 4e3;
+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) {
+    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));
+  }
+  /** Se lleva lo anotado de esa pestana. */
+  take(terminalId) {
+    const taken = this.submissions.get(terminalId) ?? [];
+    this.submissions.delete(terminalId);
+    return taken;
+  }
+  /** La pestana quedo libre, sin proceso, o en otra sesion: nada de lo anotado sigue en cola. */
+  forget(terminalId) {
+    this.submissions.delete(terminalId);
+  }
+  /** La pestana se cerro. */
+  drop(terminalId) {
+    this.submissions.delete(terminalId);
+    this.clearKeyAt.delete(terminalId);
+  }
+  /** Paso una tecla de vaciar por la pty de esa pestana: de la app, o tecleada por el usuario. */
+  noteClearKey(terminalId, at) {
+    this.clearKeyAt.set(terminalId, at);
+  }
+  lastClearKeyAt(terminalId) {
+    return this.clearKeyAt.get(terminalId) ?? null;
+  }
+  /** Pestanas con algo anotado. Para el chequeo. */
+  size() {
+    return this.submissions.size;
+  }
+};
+async function reclaimQueuedSubmits(deps) {
+  const submissions = deps.submissions.filter((each) => each.at <= deps.interruptedAt);
+  if (submissions.length === 0) return "nothing";
+  const timeoutMs = deps.timeoutMs ?? RECLAIM_TIMEOUT_MS;
+  const pollMs = deps.pollMs ?? RECLAIM_POLL_MS;
+  const deadline = deps.now() + timeoutMs;
+  let undelivered = [];
+  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) {
+      undelivered = result.undelivered;
+      break;
+    }
+    if (deps.now() >= deadline) return "not-settled";
+    await deps.wait(pollMs);
+  }
+  const last = deps.lastClearKeyAt();
+  if (last !== null) {
+    const remaining = deps.source.clearGapMs - (deps.now() - last);
+    if (remaining > 0) await deps.wait(remaining);
+  }
+  if (deps.target() === null) return "gone";
+  if (!deps.writeClearKey()) return "refused";
+  deps.prefill(undelivered.join("\n\n"));
+  return "reclaimed";
+}
+
 // packages/server/src/reveal.ts
 import { spawn as spawn3 } from "node:child_process";
 function revealPath(absolutePath) {
@@ -18343,14 +20429,14 @@ var TerminalWriteQueue = class {
 };
 
 // packages/server/src/vault/service.ts
-import { mkdir as mkdir17, stat as stat29 } from "node:fs/promises";
-import { homedir as homedir12 } from "node:os";
-import path49 from "node:path";
+import { mkdir as mkdir17, stat as stat35 } from "node:fs/promises";
+import { homedir as homedir14 } from "node:os";
+import path57 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 readdir13, rm as rm5, stat as stat26, utimes, writeFile as writeFile9 } from "node:fs/promises";
-import path46 from "node:path";
+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";
 var MOVED_ENTRIES = ["vault.json", "sessions", "memory"];
 var OWN_TEMP_FILE = /\.\d+\.[0-9a-f]{12}\.tmp$/;
 async function copyTree(source, target, result) {
@@ -18362,13 +20448,13 @@ async function copyTree(source, target, result) {
   }
   if (info.isDirectory()) {
     await mkdir15(target, { recursive: true });
-    for (const name of await readdir13(source)) {
-      await copyTree(path46.join(source, name), path46.join(target, name), result);
+    for (const name of await readdir15(source)) {
+      await copyTree(path54.join(source, name), path54.join(target, name), result);
     }
     return;
   }
   if (!info.isFile() || OWN_TEMP_FILE.test(source)) return;
-  await mkdir15(path46.dirname(target), { recursive: true });
+  await mkdir15(path54.dirname(target), { recursive: true });
   try {
     await copyFile2(source, target, constants.COPYFILE_EXCL);
   } catch (error) {
@@ -18385,7 +20471,7 @@ async function moveVault(from, to) {
   const result = { copied: 0, skipped: 0 };
   await mkdir15(to, { recursive: true });
   for (const entry of MOVED_ENTRIES) {
-    await copyTree(path46.join(from, entry), path46.join(to, entry), result);
+    await copyTree(path54.join(from, entry), path54.join(to, entry), result);
   }
   return result;
 }
@@ -18417,10 +20503,10 @@ function checkVaultTarget(current, target, options) {
   return { kind: "ok" };
 }
 async function canWriteInto(dir) {
-  const probe = temporaryPathFor(path46.join(dir, ".escritura"));
+  const probe = temporaryPathFor(path54.join(dir, ".escritura"));
   try {
     await mkdir15(dir, { recursive: true });
-    if (!(await stat26(dir)).isDirectory()) return false;
+    if (!(await stat32(dir)).isDirectory()) return false;
     await writeFile9(probe, "");
     return true;
   } catch {
@@ -18468,11 +20554,11 @@ function buildHeader(input) {
   }
   return header;
 }
-function imageRefsOf(event, images, assets, named) {
+function imageRefsOf(event2, images, assets, named) {
   const refs = [];
-  for (const part of event.parts) {
+  for (const part of event2.parts) {
     if (part.kind !== "image") continue;
-    const input = images.get(imageKey(event.eventId, part.source, part.index));
+    const input = images.get(imageKey(event2.eventId, part.source, part.index));
     let asset = null;
     let bytes = 0;
     if (input?.kind === "loaded") {
@@ -18494,8 +20580,8 @@ function serializeSession(input) {
   const assets = /* @__PURE__ */ new Map();
   const named = /* @__PURE__ */ new Set();
   const bodyLines = [];
-  for (const event of input.events) {
-    const line = { kind: "event", event, images: imageRefsOf(event, images, assets, named) };
+  for (const event2 of input.events) {
+    const line = { kind: "event", event: event2, images: imageRefsOf(event2, images, assets, named) };
     bodyLines.push(JSON.stringify(line));
   }
   for (const document of documents) {
@@ -18523,12 +20609,12 @@ function serializeSession(input) {
 }
 
 // packages/server/src/vault/writer.ts
-import { readdir as readdir15, rm as rm6, stat as stat28 } from "node:fs/promises";
-import path48 from "node:path";
+import { readdir as readdir17, rm as rm6, stat as stat34 } from "node:fs/promises";
+import path56 from "node:path";
 
 // packages/server/src/vault/memory-copy.ts
-import { mkdir as mkdir16, readdir as readdir14, readFile as readFile19, stat as stat27, utimes as utimes2 } from "node:fs/promises";
-import path47 from "node:path";
+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";
 var MEMORY_FILE_MAX_BYTES = 1024 * 1024;
 var MEMORY_MAX_FILES = 500;
 var MEMORY_SOURCE_FILE = "source.json";
@@ -18543,7 +20629,7 @@ async function listMemoryNotes(cwd) {
   }
   let entries;
   try {
-    entries = await readdir14(folder, { withFileTypes: true });
+    entries = await readdir16(folder, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -18553,7 +20639,7 @@ async function listMemoryNotes(cwd) {
     let absolute;
     try {
       absolute = await resolveInside(cwd, `${MEMORY_DIR}/${name}`, { mustExist: true });
-      const info = await stat27(absolute);
+      const info = await stat33(absolute);
       if (!info.isFile() || info.size > MEMORY_FILE_MAX_BYTES) continue;
       notes.push({ name, absolute, size: info.size, mtimeMs: info.mtimeMs });
     } catch {
@@ -18567,7 +20653,7 @@ async function measureProjectMemory(cwd) {
 }
 async function isUpToDate(target, note) {
   try {
-    const info = await stat27(target);
+    const info = await stat33(target);
     return info.isFile() && info.size === note.size && Math.abs(info.mtimeMs - note.mtimeMs) < SAME_MTIME_MS;
   } catch {
     return false;
@@ -18575,7 +20661,7 @@ async function isUpToDate(target, note) {
 }
 async function exists3(file) {
   try {
-    await stat27(file);
+    await stat33(file);
     return true;
   } catch {
     return false;
@@ -18594,11 +20680,11 @@ async function copyProjectMemory(dir, cwd, platform, deps = DEFAULT_WRITE_DEPS)
     await mkdir16(target, { recursive: true });
   };
   for (const note of notes) {
-    const destination = path47.join(target, note.name);
+    const destination = path55.join(target, note.name);
     if (await isUpToDate(destination, note)) continue;
     let content;
     try {
-      content = await readFile19(note.absolute);
+      content = await readFile21(note.absolute);
     } catch {
       continue;
     }
@@ -18610,7 +20696,7 @@ async function copyProjectMemory(dir, cwd, platform, deps = DEFAULT_WRITE_DEPS)
     result.files += 1;
     result.bytes += content.length;
   }
-  const source = path47.join(target, MEMORY_SOURCE_FILE);
+  const source = path55.join(target, MEMORY_SOURCE_FILE);
   if (result.files > 0 || !await exists3(source)) {
     await prepare();
     await writeFileAtomic(source, `${JSON.stringify({ cwd, copiedAt: deps.now() })}
@@ -19044,10 +21130,10 @@ var VaultWriter = class {
     if (whole.state !== "live" || whole.events.length === 0) return { kind: "empty" };
     const previous = reuse === null ? /* @__PURE__ */ new Map() : await this.previousImages(reuse, agent, summary.sessionId, whole.events);
     const images = /* @__PURE__ */ new Map();
-    for (const event of whole.events) {
-      for (const part of event.parts) {
+    for (const event2 of whole.events) {
+      for (const part of event2.parts) {
         if (part.kind !== "image") continue;
-        const keyOfImage = imageKey(event.eventId, part.source, part.index);
+        const keyOfImage = imageKey(event2.eventId, part.source, part.index);
         if (images.has(keyOfImage)) continue;
         const old = previous.get(keyOfImage);
         if (reuse !== null && old !== void 0 && old.asset !== null && old.mediaType === part.mediaType && await this.assetOnDisk(reuse.dir, agent, summary.sessionId, old.asset, old.bytes)) {
@@ -19055,7 +21141,7 @@ var VaultWriter = class {
           continue;
         }
         try {
-          const loaded = await whole.readImage(event.eventId, part.index, part.source);
+          const loaded = await whole.readImage(event2.eventId, part.index, part.source);
           if (loaded !== null) images.set(keyOfImage, { kind: "loaded", data: Buffer.from(loaded.data, "base64") });
         } catch (error) {
           this.log.warn(`[vault] ${whole.label}: couldn't read an image: ${messageOf2(error)}`);
@@ -19093,7 +21179,7 @@ var VaultWriter = class {
   async previousImages(reuse, agent, sessionId, events) {
     const refs = /* @__PURE__ */ new Map();
     const { header } = reuse;
-    if (header === null || header.source.kind !== "native" || header.source.writerRevision !== this.revision || header.imageCount === 0 || !events.some((event) => event.parts.some((part) => part.kind === "image"))) {
+    if (header === null || header.source.kind !== "native" || header.source.writerRevision !== this.revision || header.imageCount === 0 || !events.some((event2) => event2.parts.some((part) => part.kind === "image"))) {
       return refs;
     }
     for await (const line of this.options.catalog.readBody(agent, sessionId)) {
@@ -19104,7 +21190,7 @@ var VaultWriter = class {
   }
   async assetOnDisk(dir, agent, sessionId, asset, bytes) {
     try {
-      const info = await stat28(assetFile(dir, agent, sessionId, asset));
+      const info = await stat34(assetFile(dir, agent, sessionId, asset));
       return info.isFile() && info.size === bytes;
     } catch {
       return false;
@@ -19204,29 +21290,29 @@ var VaultWriter = class {
     const folders = [dir];
     const subfolders = async (parent) => {
       try {
-        return (await readdir15(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path48.join(parent, entry.name));
+        return (await readdir17(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path56.join(parent, entry.name));
       } catch {
         return [];
       }
     };
     for (const agentDir of await subfolders(sessionsRoot2(dir))) {
-      if (!SESSION_AGENT_IDS.includes(path48.basename(agentDir))) continue;
+      if (!SESSION_AGENT_IDS.includes(path56.basename(agentDir))) continue;
       folders.push(agentDir);
       folders.push(...(await subfolders(agentDir)).filter((folder) => folder.endsWith(".assets")));
     }
-    folders.push(...await subfolders(path48.join(dir, "memory")));
+    folders.push(...await subfolders(path56.join(dir, "memory")));
     for (const folder of folders) {
       let names;
       try {
-        names = await readdir15(folder);
+        names = await readdir17(folder);
       } catch {
         continue;
       }
       for (const name of names) {
         if (!OWN_TEMP_FILE2.test(name)) continue;
-        const file = path48.join(folder, name);
+        const file = path56.join(folder, name);
         try {
-          const info = await stat28(file);
+          const info = await stat34(file);
           if (info.isFile() && now - info.mtimeMs > TEMP_MAX_AGE_MS) await rm6(file, { force: true });
         } catch {
         }
@@ -19414,14 +21500,14 @@ var VaultService = class {
   async setDir(target) {
     const { platform, agents, settings: settings2, catalog } = this.options;
     const current = this.dir();
-    const protectedDirs = [...agents.protectedDirs(), path49.join(this.options.homeDir ?? homedir12(), ".gemini")];
+    const protectedDirs = [...agents.protectedDirs(), path57.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 stat29(vaultMarkerFile(current)).then(
+        const hadCopy = await stat35(vaultMarkerFile(current)).then(
           () => true,
           () => false
         );
@@ -19455,7 +21541,7 @@ var VaultService = class {
   /** Abre la carpeta de la copia con el explorador del sistema. */
   async reveal() {
     const dir = this.activeDir();
-    const isFolder = await stat29(dir).then(
+    const isFolder = await stat35(dir).then(
       (info) => info.isDirectory(),
       () => false
     );
@@ -19479,7 +21565,7 @@ var VaultService = class {
       fromCopy: true
     });
     const file = sessionExportFile(dir, agent, sessionId);
-    await mkdir17(path49.dirname(file), { recursive: true });
+    await mkdir17(path57.dirname(file), { recursive: true });
     await writeFileAtomic(file, text, this.writeDeps);
     this.openWithSystem(file);
     return file;
@@ -19583,7 +21669,7 @@ var VaultService = class {
         continue;
       }
       const fileName = this.exportFileName(summary, names);
-      await writeFileAtomic(path49.join(folder, fileName), text, this.writeDeps);
+      await writeFileAtomic(path57.join(folder, fileName), text, this.writeDeps);
       entries.push({
         updatedAt: summary.updatedAt,
         agentLabel: this.labelOf(summary.agent),
@@ -19594,9 +21680,9 @@ var VaultService = class {
       });
       await nextTurn3();
     }
-    const name = project.cwd.length > 0 ? path49.basename(project.cwd) || project.cwd : project.fallbackName;
+    const name = project.cwd.length > 0 ? path57.basename(project.cwd) || project.cwd : project.fallbackName;
     const index = renderProjectIndex({ name, cwd: project.cwd, exportedAt: this.now(), entries, skipped });
-    await writeFileAtomic(path49.join(folder, "index.md"), index, this.writeDeps);
+    await writeFileAtomic(path57.join(folder, "index.md"), index, this.writeDeps);
     this.openWithSystem(folder);
     return { sessions: entries.length, skipped, folder };
   }
@@ -19668,10 +21754,10 @@ var VaultService = class {
       documentCount: 0,
       imageCount: 0
     });
-    const lines = whole.events.map((event) => ({
+    const lines = whole.events.map((event2) => ({
       kind: "event",
-      event,
-      images: event.parts.flatMap(
+      event: event2,
+      images: event2.parts.flatMap(
         (part) => part.kind === "image" ? [{ index: part.index, source: part.source, mediaType: part.mediaType, asset: null, bytes: 0 }] : []
       )
     }));
@@ -19763,6 +21849,7 @@ function attachTerminalSocket(options) {
   } = options;
   const pasteStore = options.pasteStore ?? new PasteStore();
   const writeQueue = new TerminalWriteQueue();
+  const queuedSubmits = new QueuedSubmitBook();
   const wss = new WebSocketServer({ noServer: true });
   const clients = /* @__PURE__ */ new Set();
   const send = (socket, message) => {
@@ -19843,9 +21930,12 @@ function attachTerminalSocket(options) {
     if (entries.length > 0) broadcast({ type: "composer.drafts", drafts: entries });
   };
   const onRegistryExit = (terminalId, exitCode, signal) => broadcast({ type: "terminal.exit", terminalId, exitCode, signal });
-  const onRegistryActivity = (terminalId, activity, offlineReason) => broadcast(
-    offlineReason === null ? { type: "terminal.activity", terminalId, activity } : { type: "terminal.activity", terminalId, activity, offlineReason }
-  );
+  const onRegistryActivity = (terminalId, activity, offlineReason) => {
+    if (activity === "idle" || activity === "offline") queuedSubmits.forget(terminalId);
+    broadcast(
+      offlineReason === null ? { type: "terminal.activity", terminalId, activity } : { type: "terminal.activity", terminalId, activity, offlineReason }
+    );
+  };
   const onIndexStatus = (status) => broadcast({ type: "index.status", status });
   const onIndexProjects = (projects, replace) => broadcast({ type: "index.projects", projects, replace });
   const onConversationAppend = (terminalId, events, usage, permissionMode) => {
@@ -19857,7 +21947,7 @@ function attachTerminalSocket(options) {
   const onConversationState = (terminalId, state) => broadcast({ type: "conversation.state", terminalId, state });
   const onConversationMode = (terminalId, mode) => broadcast({ type: "conversation.mode", terminalId, mode });
   const onConversationWaiting = (terminalId, waitingFor) => broadcast({ type: "conversation.waiting", terminalId, waitingFor });
-  const onConversationToolCall = (terminalId, open8) => broadcast({ type: "conversation.toolCall", terminalId, open: open8 });
+  const onConversationToolCall = (terminalId, open9) => broadcast({ type: "conversation.toolCall", terminalId, open: open9 });
   const onConversationSubagents = (terminalId, subagents) => broadcast({ type: "conversation.subagents", terminalId, subagents });
   const onConversationPlans = (terminalId, plans) => broadcast({ type: "conversation.plans", terminalId, plans });
   const onConversationTurns = (terminalId, turns) => broadcast({ type: "conversation.turns", terminalId, turns });
@@ -19876,6 +21966,7 @@ function attachTerminalSocket(options) {
     conversations.drop(terminalId);
     repos.drop(terminalId);
     memory.drop(terminalId);
+    queuedSubmits.drop(terminalId);
     void pasteStore.clearTerminal(terminalId);
     broadcast({ type: "terminal.closed", terminalId });
     return true;
@@ -20064,7 +22155,8 @@ function attachTerminalSocket(options) {
       platform: process.platform,
       defaultCwd,
       shellName: appSettings.currentShell()?.name ?? null,
-      remoteClient: deviceId !== null
+      remoteClient: deviceId !== null,
+      fileCheck: true
     });
     send(socket, terminalListMessage());
     for (const entry of registry.activitySnapshot()) {
@@ -20096,6 +22188,7 @@ function attachTerminalSocket(options) {
           if (!registry.write(message.terminalId, message.data) && registry.get(message.terminalId) === null) {
             sendError(socket, "unknown-terminal", serverText("terminalGone"));
           }
+          if (message.data.includes(CLEAR_EDITOR)) queuedSubmits.noteClearKey(message.terminalId, Date.now());
           break;
         /*
                   Un mensaje del cuadro de escritura.
@@ -20117,10 +22210,11 @@ function attachTerminalSocket(options) {
             settled = true;
             send(socket, { type: "agent.submitted", terminalId, requestId: message.requestId, delivered });
           };
+          const clearsDraft = submitClearsDraft(message);
           const submittedTab = registry.get(terminalId);
           const submittedOwner = draftOwnerOf(submittedTab);
-          if (submittedOwner !== null) drafts.delete(submittedOwner);
-          if (submittedTab !== null) {
+          if (clearsDraft && submittedOwner !== null) drafts.delete(submittedOwner);
+          if (clearsDraft && submittedTab !== null) {
             broadcast({
               type: "composer.drafts",
               drafts: submittedOwner === null ? [{ terminalId, draft: { text: "", pasted: [] } }] : draftEntriesOf(registry.list(), drafts, submittedOwner)
@@ -20236,6 +22330,13 @@ function attachTerminalSocket(options) {
                 { startAfterMs }
               );
               settle(outcome === "written");
+              if (outcome === "written" && message.send !== false && submitting?.queuedSubmits !== void 0) {
+                queuedSubmits.note(
+                  terminalId,
+                  submissionPayload(fullText, imagePaths, input.imageReference) ?? fullText,
+                  Date.now()
+                );
+              }
               if (outcome === "interrupted") interrupted();
               if (outcome === "blocked") {
                 const waitingNow = blocksWhileWaiting && registry.activityOf(terminalId) === "waiting";
@@ -20385,10 +22486,10 @@ function attachTerminalSocket(options) {
                   nunca esconde nada.
                 */
         case "session.archive": {
-          const open8 = new Set(
+          const open9 = new Set(
             registry.list().map((terminal) => terminal.sessionId).filter((id) => id.length > 0)
           );
-          const targets = message.archived ? message.sessionIds.filter((id) => !open8.has(id)) : message.sessionIds;
+          const targets = message.archived ? message.sessionIds.filter((id) => !open9.has(id)) : message.sessionIds;
           if (archived.set(targets, message.archived)) index.refresh();
           if (message.archived && targets.length < message.sessionIds.length) {
             sendError(
@@ -20408,6 +22509,44 @@ function attachTerminalSocket(options) {
           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;
+                    },
+                    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(
@@ -20826,6 +22965,20 @@ function attachTerminalSocket(options) {
             }
           })();
           break;
+        /*
+          Cuales de esas rutas son archivos del proyecto (§6.33): lo que el
+          hilo vuelve enlace. Sin error para ningun caso —una pestana que ya no
+          esta, una ruta que cae fuera—: nada existe, y el hilo queda como
+          texto. Un cartel por una ruta que escribio el agente no le dice nada
+          al usuario.
+        */
+        case "files.check":
+          void (async () => {
+            const cwd = cwdOf(message.terminalId);
+            const existing = cwd === null ? [] : await existingFiles(cwd, message.paths).catch(() => []);
+            send(socket, { type: "files.checked", terminalId: message.terminalId, requestId: message.requestId, existing });
+          })();
+          break;
         case "files.reveal":
           void (async () => {
             const cwd = cwdOf(message.terminalId);
@@ -21267,9 +23420,9 @@ function attachTerminalSocket(options) {
 }
 
 // packages/server/src/vault/catalog.ts
-import { open as open7, readdir as readdir16, stat as stat30 } from "node:fs/promises";
-import path50 from "node:path";
-import { createInterface as createInterface2 } from "node:readline";
+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";
 var HEADER_MAX_BYTES = 64 * 1024;
 var LOAD_CONCURRENCY = 16;
 var keyOf2 = (agent, sessionId) => `${agent}/${sessionId}`;
@@ -21280,7 +23433,7 @@ async function assetBytesOf(dir, agent, sessionId) {
   const folder = assetsDir(dir, agent, sessionId);
   let names;
   try {
-    names = await readdir16(folder);
+    names = await readdir18(folder);
   } catch {
     return 0;
   }
@@ -21288,18 +23441,18 @@ async function assetBytesOf(dir, agent, sessionId) {
   for (const name of names) {
     if (!VAULT_ASSET_NAME_PATTERN.test(name)) continue;
     try {
-      const info = await stat30(path50.join(folder, name));
+      const info = await stat36(path58.join(folder, name));
       if (info.isFile()) total += info.size;
     } catch {
     }
   }
   return total;
 }
-async function readEntry(dir, agent, sessionId) {
+async function readEntry2(dir, agent, sessionId) {
   const file = sessionFile(dir, agent, sessionId);
   let sizeBytes;
   try {
-    const info = await stat30(file);
+    const info = await stat36(file);
     if (!info.isFile()) return { kind: "absent" };
     sizeBytes = info.size;
   } catch {
@@ -21356,7 +23509,7 @@ var VaultCatalog = class {
     const keys = [];
     let agentFolders = [];
     try {
-      agentFolders = await readdir16(sessionsRoot2(dir));
+      agentFolders = await readdir18(sessionsRoot2(dir));
     } catch {
       agentFolders = [];
     }
@@ -21364,7 +23517,7 @@ var VaultCatalog = class {
       if (!isSessionAgentId2(folder)) continue;
       let names;
       try {
-        names = await readdir16(agentSessionsDir(dir, folder));
+        names = await readdir18(agentSessionsDir(dir, folder));
       } catch {
         continue;
       }
@@ -21374,7 +23527,7 @@ var VaultCatalog = class {
         if (isSafeSessionId(sessionId)) keys.push({ agent: folder, sessionId });
       }
     }
-    const reads = await mapLimited(keys, LOAD_CONCURRENCY, (key) => readEntry(dir, key.agent, key.sessionId));
+    const reads = await mapLimited(keys, LOAD_CONCURRENCY, (key) => readEntry2(dir, key.agent, key.sessionId));
     if (generation !== this.generation) return;
     const entries = /* @__PURE__ */ new Map();
     const foreign = /* @__PURE__ */ new Set();
@@ -21393,7 +23546,7 @@ var VaultCatalog = class {
     const dir = this.dir;
     if (dir === null || !isSafeSessionId(sessionId)) return;
     const generation = this.generation;
-    const read = await readEntry(dir, agent, sessionId);
+    const read = await readEntry2(dir, agent, sessionId);
     if (generation !== this.generation) return;
     const key = keyOf2(agent, sessionId);
     const before = JSON.stringify(this.entries.get(key) ?? null);
@@ -21453,10 +23606,10 @@ var VaultCatalog = class {
   async *bodyLines(agent, sessionId) {
     const dir = this.dir;
     if (dir === null || !this.entries.has(keyOf2(agent, sessionId))) return;
-    const handle = await open7(sessionFile(dir, agent, sessionId), "r").catch(() => null);
+    const handle = await open8(sessionFile(dir, agent, sessionId), "r").catch(() => null);
     if (handle === null) return;
     const input = handle.createReadStream({ encoding: "utf8" });
-    const lines = createInterface2({ input, crlfDelay: Number.POSITIVE_INFINITY });
+    const lines = createInterface3({ input, crlfDelay: Number.POSITIVE_INFINITY });
     let sawHeader = false;
     try {
       for await (const raw of lines) {
@@ -21508,15 +23661,15 @@ var VaultCatalog = class {
 };
 
 // packages/server/src/index.ts
-var serverDir = path51.dirname(fileURLToPath2(import.meta.url));
+var serverDir = path59.dirname(fileURLToPath2(import.meta.url));
 var isPackaged = true;
-var webRoot = isPackaged ? serverDir : path51.resolve(serverDir, "../../web");
-var webDist = isPackaged ? path51.join(serverDir, "web") : path51.join(webRoot, "dist");
-var repoRoot = path51.resolve(serverDir, "../../..");
+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 isProduction = isPackaged || process.argv.includes("--prod");
 function resolveDefaultCwd() {
   const override = process.env["AGENT_WORKBENCH_CWD"];
-  if (override !== void 0 && override.length > 0) return path51.resolve(override);
+  if (override !== void 0 && override.length > 0) return path59.resolve(override);
   if (isPackaged) return process.cwd();
   return repoRoot;
 }
@@ -21591,7 +23744,7 @@ async function mountDevUi(app, httpServer) {
 }
 var LOOKS_LIKE_FILE = /\.[a-zA-Z0-9]{1,8}$/;
 function mountBuiltUi(app) {
-  const indexHtml = path51.join(webDist, "index.html");
+  const indexHtml = path59.join(webDist, "index.html");
   if (!existsSync4(indexHtml)) {
     throw new Error(
       `There's no compiled interface in ${webDist}.