agent-workbench 0.3.1 → 0.4.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 path47 from "node:path";
+import path49 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import express from "express";
 
@@ -45,6 +45,15 @@ function asArrayOf(value, parseItem) {
   }
   return result;
 }
+function asArrayFiltered(value, parseItem) {
+  if (!Array.isArray(value)) return null;
+  const result = [];
+  for (const item of value) {
+    const parsed = parseItem(item);
+    if (parsed !== null) result.push(parsed);
+  }
+  return result;
+}
 function asLiteral(value, allowed) {
   return typeof value === "string" && allowed.includes(value) ? value : null;
 }
@@ -354,6 +363,41 @@ function modelFamilyOf(value, options = MODEL_OPTIONS) {
   return candidates.find((option) => value.includes(option.family))?.family ?? null;
 }
 
+// packages/shared/src/composer-draft.ts
+var MAX_COMPOSER_DRAFT_CHARS = 1e6;
+var MAX_COMPOSER_DRAFT_PASTES = 100;
+var MAX_PASTE_NUMBER = 999999;
+function composerDraftChars(draft) {
+  return draft.pasted.reduce((total, paste) => total + paste.text.length, draft.text.length);
+}
+function isEmptyComposerDraft(draft) {
+  return draft.text.trim().length === 0 && draft.pasted.every((paste) => paste.text.trim().length === 0);
+}
+function sameComposerDraft(a, b) {
+  if (a.text !== b.text || a.pasted.length !== b.pasted.length) return false;
+  return a.pasted.every((paste, index) => {
+    const other = b.pasted[index];
+    return other !== void 0 && other.number === paste.number && other.text === paste.text;
+  });
+}
+function parseComposerDraftPaste(value) {
+  const record = asRecord(value);
+  if (record === null) return null;
+  const number = record["number"];
+  const text = asString(record["text"]);
+  if (typeof number !== "number" || !Number.isInteger(number) || number < 1 || number > MAX_PASTE_NUMBER) return null;
+  return text === null ? null : { number, text };
+}
+function parseComposerDraft(value) {
+  const record = asRecord(value);
+  if (record === null) return null;
+  const text = asString(record["text"]);
+  const pasted2 = asArrayOf(record["pasted"], parseComposerDraftPaste);
+  if (text === null || pasted2 === null || pasted2.length > MAX_COMPOSER_DRAFT_PASTES) return null;
+  if (new Set(pasted2.map((paste) => paste.number)).size !== pasted2.length) return null;
+  return { text, pasted: pasted2 };
+}
+
 // packages/shared/src/memory.ts
 var MEMORY_DIR = ".agents/memory";
 var MEMORY_INDEX_FILE = "MEMORY.md";
@@ -620,6 +664,21 @@ function parseVaultBodyLine(value) {
   return null;
 }
 
+// packages/shared/src/remote.ts
+var REMOTE_DEFAULT_PORT = 24837;
+var REMOTE_MIN_PORT = 1024;
+var REMOTE_MAX_PORT = 65535;
+var PAIR_QUERY_PARAM = "pair";
+var PAIRING_TTL_MS = 5 * 6e4;
+var REMOTE_DEVICE_LABEL_MAX_CHARS = 60;
+var REMOTE_REVOKED_CLOSE_CODE = 4001;
+function isRemotePort(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= REMOTE_MIN_PORT && value <= REMOTE_MAX_PORT;
+}
+function cleanDeviceLabel(label) {
+  return label.replace(/\s+/g, " ").trim().slice(0, REMOTE_DEVICE_LABEL_MAX_CHARS);
+}
+
 // packages/shared/src/protocol.ts
 var PROTOCOL_VERSION = 8;
 var WS_PATH = "/ws";
@@ -971,6 +1030,43 @@ function parseClientMessage(raw) {
       const searchId = asNonEmptyString(record["searchId"]);
       return searchId === null ? null : { type: "search.cancel", searchId };
     }
+    case "remote.configure": {
+      const rawEnabled = record["enabled"];
+      const rawPort = record["port"];
+      const enabled2 = rawEnabled === void 0 ? void 0 : asBoolean(rawEnabled);
+      const port = rawPort === void 0 ? void 0 : asFiniteNumber(rawPort);
+      if (enabled2 === null || port === null || enabled2 === void 0 && port === void 0) return null;
+      return {
+        type: "remote.configure",
+        ...enabled2 !== void 0 ? { enabled: enabled2 } : {},
+        ...port !== void 0 ? { port } : {}
+      };
+    }
+    case "remote.pairing.start":
+      return { type: "remote.pairing.start" };
+    case "remote.pairing.cancel":
+      return { type: "remote.pairing.cancel" };
+    case "remote.device.rename": {
+      const deviceId = asNonEmptyString(record["deviceId"]);
+      const rawLabel = asString(record["label"]);
+      const label = rawLabel === null ? "" : cleanDeviceLabel(rawLabel);
+      return deviceId === null || label.length === 0 ? null : { type: "remote.device.rename", deviceId, label };
+    }
+    case "remote.device.revoke": {
+      const deviceId = asNonEmptyString(record["deviceId"]);
+      return deviceId === null ? null : { type: "remote.device.revoke", deviceId };
+    }
+    case "remote.phone.start":
+      return { type: "remote.phone.start" };
+    case "remote.phone.cancel":
+      return { type: "remote.phone.cancel" };
+    case "remote.device.forgetSelf":
+      return { type: "remote.device.forgetSelf" };
+    case "composer.draft": {
+      const terminalId = asNonEmptyString(record["terminalId"]);
+      const draft = parseComposerDraft(record["draft"]);
+      return terminalId === null || draft === null ? null : { type: "composer.draft", terminalId, draft };
+    }
     default:
       return null;
   }
@@ -1030,6 +1126,9 @@ function pastedBoundaryPattern() {
   return /\[(?:Start|End) of pasted text #\d{1,6}\]/g;
 }
 
+// packages/shared/src/support.ts
+var SUPPORT_URL = "https://buymeacoffee.com/cvelasquez";
+
 // packages/server/src/archived-sessions.ts
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path2 from "node:path";
@@ -1068,12 +1167,18 @@ function archivedSessionsPath() {
 function appSettingsPath() {
   return path.join(appConfigDir(), "settings.json");
 }
+function remoteDevicesPath() {
+  return path.join(appConfigDir(), "remote-devices.json");
+}
 function notesStatePath() {
   return path.join(appConfigDir(), "notes.json");
 }
 function notesImagesDir() {
   return path.join(appConfigDir(), "notes-images");
 }
+function composerDraftsPath() {
+  return path.join(appConfigDir(), "composer-drafts.json");
+}
 function catalogTempDir() {
   return path.join(tmpdir(), "agent-workbench", "agy-catalog");
 }
@@ -10665,214 +10770,1075 @@ function ensurePtyHelperExecutable(options = {}) {
   return fixed;
 }
 
-// packages/server/src/security.ts
-import { randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
-var LOOPBACK_HOST = "127.0.0.1";
-var ALLOWED_HOSTNAMES = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
-var TOKEN_HEADER = "x-agent-workbench-token";
-var TOKEN_COOKIE = "agent_workbench_token";
-function createSessionToken() {
-  return randomBytes2(32).toString("base64url");
+// packages/server/src/remote-access-service.ts
+import { execFile as execFile3 } from "node:child_process";
+import { randomBytes as cryptoRandomBytes, randomUUID as randomUUID2 } from "node:crypto";
+import os from "node:os";
+
+// packages/server/src/phone-pairing.ts
+import { createPrivateKey, createPublicKey } from "node:crypto";
+var PHONE_PAYLOAD_PREFIX = "agentworkbench://pair?";
+var PHONE_PAYLOAD_VERSION = 1;
+var PHONE_SSH_PORT = 22;
+var PHONE_KEY_COMMENT = "agent-workbench-phone";
+var PHONE_SEED_BYTES = 32;
+var ED25519_PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+function ed25519PublicKey(seed) {
+  if (seed.length !== PHONE_SEED_BYTES) throw new Error(`an Ed25519 seed has ${PHONE_SEED_BYTES} bytes`);
+  const privateKey = createPrivateKey({ key: Buffer.concat([ED25519_PKCS8_PREFIX, seed]), format: "der", type: "pkcs8" });
+  const spki = createPublicKey(privateKey).export({ format: "der", type: "spki" });
+  return Buffer.from(spki.subarray(spki.length - 32));
+}
+function sshString(bytes) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(bytes.length);
+  return Buffer.concat([length, bytes]);
+}
+function sshEd25519PublicKey(publicKey) {
+  const blob = Buffer.concat([sshString(Buffer.from("ssh-ed25519", "ascii")), sshString(publicKey)]);
+  return `ssh-ed25519 ${blob.toString("base64")}`;
+}
+function phoneAuthorizedKeysEntry(publicKey, appPort) {
+  return `restrict,port-forwarding,permitopen="127.0.0.1:${appPort}",command="exit" ${sshEd25519PublicKey(publicKey)} ${PHONE_KEY_COMMENT}`;
+}
+function phoneAuthorizeCommand(entry, shell) {
+  switch (shell) {
+    case "powershell-admin":
+      return `$f = "$env:ProgramData\\ssh\\administrators_authorized_keys"; Add-Content -Path $f -Encoding ascii -Value @('', '${entry}'); icacls.exe $f /inheritance:r /grant '*S-1-5-32-544:F' /grant '*S-1-5-18:F'`;
+    case "powershell":
+      return `New-Item -ItemType Directory -Force "$HOME\\.ssh" | Out-Null; Add-Content -Path "$HOME\\.ssh\\authorized_keys" -Encoding ascii -Value @('', '${entry}')`;
+    case "terminal":
+      return `mkdir -p ~/.ssh && chmod 700 ~/.ssh && printf '\\n%s\\n' '${entry}' >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys`;
+  }
+}
+function authorizeShellFromGroups(whoamiGroups) {
+  return /S-1-5-32-544/.test(whoamiGroups) ? "powershell-admin" : "powershell";
+}
+function phonePairingPayload(fields) {
+  const params = new URLSearchParams();
+  params.set("v", String(PHONE_PAYLOAD_VERSION));
+  params.set("n", fields.pcName);
+  params.set("h", fields.hosts.join(","));
+  params.set("p", String(fields.sshPort));
+  params.set("u", fields.user);
+  params.set("a", String(fields.appPort));
+  params.set("c", fields.code);
+  params.set("k", fields.seed.toString("base64url"));
+  return PHONE_PAYLOAD_PREFIX + params.toString();
 }
-function constantTimeEquals(a, b) {
+
+// packages/server/src/remote-access.ts
+import { createHash, timingSafeEqual } from "node:crypto";
+var PAIRING_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+var PAIRING_CODE_CHARS = 8;
+var PAIRING_MAX_FAILURES = 5;
+function formatPairingCode(raw) {
+  const half = PAIRING_CODE_CHARS / 2;
+  return `${raw.slice(0, half)}-${raw.slice(half)}`;
+}
+function normalizePairingCode(input) {
+  const raw = input.replace(/[\s-]/g, "").toUpperCase();
+  if (raw.length !== PAIRING_CODE_CHARS) return null;
+  for (const char of raw) {
+    if (!PAIRING_ALPHABET.includes(char)) return null;
+  }
+  return raw;
+}
+function sameText(a, b) {
   const bufferA = Buffer.from(a, "utf8");
   const bufferB = Buffer.from(b, "utf8");
   if (bufferA.length !== bufferB.length) return false;
   return timingSafeEqual(bufferA, bufferB);
 }
-function requestUrl(request) {
-  try {
-    return new URL(request.url ?? "/", `http://${request.headers.host ?? LOOPBACK_HOST}`);
-  } catch {
-    return null;
+var PairingDesk = class {
+  constructor(deps) {
+    this.deps = deps;
   }
-}
-function readCookie(request, name) {
-  const header = request.headers.cookie;
-  if (typeof header !== "string") return null;
-  for (const pair of header.split(";")) {
-    const separator = pair.indexOf("=");
-    if (separator === -1) continue;
-    if (pair.slice(0, separator).trim() !== name) continue;
-    const value = pair.slice(separator + 1).trim();
-    return value.length > 0 ? decodeURIComponent(value) : null;
+  deps;
+  current = null;
+  /** Un código nuevo. Reemplaza al que hubiera: nunca hay dos vigentes. */
+  start() {
+    const bytes = this.deps.randomBytes(PAIRING_CODE_CHARS);
+    let raw = "";
+    for (let i = 0; i < PAIRING_CODE_CHARS; i++) raw += PAIRING_ALPHABET[(bytes[i] ?? 0) % PAIRING_ALPHABET.length];
+    const expiresAt = this.deps.now() + PAIRING_TTL_MS;
+    this.current = { raw, expiresAt, failures: 0 };
+    return { code: formatPairingCode(raw), expiresAt };
   }
-  return null;
-}
-function matchToken(request, expected) {
-  const url = requestUrl(request);
-  const fromQuery = url?.searchParams.get(TOKEN_QUERY_PARAM) ?? null;
-  if (fromQuery !== null && constantTimeEquals(fromQuery, expected)) {
-    return { source: "query" };
+  cancel() {
+    this.current = null;
   }
-  const fromHeader = request.headers[TOKEN_HEADER];
-  if (typeof fromHeader === "string" && constantTimeEquals(fromHeader, expected)) {
-    return { source: "header" };
+  isActive() {
+    if (this.current !== null && this.deps.now() >= this.current.expiresAt) this.current = null;
+    return this.current !== null;
   }
-  const fromCookie = readCookie(request, TOKEN_COOKIE);
-  if (fromCookie !== null && constantTimeEquals(fromCookie, expected)) {
-    return { source: "cookie" };
+  /** Cuándo vence el vigente, o null. */
+  expiresAt() {
+    return this.isActive() ? this.current?.expiresAt ?? null : null;
   }
-  return null;
-}
-function hasValidToken(request, expected) {
-  return matchToken(request, expected) !== null;
+  redeem(input) {
+    if (!this.isActive() || this.current === null) return "none";
+    const raw = normalizePairingCode(input);
+    if (raw === null) return "none";
+    if (sameText(raw, this.current.raw)) {
+      this.current = null;
+      return "ok";
+    }
+    this.current.failures += 1;
+    if (this.current.failures >= PAIRING_MAX_FAILURES) this.current = null;
+    return "wrong";
+  }
+};
+var REMOTE_DEVICES_VERSION = 1;
+var REMOTE_MAX_DEVICES = 20;
+function hashCredential(credential) {
+  return createHash("sha256").update(credential, "utf8").digest("hex");
 }
-function buildTokenCookie(token) {
-  return `${TOKEN_COOKIE}=${encodeURIComponent(token)}; Path=/; SameSite=Strict; HttpOnly`;
+var DeviceBook = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  devices = [];
+  load(devices) {
+    this.devices = devices.slice(0, REMOTE_MAX_DEVICES).map((device) => ({ ...device }));
+  }
+  /** Para guardar: con el hash. */
+  snapshot() {
+    return this.devices.map((device) => ({ ...device }));
+  }
+  /** Para mostrar: sin el hash. */
+  list() {
+    return this.devices.map(({ id, label, createdAt, lastSeenAt }) => ({ id, label, createdAt, lastSeenAt }));
+  }
+  get size() {
+    return this.devices.length;
+  }
+  /** Un equipo nuevo y su credencial, que no queda guardada en ningún lado; null si ya no entran más. */
+  enroll(label) {
+    if (this.devices.length >= REMOTE_MAX_DEVICES) return null;
+    const credential = this.deps.randomBytes(32).toString("base64url");
+    const device = {
+      id: this.deps.randomId(),
+      label: cleanDeviceLabel(label) || "Device",
+      hash: hashCredential(credential),
+      createdAt: this.deps.now(),
+      lastSeenAt: null
+    };
+    this.devices.push(device);
+    return { device: { ...device }, credential };
+  }
+  match(credential) {
+    if (credential.length === 0) return null;
+    const hash = hashCredential(credential);
+    let found = null;
+    for (const device of this.devices) {
+      if (sameText(device.hash, hash)) found = device;
+    }
+    return found === null ? null : { ...found };
+  }
+  /** Anota cuándo se lo vio: ahora, o la marca que se le pase. */
+  touch(id, at = this.deps.now()) {
+    const device = this.devices.find((candidate) => candidate.id === id);
+    if (device === void 0) return false;
+    device.lastSeenAt = at;
+    return true;
+  }
+  rename(id, label) {
+    const device = this.devices.find((candidate) => candidate.id === id);
+    const clean = cleanDeviceLabel(label);
+    if (device === void 0 || clean.length === 0) return false;
+    device.label = clean;
+    return true;
+  }
+  revoke(id) {
+    const before = this.devices.length;
+    this.devices = this.devices.filter((device) => device.id !== id);
+    return this.devices.length !== before;
+  }
+};
+function parseRemoteDevice(value) {
+  const record = asRecord(value);
+  if (record === null) return null;
+  const id = asNonEmptyString(record["id"]);
+  const label = asString(record["label"]);
+  const hash = asString(record["hash"]);
+  const createdAt = asFiniteNumber(record["createdAt"]);
+  if (id === null || label === null || hash === null || createdAt === null) return null;
+  if (!/^[0-9a-f]{64}$/.test(hash)) return null;
+  const lastSeenAt = record["lastSeenAt"] === null || record["lastSeenAt"] === void 0 ? null : asFiniteNumber(record["lastSeenAt"]);
+  return { id, label: cleanDeviceLabel(label) || "Device", hash, createdAt, lastSeenAt };
 }
-function hasValidHost(request, port) {
-  const host = request.headers.host;
-  if (typeof host !== "string") return false;
-  const separator = host.lastIndexOf(":");
-  const hostname = separator === -1 ? host : host.slice(0, separator);
-  const hostPort = separator === -1 ? "" : host.slice(separator + 1);
-  if (!ALLOWED_HOSTNAMES.has(hostname)) return false;
-  return hostPort === "" || hostPort === String(port);
+function parseRemoteDevicesFile(value) {
+  const record = asRecord(value);
+  if (record === null || record["version"] !== REMOTE_DEVICES_VERSION) return null;
+  return asArrayFiltered(record["devices"], parseRemoteDevice) ?? [];
 }
-function hasValidOrigin(request, port) {
-  const origin = request.headers.origin;
-  if (typeof origin !== "string" || origin.length === 0) return true;
-  let parsed;
-  try {
-    parsed = new URL(origin);
-  } catch {
-    return false;
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
-  if (!ALLOWED_HOSTNAMES.has(parsed.hostname)) return false;
-  return parsed.port === String(port);
+function serializeRemoteDevices(devices) {
+  return `${JSON.stringify({ version: REMOTE_DEVICES_VERSION, devices }, null, 2)}
+`;
 }
-function rejectRequest(request, port, token) {
-  if (!hasValidHost(request, port)) return "bad-host";
-  if (!hasValidOrigin(request, port)) return "bad-origin";
-  if (!hasValidToken(request, token)) return "bad-token";
+function remoteAccessState(remote, listening) {
+  if (!remote.enabled) return "off";
+  if (listening.fixedPortBusy) return "port-busy";
+  if (!listening.fixed || listening.port !== remote.port) return "restart-needed";
+  return "active";
+}
+function isPrivateIpv4(address) {
+  const parts = address.split(".").map((part) => Number(part));
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return false;
+  const [a, b] = parts;
+  return a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168;
+}
+function privateIpv4Addresses(interfaces) {
+  const addresses = [];
+  for (const list of Object.values(interfaces)) {
+    for (const info of list ?? []) {
+      if (info.internal || info.family !== "IPv4" || !isPrivateIpv4(info.address)) continue;
+      if (!addresses.includes(info.address)) addresses.push(info.address);
+    }
+  }
+  return addresses;
+}
+var PHONE_APP_USER_AGENT = /AgentWorkbenchAndroid\/\S+ \(Android [^;)]*; ([^)]{1,80})\)/;
+function deviceLabelFromUserAgent(userAgent) {
+  if (userAgent === void 0) return "Device";
+  const phone = PHONE_APP_USER_AGENT.exec(userAgent);
+  if (phone !== null) {
+    const name = cleanDeviceLabel(phone[1] ?? "");
+    return name.length > 0 ? cleanDeviceLabel(`${name} \xB7 Android`) : "Android";
+  }
+  const browser = /Edg\//.test(userAgent) ? "Edge" : /OPR\//.test(userAgent) ? "Opera" : /Firefox\//.test(userAgent) ? "Firefox" : /Chrome\//.test(userAgent) ? "Chrome" : /Safari\//.test(userAgent) ? "Safari" : null;
+  const system = /Windows/.test(userAgent) ? "Windows" : /Android/.test(userAgent) ? "Android" : /iPhone|iPad/.test(userAgent) ? "iOS" : /Mac OS X/.test(userAgent) ? "macOS" : /Linux/.test(userAgent) ? "Linux" : null;
+  if (browser === null || system === null) return "Device";
+  return `${browser} \xB7 ${system}`;
+}
+var HOST_ONLY = /* @__PURE__ */ new Set([
+  "remote.configure",
+  "remote.pairing.start",
+  "remote.pairing.cancel",
+  "remote.device.rename",
+  "remote.device.revoke",
+  "remote.phone.start",
+  "remote.phone.cancel"
+]);
+var OPENS_ON_HOST = /* @__PURE__ */ new Set([
+  "files.reveal",
+  "vault.reveal",
+  "vault.openSession",
+  "vault.exportProject"
+]);
+function remoteRefusal(type, remoteClient) {
+  if (!remoteClient) return null;
+  if (HOST_ONLY.has(type)) return serverText("remoteHostOnly");
+  if (OPENS_ON_HOST.has(type)) return serverText("remoteOpensOnHost");
   return null;
 }
 
-// packages/server/src/repo-hub.ts
-import { EventEmitter as EventEmitter2 } from "node:events";
-import chokidar from "chokidar";
-
-// packages/server/src/git-repo.ts
-import { execFile as execFile3 } from "node:child_process";
-import { readFile as readFile9 } from "node:fs/promises";
-import path30 from "node:path";
-function gitOutputText(output, command) {
-  return output.length > 0 ? serverText("raw", { text: output }) : serverText("gitCommandFailed", { command });
-}
-var MAX_CHANGES = 2e3;
-var MAX_DIFF_LINES = 4e3;
-var MAX_DIFF_BYTES = 512 * 1024;
-var GIT_TIMEOUT_MS = 15e3;
-var GIT_MAX_BUFFER = 32 * 1024 * 1024;
-function isMissingBinary(error) {
-  return typeof error === "object" && error !== null && error.code === "ENOENT";
-}
-var GitMissingError = class extends Error {
-  constructor() {
-    super("git wasn't found in the PATH.");
-    this.name = "GitMissingError";
-  }
-};
-function runGit(cwd, args) {
-  return new Promise((resolve, reject) => {
-    execFile3(
-      "git",
-      [
-        // Sin esto git escapa los no-ASCII en octal y un archivo con acento
-        // vuelve ilegible.
-        "-c",
-        "core.quotepath=false",
-        // Esta app corre `git status` sola, cada pocos segundos, mientras el
-        // usuario trabaja. Sin esta bandera `status` refresca y **escribe** el
-        // indice, y eso trae dos problemas: toma `index.lock`, con lo que puede
-        // hacer fallar un `git add` que el usuario esta escribiendo en la
-        // terminal, y modifica `.git/index`, que es justo lo que observa
-        // nuestro watcher — o sea que cada lectura se dispara a si misma.
-        "--no-optional-locks",
-        ...args
-      ],
-      {
-        cwd,
-        timeout: GIT_TIMEOUT_MS,
-        maxBuffer: GIT_MAX_BUFFER,
-        windowsHide: true,
-        encoding: "utf8"
-      },
-      (error, stdout, stderr) => {
-        if (error !== null && isMissingBinary(error)) {
-          reject(new GitMissingError());
-          return;
-        }
-        const code = error !== null && typeof error.code === "number" ? error.code : error !== null ? 1 : 0;
-        resolve({ stdout, stderr, code });
-      }
-    );
+// packages/server/src/remote-access-service.ts
+var TOUCH_SAVE_DELAY_MS = 5e3;
+var FILES_POLL_MS = 2e3;
+function detectAuthorizeShell() {
+  if (process.platform !== "win32") return Promise.resolve("terminal");
+  return new Promise((resolve) => {
+    execFile3("whoami", ["/groups", "/fo", "csv", "/nh"], { windowsHide: true, timeout: 5e3 }, (error, stdout) => {
+      resolve(error === null ? authorizeShellFromGroups(String(stdout)) : "powershell-admin");
+    });
   });
 }
-function toPosix(value) {
-  return value.split("\\").join("/");
+function detectHostInfo() {
+  let user = "";
+  try {
+    user = os.userInfo().username;
+  } catch {
+    user = process.env["USERNAME"] ?? process.env["USER"] ?? "";
+  }
+  return { user, hostNames: [os.hostname(), ...privateIpv4Addresses(os.networkInterfaces())] };
 }
-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: path30.resolve(root), message: null };
+var RemoteAccessService = class {
+  settings;
+  store;
+  listening;
+  host;
+  now;
+  log;
+  book;
+  desk;
+  randomBytes;
+  authorizeShell;
+  authorizeShellCache = null;
+  /**
+   * La semilla de la llave del teléfono que se está emparejando (hito 38). Sólo
+   * en memoria, y sólo mientras dure ese emparejamiento: se olvida al
+   * cancelarlo, al canjearse el código o al cerrarse la ventana que lo pidió.
+   */
+  phoneSeed = null;
+  changeListeners = /* @__PURE__ */ new Set();
+  revokedListeners = /* @__PURE__ */ new Set();
+  /** Cuántas ventanas tiene abiertas cada equipo. */
+  connections = /* @__PURE__ */ new Map();
+  /** Las "última vez visto" que todavía no se guardaron: releer el archivo no se las lleva. */
+  pendingSeen = /* @__PURE__ */ new Map();
+  pairingTimer = null;
+  touchTimer = null;
+  pollTimer = null;
+  /** Cómo estaban los dos archivos la última vez que se leyeron o escribieron desde acá. */
+  stamps = { devices: "", settings: "" };
+  /** Las sincronizaciones, en fila: la del sondeo y la de un cambio no se cruzan. */
+  syncing = Promise.resolve();
+  constructor(options) {
+    this.settings = options.settings;
+    this.store = options.store;
+    this.listening = options.listening;
+    this.host = options.host ?? null;
+    this.now = options.now ?? (() => Date.now());
+    this.log = options.log ?? console;
+    const randomBytes5 = options.randomBytes ?? ((size) => cryptoRandomBytes(size));
+    this.randomBytes = randomBytes5;
+    this.authorizeShell = options.authorizeShell ?? detectAuthorizeShell;
+    this.book = new DeviceBook({ now: this.now, randomBytes: randomBytes5, randomId: () => randomUUID2() });
+    this.desk = new PairingDesk({ now: this.now, randomBytes: randomBytes5 });
   }
-  const stderr = result.stderr.trim();
-  if (/not a git repository|no es un repositorio/i.test(stderr)) {
-    return { state: "not-a-repo", root: "", message: null };
+  async load() {
+    this.book.load(await this.store.load());
+    this.stamps = { devices: await this.store.stamp(), settings: await this.settings.stamp() };
+    this.updatePolling();
   }
-  if (stderr.length === 0 && result.code !== 0) {
+  // ---- Qué corre ---------------------------------------------------------------
+  remote() {
+    return this.settings.get().remote;
+  }
+  /** Entran equipos: encendido, y el servidor escucha en el puerto fijo con el que arrancó. */
+  accepting() {
+    return this.remote().enabled && this.listening.fixed;
+  }
+  /** A quién pertenece una credencial, o null si ahora no entra nadie. */
+  verifier() {
+    return this.accepting() ? this.book : null;
+  }
+  get pairedDevices() {
+    return this.book.size;
+  }
+  status() {
+    const remote = this.remote();
+    const host = this.host ?? detectHostInfo();
     return {
-      state: "error",
-      root: "",
-      message: serverText("gitRunFailed")
+      enabled: remote.enabled,
+      port: remote.port,
+      state: remoteAccessState(remote, this.listening),
+      listeningPort: this.listening.port,
+      sshUser: host.user,
+      hostNames: [...host.hostNames],
+      pairingActive: this.desk.isActive(),
+      devices: this.book.list().map((device) => ({
+        ...device,
+        connected: (this.connections.get(device.id) ?? 0) > 0
+      }))
     };
   }
-  return {
-    state: "error",
-    root: "",
-    message: gitOutputText(stderr.slice(0, 400), "rev-parse")
-  };
-}
-async function findRepoRoot(cwd) {
-  const lookup = await resolveRepo(cwd);
-  return lookup.state === "ready" ? lookup.root : null;
-}
-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 ? path30.resolve(dir) : null;
-}
-function letterToKind(letter) {
-  switch (letter) {
-    case "A":
-      return "added";
-    case "M":
-      return "modified";
-    case "D":
-      return "deleted";
-    case "R":
-      return "renamed";
-    case "C":
-      return "copied";
-    case "T":
-      return "type-changed";
-    default:
-      return "modified";
+  // ---- Lo que cambió otra instancia ----------------------------------------------
+  /**
+   * Trae lo que haya cambiado en los dos archivos desde la última vez. Un equipo
+   * que ya no está se avisa como revocado, y el acceso apagado desde otro lado
+   * corta igual que apagado desde acá.
+   */
+  sync() {
+    const result = this.syncing.then(() => this.syncNow());
+    this.syncing = result.catch(() => void 0);
+    return result;
   }
-}
-function parsePorcelainV2(raw) {
-  const fields = raw.split("\0");
-  const parsed = {
-    branch: null,
-    head: null,
-    upstream: null,
-    ahead: 0,
-    behind: 0,
+  async syncNow() {
+    let changed = false;
+    const settingsStamp = await this.settings.stamp();
+    if (settingsStamp !== this.stamps.settings) {
+      this.stamps.settings = settingsStamp;
+      const wasAccepting = this.accepting();
+      await this.settings.reloadRemote();
+      if (wasAccepting && !this.accepting()) this.cutOff();
+      changed = true;
+    }
+    const devicesStamp = await this.store.stamp();
+    if (devicesStamp !== this.stamps.devices) {
+      this.stamps.devices = devicesStamp;
+      const before = this.book.list().map((device) => device.id);
+      this.book.load(await this.store.load());
+      for (const [deviceId, at] of this.pendingSeen) this.book.touch(deviceId, at);
+      const still = new Set(this.book.list().map((device) => device.id));
+      for (const deviceId of before) {
+        if (still.has(deviceId)) continue;
+        this.connections.delete(deviceId);
+        for (const listener of this.revokedListeners) listener(deviceId);
+      }
+      changed = true;
+    }
+    if (!changed) return;
+    this.updatePolling();
+    this.emitChange();
+  }
+  /** Sondea sólo con el acceso encendido: apagado, esta instancia no hace nada nuevo. */
+  updatePolling() {
+    const wanted = this.remote().enabled;
+    if (wanted && this.pollTimer === null) {
+      this.pollTimer = setInterval(() => void this.sync().catch(() => void 0), FILES_POLL_MS);
+      this.pollTimer.unref();
+    } else if (!wanted && this.pollTimer !== null) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  /** El acceso dejó de estar encendido: el código muere y se avisa cerrar las ventanas de todos. */
+  cutOff() {
+    this.stopPairing();
+    this.log.log("[remote] remote access turned off: paired devices are disconnected");
+    for (const listener of this.revokedListeners) listener(null);
+  }
+  // ---- Cambios desde el anfitrión ----------------------------------------------
+  /** Lanza un `ServerTextError` si el puerto no sirve; los ajustes quedan como estaban. */
+  async configure(patch) {
+    if (patch.port !== void 0 && !isRemotePort(patch.port)) {
+      throw new ServerTextError(serverText("remotePortInvalid", { max: REMOTE_MAX_PORT, min: REMOTE_MIN_PORT }));
+    }
+    await this.sync();
+    const wasAccepting = this.accepting();
+    await this.settings.update({ remote: patch });
+    this.stamps.settings = await this.settings.stamp();
+    if (wasAccepting && !this.accepting()) this.cutOff();
+    this.updatePolling();
+    this.emitChange();
+  }
+  startPairing() {
+    if (!this.accepting()) throw new ServerTextError(serverText("remoteNotActive"));
+    if (this.book.size >= REMOTE_MAX_DEVICES) {
+      throw new ServerTextError(serverText("remoteTooManyDevices", { max: REMOTE_MAX_DEVICES }));
+    }
+    this.stopPairing();
+    const pairing = this.desk.start();
+    this.pairingTimer = setTimeout(() => {
+      this.pairingTimer = null;
+      this.emitChange();
+    }, Math.max(0, pairing.expiresAt - this.now()) + 50);
+    this.pairingTimer.unref();
+    this.emitChange();
+    return pairing;
+  }
+  cancelPairing() {
+    if (!this.desk.isActive()) return;
+    this.stopPairing();
+    this.emitChange();
+  }
+  /**
+   * Empareja un teléfono (hito 38, §15): un código de un solo uso y la llave SSH
+   * que va con él en el QR. La llave es la misma mientras no se cancele: si el
+   * código vence antes de que el teléfono lo use, el usuario pide otro y no
+   * tiene que autorizar otra llave.
+   *
+   * La dirección lleva el puerto en el que escucha este arranque, que es el que
+   * el teléfono va a reenviar.
+   */
+  async startPhonePairing() {
+    const pairing = this.startPairing();
+    this.phoneSeed ??= this.randomBytes(PHONE_SEED_BYTES);
+    const seed = this.phoneSeed;
+    this.authorizeShellCache ??= this.authorizeShell();
+    const shell = await this.authorizeShellCache;
+    const host = this.host ?? detectHostInfo();
+    const [pcName = "", ...addresses] = host.hostNames;
+    const appPort = this.listening.port;
+    return {
+      payload: phonePairingPayload({
+        pcName,
+        hosts: addresses.length > 0 ? addresses : [pcName],
+        sshPort: PHONE_SSH_PORT,
+        user: host.user,
+        appPort,
+        code: pairing.code.replace("-", ""),
+        seed
+      }),
+      authorizeCommand: phoneAuthorizeCommand(phoneAuthorizedKeysEntry(ed25519PublicKey(seed), appPort), shell),
+      shell,
+      code: pairing.code,
+      expiresAt: pairing.expiresAt
+    };
+  }
+  /** Olvida la llave del teléfono y da de baja el código. */
+  cancelPhonePairing() {
+    this.phoneSeed = null;
+    this.cancelPairing();
+  }
+  /** Para el chequeo: si todavía hay una llave de teléfono en memoria. */
+  get phoneKeyHeld() {
+    return this.phoneSeed !== null;
+  }
+  stopPairing() {
+    this.desk.cancel();
+    if (this.pairingTimer !== null) clearTimeout(this.pairingTimer);
+    this.pairingTimer = null;
+  }
+  async renameDevice(deviceId, label) {
+    await this.sync();
+    if (!this.book.rename(deviceId, label)) return false;
+    await this.persist();
+    this.emitChange();
+    return true;
+  }
+  async revokeDevice(deviceId) {
+    await this.sync();
+    if (!this.book.revoke(deviceId)) return false;
+    this.connections.delete(deviceId);
+    this.log.log("[remote] a paired device was revoked");
+    for (const listener of this.revokedListeners) listener(deviceId);
+    await this.persist();
+    this.emitChange();
+    return true;
+  }
+  // ---- Lo que llega de afuera --------------------------------------------------
+  /**
+   * Canjea un código por un equipo nuevo, o null. El nombre sale del navegador
+   * que lo presentó; el usuario lo cambia después.
+   */
+  async redeemPairing(input, userAgent) {
+    if (!this.accepting()) return null;
+    const outcome = this.desk.redeem(input);
+    if (outcome === "none") return null;
+    if (outcome === "wrong") {
+      this.log.warn("[remote] a wrong pairing code was presented");
+      if (!this.desk.isActive()) {
+        this.stopPairing();
+        this.log.warn("[remote] too many wrong codes: the pairing code is no longer valid");
+        this.emitChange();
+      }
+      return null;
+    }
+    this.stopPairing();
+    this.phoneSeed = null;
+    await this.sync();
+    const enrolled = this.accepting() ? this.book.enroll(deviceLabelFromUserAgent(userAgent)) : null;
+    if (enrolled === null) {
+      this.emitChange();
+      return null;
+    }
+    await this.persist();
+    this.log.log(`[remote] paired a new device: ${enrolled.device.label}`);
+    this.emitChange();
+    return { deviceId: enrolled.device.id, credential: enrolled.credential };
+  }
+  noteConnected(deviceId) {
+    this.connections.set(deviceId, (this.connections.get(deviceId) ?? 0) + 1);
+    this.touch(deviceId);
+    this.emitChange();
+  }
+  noteDisconnected(deviceId) {
+    const left = (this.connections.get(deviceId) ?? 0) - 1;
+    if (left > 0) this.connections.set(deviceId, left);
+    else this.connections.delete(deviceId);
+    this.touch(deviceId);
+    this.emitChange();
+  }
+  /** La "última vez visto" no vale una escritura por conexión: se junta. */
+  touch(deviceId) {
+    const at = this.now();
+    if (!this.book.touch(deviceId, at)) return;
+    this.pendingSeen.set(deviceId, at);
+    if (this.touchTimer !== null) return;
+    this.touchTimer = setTimeout(() => {
+      this.touchTimer = null;
+      void this.persistTouches();
+    }, TOUCH_SAVE_DELAY_MS);
+    this.touchTimer.unref();
+  }
+  /**
+   * Guarda las "última vez visto". Relee antes: una fecha no puede devolverle
+   * la vida a un equipo que otra instancia revocó mientras tanto —al releer, el
+   * que ya no está no recibe la suya—.
+   */
+  async persistTouches() {
+    if (this.pendingSeen.size === 0) return;
+    await this.sync();
+    this.pendingSeen.clear();
+    await this.persist();
+  }
+  // ---- Avisos y disco ----------------------------------------------------------
+  onChange(listener) {
+    this.changeListeners.add(listener);
+    return () => this.changeListeners.delete(listener);
+  }
+  /** Hay que cerrar las ventanas de ese equipo; con null, las de todos. */
+  onRevoked(listener) {
+    this.revokedListeners.add(listener);
+    return () => this.revokedListeners.delete(listener);
+  }
+  emitChange() {
+    for (const listener of this.changeListeners) listener();
+  }
+  /** Escribe los equipos y anota cómo quedó el archivo, para no tomarlo por un cambio ajeno. Nunca rechaza. */
+  async persist() {
+    try {
+      await this.store.save(this.book.snapshot());
+      this.stamps.devices = await this.store.stamp();
+    } catch (error) {
+      this.log.warn("[remote] couldn't save the paired devices:", error instanceof Error ? error.message : String(error));
+    }
+  }
+  /** Escribe lo pendiente y espera. Nunca rechaza. */
+  async flush() {
+    if (this.touchTimer !== null) clearTimeout(this.touchTimer);
+    this.touchTimer = null;
+    await this.persistTouches().catch(() => void 0);
+    await this.store.flush();
+  }
+  /** Frena los relojes. Lo que quede por guardar lo escribe `flush()`. */
+  dispose() {
+    this.stopPairing();
+    this.phoneSeed = null;
+    if (this.pollTimer !== null) clearInterval(this.pollTimer);
+    this.pollTimer = null;
+  }
+};
+
+// packages/server/src/remote-devices-store.ts
+import { chmod, mkdir as mkdir6, readFile as readFile9, stat as stat16 } from "node:fs/promises";
+import path31 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 stat15, writeFile as writeFile3 } from "node:fs/promises";
+
+// packages/server/src/vault/paths.ts
+import { createHash as createHash2 } from "node:crypto";
+import path30 from "node:path";
+function defaultVaultDir() {
+  return path30.join(appConfigDir(), "vault");
+}
+function vaultMarkerFile(dir) {
+  return path30.join(dir, "vault.json");
+}
+function sessionsRoot2(dir) {
+  return path30.join(dir, "sessions");
+}
+function isSafeSessionId(sessionId) {
+  return isVaultSessionId(sessionId);
+}
+function isSessionAgentId(value) {
+  return SESSION_AGENT_IDS.includes(value);
+}
+function assertSessionKey(agent, sessionId) {
+  if (!isSessionAgentId(agent)) throw new Error(`Unknown source for the local copy: ${JSON.stringify(agent)}`);
+  if (!isSafeSessionId(sessionId)) throw new Error(`Session id that isn't copied: ${JSON.stringify(sessionId)}`);
+}
+function agentSessionsDir(dir, agent) {
+  if (!isSessionAgentId(agent)) throw new Error(`Unknown source for the local copy: ${JSON.stringify(agent)}`);
+  return path30.join(sessionsRoot2(dir), agent);
+}
+function sessionFile(dir, agent, sessionId) {
+  assertSessionKey(agent, sessionId);
+  return path30.join(sessionsRoot2(dir), agent, `${sessionId}.jsonl`);
+}
+function assetsDir(dir, agent, sessionId) {
+  assertSessionKey(agent, sessionId);
+  return path30.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 path30.join(assetsDir(dir, agent, sessionId), asset);
+}
+function projectFolderName(cwd, platform) {
+  const hash = createHash2("sha256").update(normalizeCwdKey(cwd, platform)).digest("hex").slice(0, 8);
+  const base = (platform === "win32" ? path30.win32 : path30.posix).basename(cwd);
+  const name = base.length === 0 ? "proyecto" : sanitizeFileName(base, 60);
+  return `${name}-${hash}`;
+}
+function memoryDir(dir, cwd, platform) {
+  return path30.join(dir, "memory", projectFolderName(cwd, platform));
+}
+function projectExportDir(dir, cwd, platform) {
+  return path30.join(dir, "export", projectFolderName(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 path30.join(dir, "export", `${name}-${hash}`);
+}
+function sessionExportFile(dir, agent, sessionId) {
+  assertSessionKey(agent, sessionId);
+  return path30.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) {
+  const limit = Math.max(1, Math.floor(max));
+  const kept = text.normalize("NFC").replace(/[^\p{L}\p{M}\p{N} ._-]/gu, "_");
+  const trimEnds = (value) => value.replace(/^ +/u, "").replace(/[. ]+$/u, "");
+  let name = trimEnds(Array.from(trimEnds(kept)).slice(0, limit).join(""));
+  if (name.length === 0) return "_";
+  const stem = (name.split(".")[0] ?? "").replace(/ +$/u, "");
+  if (RESERVED_WINDOWS_NAME.test(stem)) {
+    name = `_${Array.from(name).slice(0, limit - 1).join("")}`;
+    name = name.replace(/[. ]+$/u, "");
+  }
+  return name;
+}
+
+// packages/server/src/vault/write.ts
+var RENAME_RETRIES = 3;
+var RENAME_RETRY_MS = 100;
+var DEFAULT_WRITE_DEPS = {
+  rename: rename3,
+  platform: process.platform,
+  delay: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  now: () => Date.now()
+};
+function temporaryPathFor(target) {
+  return `${target}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
+}
+function isRetryableRename(error, platform) {
+  if (platform !== "win32") return false;
+  const code = error?.code;
+  return code === "EPERM" || code === "EBUSY";
+}
+async function writeFileAtomic(target, data, deps = DEFAULT_WRITE_DEPS) {
+  const temporary = temporaryPathFor(target);
+  try {
+    await writeFile3(temporary, data);
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        await deps.rename(temporary, target);
+        return;
+      } catch (error) {
+        if (attempt >= RENAME_RETRIES || !isRetryableRename(error, deps.platform)) throw error;
+        await deps.delay(RENAME_RETRY_MS);
+      }
+    }
+  } catch (error) {
+    await rm2(temporary, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function ensureVaultMarker(dir, deps = DEFAULT_WRITE_DEPS) {
+  const marker = vaultMarkerFile(dir);
+  try {
+    await stat15(marker);
+    return;
+  } catch {
+  }
+  await mkdir5(dir, { recursive: true });
+  await writeFileAtomic(marker, `${JSON.stringify({ format: VAULT_FORMAT, createdAt: deps.now() })}
+`, deps);
+}
+async function assetPresent(file, size) {
+  try {
+    const info = await stat15(file);
+    return info.isFile() && info.size === size;
+  } catch {
+    return false;
+  }
+}
+async function writeSessionFile(dir, serialized, deps = DEFAULT_WRITE_DEPS) {
+  const { agent, sessionId } = serialized.header;
+  const file = sessionFile(dir, agent, sessionId);
+  await ensureVaultMarker(dir, deps);
+  await mkdir5(agentSessionsDir(dir, agent), { recursive: true });
+  let assetsWritten = 0;
+  let assetBytesWritten = 0;
+  if (serialized.assets.size > 0) {
+    await mkdir5(assetsDir(dir, agent, sessionId), { recursive: true });
+    for (const [name, bytes] of serialized.assets) {
+      const target = assetFile(dir, agent, sessionId, name);
+      if (await assetPresent(target, bytes.length)) continue;
+      await writeFileAtomic(target, bytes, deps);
+      assetsWritten += 1;
+      assetBytesWritten += bytes.length;
+    }
+  }
+  const text = Buffer.from(serialized.text, "utf8");
+  await writeFileAtomic(file, text, deps);
+  return { file, bytes: text.length, assetsWritten, assetBytesWritten };
+}
+
+// packages/server/src/remote-devices-store.ts
+var RemoteDevicesStore = class {
+  /** La ruta y el aviso son inyectables para las pruebas. */
+  constructor(filePath = remoteDevicesPath(), log = console) {
+    this.filePath = filePath;
+    this.log = log;
+  }
+  filePath;
+  log;
+  /** Las escrituras, en fila: dos seguidas no se pisan. */
+  queue = Promise.resolve();
+  async load() {
+    let raw;
+    try {
+      raw = await readFile9(this.filePath, "utf8");
+    } catch {
+      return [];
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      this.log.warn("[remote] remote-devices.json isn't valid JSON: no paired devices are loaded");
+      return [];
+    }
+    const devices = parseRemoteDevicesFile(parsed);
+    if (devices === null) {
+      this.log.warn("[remote] remote-devices.json is from another version: no paired devices are loaded");
+      return [];
+    }
+    return devices;
+  }
+  save(devices) {
+    const text = serializeRemoteDevices(devices);
+    const run = async () => {
+      await mkdir6(path31.dirname(this.filePath), { recursive: true });
+      await writeFileAtomic(this.filePath, text);
+      await chmod(this.filePath, 384).catch(() => void 0);
+    };
+    const result = this.queue.then(run);
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+  /** Espera lo que quede por escribir. Nunca rechaza. */
+  flush() {
+    return this.queue;
+  }
+  /**
+   * Una marca que cambia cuando el archivo cambia (fecha y tamaño), o '' si no
+   * está. Es lo que mira otra instancia de la app para enterarse de que acá se
+   * revocó un equipo: comparten la carpeta de configuración.
+   */
+  async stamp() {
+    try {
+      const info = await stat16(this.filePath);
+      return `${info.mtimeMs}:${info.size}`;
+    } catch {
+      return "";
+    }
+  }
+};
+
+// packages/server/src/security.ts
+import { randomBytes as randomBytes3, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+var LOOPBACK_HOST = "127.0.0.1";
+var ALLOWED_HOSTNAMES = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
+var TOKEN_HEADER = "x-agent-workbench-token";
+var TOKEN_COOKIE = "agent_workbench_token";
+function createSessionToken() {
+  return randomBytes3(32).toString("base64url");
+}
+function constantTimeEquals(a, b) {
+  const bufferA = Buffer.from(a, "utf8");
+  const bufferB = Buffer.from(b, "utf8");
+  if (bufferA.length !== bufferB.length) return false;
+  return timingSafeEqual2(bufferA, bufferB);
+}
+function requestUrl(request) {
+  try {
+    return new URL(request.url ?? "/", `http://${request.headers.host ?? LOOPBACK_HOST}`);
+  } catch {
+    return null;
+  }
+}
+function readCookie(request, name) {
+  const header = request.headers.cookie;
+  if (typeof header !== "string") return null;
+  for (const pair of header.split(";")) {
+    const separator = pair.indexOf("=");
+    if (separator === -1) continue;
+    if (pair.slice(0, separator).trim() !== name) continue;
+    const value = pair.slice(separator + 1).trim();
+    return value.length > 0 ? decodeURIComponent(value) : null;
+  }
+  return null;
+}
+function matchToken(request, expected) {
+  const url = requestUrl(request);
+  const fromQuery = url?.searchParams.get(TOKEN_QUERY_PARAM) ?? null;
+  if (fromQuery !== null && constantTimeEquals(fromQuery, expected)) {
+    return { source: "query" };
+  }
+  const fromHeader = request.headers[TOKEN_HEADER];
+  if (typeof fromHeader === "string" && constantTimeEquals(fromHeader, expected)) {
+    return { source: "header" };
+  }
+  const fromCookie = readCookie(request, TOKEN_COOKIE);
+  if (fromCookie !== null && constantTimeEquals(fromCookie, expected)) {
+    return { source: "cookie" };
+  }
+  return null;
+}
+function buildTokenCookie(token) {
+  return `${TOKEN_COOKIE}=${encodeURIComponent(token)}; Path=/; SameSite=Strict; HttpOnly`;
+}
+var DEVICE_COOKIE = "agent_workbench_device";
+var DEVICE_COOKIE_MAX_AGE_S = 400 * 24 * 60 * 60;
+function buildDeviceCookie(credential) {
+  return `${DEVICE_COOKIE}=${encodeURIComponent(credential)}; Path=/; Max-Age=${DEVICE_COOKIE_MAX_AGE_S}; SameSite=Strict; HttpOnly`;
+}
+function matchCredential(request, token, devices) {
+  const session = matchToken(request, token);
+  if (session !== null) return { kind: "session", source: session.source };
+  if (devices === null) return null;
+  const credential = readCookie(request, DEVICE_COOKIE);
+  if (credential === null) return null;
+  const device = devices.match(credential);
+  return device === null ? null : { kind: "device", deviceId: device.id, credential };
+}
+function readPairingCode(request) {
+  const code = requestUrl(request)?.searchParams.get(PAIR_QUERY_PARAM) ?? null;
+  return code !== null && code.length > 0 ? code : null;
+}
+function hasValidHost(request, port) {
+  const host = request.headers.host;
+  if (typeof host !== "string") return false;
+  const separator = host.lastIndexOf(":");
+  const hostname = separator === -1 ? host : host.slice(0, separator);
+  const hostPort = separator === -1 ? "" : host.slice(separator + 1);
+  if (!ALLOWED_HOSTNAMES.has(hostname)) return false;
+  return hostPort === "" || hostPort === String(port);
+}
+function hasValidOrigin(request, port) {
+  const origin = request.headers.origin;
+  if (typeof origin !== "string" || origin.length === 0) return true;
+  let parsed;
+  try {
+    parsed = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+  if (!ALLOWED_HOSTNAMES.has(parsed.hostname)) return false;
+  return parsed.port === String(port);
+}
+function authorizeRequest(request, port, token, devices) {
+  if (!hasValidHost(request, port)) return { ok: false, reason: "bad-host" };
+  if (!hasValidOrigin(request, port)) return { ok: false, reason: "bad-origin" };
+  const credential = matchCredential(request, token, devices);
+  return credential === null ? { ok: false, reason: "bad-token" } : { ok: true, credential };
+}
+
+// packages/server/src/repo-hub.ts
+import { EventEmitter as EventEmitter2 } from "node:events";
+import chokidar from "chokidar";
+
+// packages/server/src/git-repo.ts
+import { execFile as execFile4 } from "node:child_process";
+import { readFile as readFile10 } from "node:fs/promises";
+import path32 from "node:path";
+function gitOutputText(output, command) {
+  return output.length > 0 ? serverText("raw", { text: output }) : serverText("gitCommandFailed", { command });
+}
+var MAX_CHANGES = 2e3;
+var MAX_DIFF_LINES = 4e3;
+var MAX_DIFF_BYTES = 512 * 1024;
+var GIT_TIMEOUT_MS = 15e3;
+var GIT_MAX_BUFFER = 32 * 1024 * 1024;
+function isMissingBinary(error) {
+  return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+var GitMissingError = class extends Error {
+  constructor() {
+    super("git wasn't found in the PATH.");
+    this.name = "GitMissingError";
+  }
+};
+function runGit(cwd, args) {
+  return new Promise((resolve, reject) => {
+    execFile4(
+      "git",
+      [
+        // Sin esto git escapa los no-ASCII en octal y un archivo con acento
+        // vuelve ilegible.
+        "-c",
+        "core.quotepath=false",
+        // Esta app corre `git status` sola, cada pocos segundos, mientras el
+        // usuario trabaja. Sin esta bandera `status` refresca y **escribe** el
+        // indice, y eso trae dos problemas: toma `index.lock`, con lo que puede
+        // hacer fallar un `git add` que el usuario esta escribiendo en la
+        // terminal, y modifica `.git/index`, que es justo lo que observa
+        // nuestro watcher — o sea que cada lectura se dispara a si misma.
+        "--no-optional-locks",
+        ...args
+      ],
+      {
+        cwd,
+        timeout: GIT_TIMEOUT_MS,
+        maxBuffer: GIT_MAX_BUFFER,
+        windowsHide: true,
+        encoding: "utf8"
+      },
+      (error, stdout, stderr) => {
+        if (error !== null && isMissingBinary(error)) {
+          reject(new GitMissingError());
+          return;
+        }
+        const code = error !== null && typeof error.code === "number" ? error.code : error !== null ? 1 : 0;
+        resolve({ stdout, stderr, code });
+      }
+    );
+  });
+}
+function toPosix(value) {
+  return value.split("\\").join("/");
+}
+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: path32.resolve(root), message: null };
+  }
+  const stderr = result.stderr.trim();
+  if (/not a git repository|no es un repositorio/i.test(stderr)) {
+    return { state: "not-a-repo", root: "", message: null };
+  }
+  if (stderr.length === 0 && result.code !== 0) {
+    return {
+      state: "error",
+      root: "",
+      message: serverText("gitRunFailed")
+    };
+  }
+  return {
+    state: "error",
+    root: "",
+    message: gitOutputText(stderr.slice(0, 400), "rev-parse")
+  };
+}
+async function findRepoRoot(cwd) {
+  const lookup = await resolveRepo(cwd);
+  return lookup.state === "ready" ? lookup.root : null;
+}
+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 ? path32.resolve(dir) : null;
+}
+function letterToKind(letter) {
+  switch (letter) {
+    case "A":
+      return "added";
+    case "M":
+      return "modified";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "C":
+      return "copied";
+    case "T":
+      return "type-changed";
+    default:
+      return "modified";
+  }
+}
+function parsePorcelainV2(raw) {
+  const fields = raw.split("\0");
+  const parsed = {
+    branch: null,
+    head: null,
+    upstream: null,
+    ahead: 0,
+    behind: 0,
     changes: [],
     truncated: false
   };
@@ -10948,7 +11914,7 @@ function parseWorktrees(raw, currentRoot) {
     worktrees.push({
       path: current.path,
       branch: current.branch,
-      isCurrent: path30.resolve(current.path) === path30.resolve(currentRoot)
+      isCurrent: path32.resolve(current.path) === path32.resolve(currentRoot)
     });
     current = null;
   };
@@ -11091,7 +12057,7 @@ function looksBinary(buffer) {
 async function readUntrackedAsDiff(absolutePath, relativePath) {
   let content;
   try {
-    content = await readFile9(absolutePath);
+    content = await readFile10(absolutePath);
   } catch {
     return {
       path: relativePath,
@@ -11139,7 +12105,7 @@ async function readUntrackedAsDiff(absolutePath, relativePath) {
 async function readDiff(options) {
   const { repoRoot: repoRoot2, relativePath, staged, untracked } = options;
   if (untracked && !staged) {
-    return readUntrackedAsDiff(path30.join(repoRoot2, relativePath), relativePath);
+    return readUntrackedAsDiff(path32.join(repoRoot2, relativePath), relativePath);
   }
   const args = [
     "diff",
@@ -11178,7 +12144,7 @@ async function filterIgnored(repoRoot2, relativePaths) {
   const ignored = /* @__PURE__ */ new Set();
   if (relativePaths.length === 0) return ignored;
   const result = await new Promise((resolve) => {
-    const child = execFile3(
+    const child = execFile4(
       "git",
       ["-c", "core.quotepath=false", "check-ignore", "--stdin", "-z"],
       { cwd: repoRoot2, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER, windowsHide: true },
@@ -11359,24 +12325,24 @@ 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 path32 from "node:path";
+import path34 from "node:path";
 import chokidar2 from "chokidar";
 
 // packages/server/src/memory-bridge.ts
-import { execFile as execFile4 } from "node:child_process";
-import { randomBytes as randomBytes3 } from "node:crypto";
+import { execFile as execFile5 } from "node:child_process";
+import { randomBytes as randomBytes4 } from "node:crypto";
 import {
-  mkdir as mkdir5,
+  mkdir as mkdir7,
   open as open6,
   readdir as readdir9,
-  readFile as readFile10,
+  readFile as readFile11,
   realpath as realpath2,
-  rename as rename3,
-  stat as stat15,
+  rename as rename4,
+  stat as stat17,
   unlink as unlink3
 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
-import path31 from "node:path";
+import path33 from "node:path";
 var MemoryBridgeError = class extends ServerTextError {
 };
 var MAX_LISTED_NOTES = 500;
@@ -11394,9 +12360,9 @@ var GITIGNORE_MEMORY_LINE = `${MEMORY_DIR}/`;
 var BOM2 = Buffer.from([239, 187, 191]);
 async function inspectMemory(cwd, home = homedir9()) {
   await assertMemoryDirInside(cwd);
-  const folder = path31.join(cwd, MEMORY_DIR);
+  const folder = path33.join(cwd, MEMORY_DIR);
   const folderExists = await isDirectory2(folder);
-  const indexExists = folderExists && await isFile(path31.join(folder, MEMORY_INDEX_FILE));
+  const indexExists = folderExists && await isFile(path33.join(folder, MEMORY_INDEX_FILE));
   const noteNames = folderExists ? await listNoteFiles(folder) : [];
   const notes = await describeNotes(folder, noteNames);
   const files = await Promise.all(
@@ -11428,7 +12394,7 @@ async function installMemory(cwd, options, home = homedir9()) {
 }
 async function importNativeMemory(cwd, home = homedir9()) {
   await assertMemoryDirInside(cwd);
-  if (!await isDirectory2(path31.join(cwd, MEMORY_DIR))) {
+  if (!await isDirectory2(path33.join(cwd, MEMORY_DIR))) {
     throw new MemoryBridgeError(serverText("memoryNotInstalled"));
   }
   const plan = new PlanBuilder(cwd);
@@ -11446,9 +12412,9 @@ async function readMemoryNote(cwd, name) {
   }
   const absolute = await resolveInside(cwd, `${MEMORY_DIR}/${name}`);
   try {
-    const info = await stat15(absolute);
+    const info = await stat17(absolute);
     if (!info.isFile()) return null;
-    const content = await readFile10(absolute);
+    const content = await readFile11(absolute);
     return {
       name,
       text: content.subarray(0, MAX_NOTE_BYTES).toString("utf8"),
@@ -11463,7 +12429,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 (path31.basename(name) !== name) return false;
+  if (path33.basename(name) !== name) return false;
   if (/[\\/:*?"<>|\u0000-\u001f]/.test(name)) return false;
   return name.toLowerCase().endsWith(".md");
 }
@@ -11500,7 +12466,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(path31.join(this.cwd, MEMORY_DIR))) {
+    for (const name of await listNoteFiles(path33.join(this.cwd, MEMORY_DIR))) {
       names.set(name.toLowerCase(), name);
     }
     for (const rel of this.files.keys()) {
@@ -11543,7 +12509,7 @@ var PlanBuilder = class {
         continue;
       }
       const target = await realpath2(absolute);
-      const info = await stat15(target);
+      const info = await stat17(target);
       if (info.nlink > 1) {
         throw new MemoryBridgeError(serverText("memoryHardLinks", { file: file.rel }));
       }
@@ -11562,7 +12528,7 @@ var PlanBuilder = class {
     );
     if (pending.length === 0) return;
     if (pending.some((file) => file.rel.startsWith(`${MEMORY_DIR}/`))) {
-      await mkdir5(path31.join(this.cwd, MEMORY_DIR), { recursive: true });
+      await mkdir7(path33.join(this.cwd, MEMORY_DIR), { recursive: true });
     }
     for (const file of pending) {
       if (file.target === null) throw new Error(`Unvalidated plan: ${file.rel}`);
@@ -11673,7 +12639,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(path31.join(folder, name), name);
+      const content = await readIfFile(path33.join(folder, name), name);
       if (content === null) continue;
       const already = chosen.get(key);
       if (already !== void 0) {
@@ -11687,7 +12653,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", "", path31.join(folder, name));
+      plan.put(`${MEMORY_DIR}/${name}`, null, content, "copy", "", path33.join(folder, name));
       copied.push(name);
     }
   }
@@ -11697,7 +12663,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(path31.join(folder, MEMORY_INDEX_FILE), MEMORY_INDEX_FILE);
+      const nativeIndex = await readIfFile(path33.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];
@@ -11922,7 +12888,7 @@ async function describeNotes(folder, names) {
   const stated = [];
   for (const name of names) {
     try {
-      const info = await stat15(path31.join(folder, name));
+      const info = await stat17(path33.join(folder, name));
       if (info.isFile()) stated.push({ name, sizeBytes: info.size, modifiedAt: info.mtimeMs });
     } catch {
     }
@@ -11930,7 +12896,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(path31.join(folder, item.name));
+    const head = await readHead(path33.join(folder, item.name));
     notes.push({ ...item, ...describeNoteText(head, item.name) });
   }
   return notes;
@@ -11988,28 +12954,28 @@ async function countNativeMemory(cwd, home, sharedNames) {
   return { available: names.size, pending };
 }
 async function nativeMemoryFolders(cwd, home) {
-  const root = path31.join(home, ".claude", "projects");
+  const root = path33.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) => path31.join(root, name, "memory"));
+    return entries.filter((entry) => entry.isDirectory() && entry.name.toLowerCase() === slug).map((entry) => entry.name).sort().map((name) => path33.join(root, name, "memory"));
   } catch {
     return [];
   }
 }
 function buildGlobalFragments(home) {
   const windows = process.platform === "win32";
-  const globalFile = path31.join(home, ...GLOBAL_MEMORY_RELATIVE.split("/"));
+  const globalFile = path33.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 = path31.join(home, ".codex", "AGENTS.md");
-  const geminiTarget = path31.join(home, ".gemini", "GEMINI.md");
+  const codexTarget = path33.join(home, ".codex", "AGENTS.md");
+  const geminiTarget = path33.join(home, ".gemini", "GEMINI.md");
   const homeSlashes = home.replace(/\\/g, "/").replace(/\/+$/, "");
   return [
     {
       agent: "claude-code",
       label: MEMORY_AGENT_LABELS["claude-code"],
-      target: path31.join(home, ".claude", "CLAUDE.md"),
+      target: path33.join(home, ".claude", "CLAUDE.md"),
       kind: "line",
       text: `@~/${GLOBAL_MEMORY_RELATIVE}`,
       note: serverText("memoryNoteClaude")
@@ -12033,7 +12999,7 @@ function buildGlobalFragments(home) {
     {
       agent: "opencode",
       label: MEMORY_AGENT_LABELS.opencode,
-      target: path31.join(home, ".config", "opencode", "opencode.json"),
+      target: path33.join(home, ".config", "opencode", "opencode.json"),
       kind: "json",
       text: `"instructions": ["${homeSlashes}/${GLOBAL_MEMORY_RELATIVE}"]`,
       note: serverText("memoryNoteOpenCode")
@@ -12042,7 +13008,7 @@ function buildGlobalFragments(home) {
 }
 function runGit2(cwd, args) {
   return new Promise((resolve) => {
-    execFile4(
+    execFile5(
       "git",
       ["-c", "core.quotepath=false", "--no-optional-locks", ...args],
       { cwd, timeout: GIT_TIMEOUT_MS2, windowsHide: true, encoding: "utf8", maxBuffer: 1024 * 1024 },
@@ -12081,17 +13047,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 = path31.resolve(cwd, gitDir);
-  const absoluteCommonDir = path31.resolve(cwd, commonDir);
+  const absoluteGitDir = path33.resolve(cwd, gitDir);
+  const absoluteCommonDir = path33.resolve(cwd, commonDir);
   let worktree = null;
   let main2 = null;
   if (!await samePath(absoluteGitDir, absoluteCommonDir)) {
-    if (path31.basename(absoluteCommonDir).toLowerCase() === ".git") {
-      const mainRoot = path31.dirname(absoluteCommonDir);
-      const inner = path31.relative(path31.resolve(toplevel), path31.resolve(cwd));
-      const sameFolder = inner.length === 0 || inner.startsWith("..") || path31.isAbsolute(inner);
-      const mainPath = sameFolder ? mainRoot : path31.join(mainRoot, inner);
-      const memoryRel = sameFolder ? MEMORY_DIR : [...inner.split(path31.sep), MEMORY_DIR].join("/");
+    if (path33.basename(absoluteCommonDir).toLowerCase() === ".git") {
+      const mainRoot = path33.dirname(absoluteCommonDir);
+      const inner = path33.relative(path33.resolve(toplevel), path33.resolve(cwd));
+      const sameFolder = inner.length === 0 || inner.startsWith("..") || path33.isAbsolute(inner);
+      const mainPath = sameFolder ? mainRoot : path33.join(mainRoot, inner);
+      const memoryRel = sameFolder ? MEMORY_DIR : [...inner.split(path33.sep), MEMORY_DIR].join("/");
       main2 = { root: mainRoot, memoryRel };
       worktree = {
         mainPath,
@@ -12116,7 +13082,7 @@ async function samePath(a, b) {
     try {
       return await realpath2(value);
     } catch {
-      return path31.resolve(value);
+      return path33.resolve(value);
     }
   };
   const [left, right] = await Promise.all([resolve(a), resolve(b)]);
@@ -12158,9 +13124,9 @@ async function listNoteFiles(folder) {
 }
 async function readIfFile(absolute, label) {
   try {
-    const info = await stat15(absolute);
+    const info = await stat17(absolute);
     if (!info.isFile()) throw new MemoryBridgeError(serverText("memoryNotAFile", { label }));
-    return await readFile10(absolute);
+    return await readFile11(absolute);
   } catch (error) {
     if (isNotFound(error)) return null;
     throw error;
@@ -12182,14 +13148,14 @@ async function readHead(absolute) {
 }
 async function isFile(absolute) {
   try {
-    return (await stat15(absolute)).isFile();
+    return (await stat17(absolute)).isFile();
   } catch {
     return false;
   }
 }
 async function isDirectory2(absolute) {
   try {
-    return (await stat15(absolute)).isDirectory();
+    return (await stat17(absolute)).isDirectory();
   } catch {
     return false;
   }
@@ -12207,7 +13173,7 @@ async function writeAtomic(target, content, mustNotExist) {
       await handle.close();
     }
     if (mustNotExist && await exists2(target)) {
-      throw new MemoryBridgeError(serverText("memoryAppeared", { file: path31.basename(target) }));
+      throw new MemoryBridgeError(serverText("memoryAppeared", { file: path33.basename(target) }));
     }
     await renameWithRetry(temporary, target);
   } catch (error) {
@@ -12217,10 +13183,10 @@ async function writeAtomic(target, content, mustNotExist) {
 }
 async function createTemporary(target) {
   for (let attempt = 1; ; attempt += 1) {
-    const suffix = randomBytes3(6).toString("hex");
-    const temporary = path31.join(
-      path31.dirname(target),
-      `.${path31.basename(target)}.${process.pid}.${suffix}.tmp`
+    const suffix = randomBytes4(6).toString("hex");
+    const temporary = path33.join(
+      path33.dirname(target),
+      `.${path33.basename(target)}.${process.pid}.${suffix}.tmp`
     );
     try {
       return { temporary, handle: await open6(temporary, "wx") };
@@ -12232,7 +13198,7 @@ async function createTemporary(target) {
 }
 async function exists2(absolute) {
   try {
-    await stat15(absolute);
+    await stat17(absolute);
     return true;
   } catch {
     return false;
@@ -12241,7 +13207,7 @@ async function exists2(absolute) {
 async function renameWithRetry(from, to) {
   for (let attempt = 1; ; attempt += 1) {
     try {
-      await rename3(from, to);
+      await rename4(from, to);
       return;
     } catch (error) {
       const code = error.code;
@@ -12458,13 +13424,13 @@ var MemoryHub = class extends EventEmitter3 {
   }
 };
 function keyFor(cwd) {
-  const resolved = path32.resolve(cwd);
+  const resolved = path34.resolve(cwd);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function isRelevantPath(cwd, candidate) {
-  const relative = path32.relative(cwd, candidate);
+  const relative = path34.relative(cwd, candidate);
   if (relative.length === 0) return true;
-  if (relative.startsWith("..") || path32.isAbsolute(relative)) return false;
+  if (relative.startsWith("..") || path34.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;
@@ -12481,10 +13447,10 @@ function isRelevantPath(cwd, candidate) {
 }
 
 // packages/server/src/paste-store.ts
-import { createHash, randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir6, readdir as readdir10, rm as rm2, stat as stat16, writeFile as writeFile3 } from "node:fs/promises";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir as mkdir8, readdir as readdir10, rm as rm3, stat as stat18, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import path33 from "node:path";
+import path35 from "node:path";
 
 // packages/server/src/vault/markdown.ts
 var pad2 = (value) => String(value).padStart(2, "0");
@@ -12999,8 +13965,8 @@ function buildContinuationMessage(input) {
   }
   return sanitizeForPaste(lines.join("\n"));
 }
-function transcriptReferenceFor(path48, style) {
-  return style === "at-quoted" ? fileReference(path48, "at-quoted") : `"${path48}"`;
+function transcriptReferenceFor(path50, style) {
+  return style === "at-quoted" ? fileReference(path50, "at-quoted") : `"${path50}"`;
 }
 function planTranscript(input) {
   const turns = splitTurns(input.events);
@@ -13175,7 +14141,7 @@ var PasteStore = class {
   root;
   counter = 0;
   constructor(root) {
-    this.root = root ?? path33.join(tmpdir4(), "agent-workbench", "pasted");
+    this.root = root ?? path35.join(tmpdir4(), "agent-workbench", "pasted");
   }
   /**
    * Guarda una imagen y devuelve su ruta.
@@ -13202,12 +14168,12 @@ var PasteStore = class {
     if (signature === null) {
       throw new PasteImageError(serverText("imageUnknownFormat"));
     }
-    const directory = path33.join(this.root, safeSegment(terminalId));
-    await mkdir6(directory, { recursive: true, mode: DIRECTORY_MODE });
+    const directory = path35.join(this.root, safeSegment(terminalId));
+    await mkdir8(directory, { recursive: true, mode: DIRECTORY_MODE });
     this.counter += 1;
-    const name = `pegada-${this.counter}-${randomUUID2().slice(0, 8)}.${signature.ext}`;
-    const file = path33.join(directory, name);
-    await writeFile3(file, bytes, { mode: FILE_MODE });
+    const name = `pegada-${this.counter}-${randomUUID3().slice(0, 8)}.${signature.ext}`;
+    const file = path35.join(directory, name);
+    await writeFile4(file, bytes, { mode: FILE_MODE });
     return { path: file, bytes: bytes.length };
   }
   /**
@@ -13224,12 +14190,12 @@ 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 = path33.join(this.root, safeSegment(terminalId));
-    await mkdir6(directory, { recursive: true, mode: DIRECTORY_MODE });
+    const directory = path35.join(this.root, safeSegment(terminalId));
+    await mkdir8(directory, { recursive: true, mode: DIRECTORY_MODE });
     this.counter += 1;
-    const name = `${baseName}-${this.counter}-${randomUUID2().slice(0, 8)}.md`;
-    const file = path33.join(directory, name);
-    await writeFile3(file, bytes, { mode: FILE_MODE });
+    const name = `${baseName}-${this.counter}-${randomUUID3().slice(0, 8)}.md`;
+    const file = path35.join(directory, name);
+    await writeFile4(file, bytes, { mode: FILE_MODE });
     return { path: file, bytes: bytes.length };
   }
   /**
@@ -13258,17 +14224,17 @@ var PasteStore = class {
         })
       );
     }
-    const directory = path33.join(this.root, safeSegment(terminalId));
-    await mkdir6(directory, { recursive: true, mode: DIRECTORY_MODE });
+    const directory = path35.join(this.root, safeSegment(terminalId));
+    await mkdir8(directory, { recursive: true, mode: DIRECTORY_MODE });
     this.counter += 1;
-    const name = `adjunto-${this.counter}-${randomUUID2().slice(0, 8)}-${safe}`;
-    const file = path33.join(directory, name);
-    await writeFile3(file, bytes, { mode: FILE_MODE });
+    const name = `adjunto-${this.counter}-${randomUUID3().slice(0, 8)}-${safe}`;
+    const file = path35.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 rm2(path33.join(this.root, safeSegment(terminalId)), {
+    await rm3(path35.join(this.root, safeSegment(terminalId)), {
       recursive: true,
       force: true
     }).catch(() => {
@@ -13290,11 +14256,11 @@ var PasteStore = class {
     }
     await Promise.all(
       entries.map(async (entry) => {
-        const full = path33.join(this.root, entry);
+        const full = path35.join(this.root, entry);
         try {
-          const info = await stat16(full);
+          const info = await stat18(full);
           if (now - info.mtimeMs > STALE_AFTER_MS) {
-            await rm2(full, { recursive: true, force: true });
+            await rm3(full, { recursive: true, force: true });
           }
         } catch {
         }
@@ -13304,13 +14270,13 @@ var PasteStore = class {
 };
 function safeSegment(value) {
   const clean = value.replace(/[^a-zA-Z0-9_-]/g, "");
-  return clean.length > 0 ? clean : createHash("sha1").update(value).digest("hex").slice(0, 16);
+  return clean.length > 0 ? clean : createHash3("sha1").update(value).digest("hex").slice(0, 16);
 }
 
 // packages/server/src/session-index.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
-import { mkdir as mkdir7, readFile as readFile11, stat as stat17, writeFile as writeFile4 } from "node:fs/promises";
-import path34 from "node:path";
+import { mkdir as mkdir9, readFile as readFile12, stat as stat19, writeFile as writeFile5 } from "node:fs/promises";
+import path36 from "node:path";
 var CACHE_VERSION = 4;
 var vaultPairKey = (agent, sessionId) => `${agent}/${sessionId}`;
 function vaultOnlySessions(natives, vault, listState, ready) {
@@ -13359,7 +14325,7 @@ function cacheKey(agent, ref) {
 }
 async function pathExists3(candidate) {
   try {
-    await stat17(candidate);
+    await stat19(candidate);
     return true;
   } catch {
     return false;
@@ -13409,7 +14375,7 @@ function migrateEntryV3(filePath, value) {
   return {
     agent: "claude-code",
     ref: filePath,
-    group: path34.basename(path34.dirname(filePath)),
+    group: path36.basename(path36.dirname(filePath)),
     mtimeMs,
     sizeBytes,
     cwd,
@@ -13674,7 +14640,7 @@ var SessionIndex = class extends EventEmitter4 {
   }
   async loadCache() {
     try {
-      const raw = await readFile11(sessionIndexCachePath(), "utf8");
+      const raw = await readFile12(sessionIndexCachePath(), "utf8");
       const parsed = JSON.parse(raw);
       const migrated = migrateIndexCache(parsed);
       if (migrated === null) return;
@@ -13687,8 +14653,8 @@ var SessionIndex = class extends EventEmitter4 {
     if (!this.cacheDirty) return;
     this.cacheDirty = false;
     try {
-      await mkdir7(appConfigDir(), { recursive: true });
-      await writeFile4(sessionIndexCachePath(), JSON.stringify(this.cache), "utf8");
+      await mkdir9(appConfigDir(), { recursive: true });
+      await writeFile5(sessionIndexCachePath(), JSON.stringify(this.cache), "utf8");
     } catch (error) {
       console.warn("[index] couldn't save the cache:", error);
     }
@@ -13865,199 +14831,42 @@ var SessionIndex = class extends EventEmitter4 {
     let refs;
     try {
       refs = await history.changedRefs(filePath);
-    } catch {
-      refs = null;
-    }
-    if (refs === null || refs.length === 0) return;
-    let changed = false;
-    for (const ref of refs) {
-      const key = cacheKey(agent, ref);
-      const cachedBefore = this.cache.entries[key];
-      if (cachedBefore !== void 0) {
-        delete this.cache.entries[key];
-        this.cacheDirty = true;
-      }
-      let indexed;
-      try {
-        const item = await history.item(ref);
-        indexed = item === null ? null : await this.readOrThrow(agent, history, item);
-      } catch {
-        if (cachedBefore !== void 0 && !(key in this.cache.entries)) this.cache.entries[key] = cachedBefore;
-        continue;
-      }
-      if (indexed === null) {
-        if (this.sessions.delete(key)) changed = true;
-        continue;
-      }
-      if (indexed.cwd !== null) this.cwdExists.set(indexed.cwd, await pathExists3(indexed.cwd));
-      this.sessions.set(key, indexed);
-      changed = true;
-    }
-    if (changed) this.emitProjects();
-    await this.saveCache();
-  }
-};
-
-// packages/server/src/settings-store.ts
-import { mkdir as mkdir9, readFile as readFile12 } from "node:fs/promises";
-import path36 from "node:path";
-
-// packages/server/src/vault/write.ts
-import { randomBytes as randomBytes4 } from "node:crypto";
-import { mkdir as mkdir8, rename as rename4, rm as rm3, stat as stat18, writeFile as writeFile5 } from "node:fs/promises";
-
-// packages/server/src/vault/paths.ts
-import { createHash as createHash2 } from "node:crypto";
-import path35 from "node:path";
-function defaultVaultDir() {
-  return path35.join(appConfigDir(), "vault");
-}
-function vaultMarkerFile(dir) {
-  return path35.join(dir, "vault.json");
-}
-function sessionsRoot2(dir) {
-  return path35.join(dir, "sessions");
-}
-function isSafeSessionId(sessionId) {
-  return isVaultSessionId(sessionId);
-}
-function isSessionAgentId(value) {
-  return SESSION_AGENT_IDS.includes(value);
-}
-function assertSessionKey(agent, sessionId) {
-  if (!isSessionAgentId(agent)) throw new Error(`Unknown source for the local copy: ${JSON.stringify(agent)}`);
-  if (!isSafeSessionId(sessionId)) throw new Error(`Session id that isn't copied: ${JSON.stringify(sessionId)}`);
-}
-function agentSessionsDir(dir, agent) {
-  if (!isSessionAgentId(agent)) throw new Error(`Unknown source for the local copy: ${JSON.stringify(agent)}`);
-  return path35.join(sessionsRoot2(dir), agent);
-}
-function sessionFile(dir, agent, sessionId) {
-  assertSessionKey(agent, sessionId);
-  return path35.join(sessionsRoot2(dir), agent, `${sessionId}.jsonl`);
-}
-function assetsDir(dir, agent, sessionId) {
-  assertSessionKey(agent, sessionId);
-  return path35.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 path35.join(assetsDir(dir, agent, sessionId), asset);
-}
-function projectFolderName(cwd, platform) {
-  const hash = createHash2("sha256").update(normalizeCwdKey(cwd, platform)).digest("hex").slice(0, 8);
-  const base = (platform === "win32" ? path35.win32 : path35.posix).basename(cwd);
-  const name = base.length === 0 ? "proyecto" : sanitizeFileName(base, 60);
-  return `${name}-${hash}`;
-}
-function memoryDir(dir, cwd, platform) {
-  return path35.join(dir, "memory", projectFolderName(cwd, platform));
-}
-function projectExportDir(dir, cwd, platform) {
-  return path35.join(dir, "export", projectFolderName(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 path35.join(dir, "export", `${name}-${hash}`);
-}
-function sessionExportFile(dir, agent, sessionId) {
-  assertSessionKey(agent, sessionId);
-  return path35.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) {
-  const limit = Math.max(1, Math.floor(max));
-  const kept = text.normalize("NFC").replace(/[^\p{L}\p{M}\p{N} ._-]/gu, "_");
-  const trimEnds = (value) => value.replace(/^ +/u, "").replace(/[. ]+$/u, "");
-  let name = trimEnds(Array.from(trimEnds(kept)).slice(0, limit).join(""));
-  if (name.length === 0) return "_";
-  const stem = (name.split(".")[0] ?? "").replace(/ +$/u, "");
-  if (RESERVED_WINDOWS_NAME.test(stem)) {
-    name = `_${Array.from(name).slice(0, limit - 1).join("")}`;
-    name = name.replace(/[. ]+$/u, "");
-  }
-  return name;
-}
-
-// packages/server/src/vault/write.ts
-var RENAME_RETRIES = 3;
-var RENAME_RETRY_MS = 100;
-var DEFAULT_WRITE_DEPS = {
-  rename: rename4,
-  platform: process.platform,
-  delay: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-  now: () => Date.now()
-};
-function temporaryPathFor(target) {
-  return `${target}.${process.pid}.${randomBytes4(6).toString("hex")}.tmp`;
-}
-function isRetryableRename(error, platform) {
-  if (platform !== "win32") return false;
-  const code = error?.code;
-  return code === "EPERM" || code === "EBUSY";
-}
-async function writeFileAtomic(target, data, deps = DEFAULT_WRITE_DEPS) {
-  const temporary = temporaryPathFor(target);
-  try {
-    await writeFile5(temporary, data);
-    for (let attempt = 0; ; attempt += 1) {
+    } catch {
+      refs = null;
+    }
+    if (refs === null || refs.length === 0) return;
+    let changed = false;
+    for (const ref of refs) {
+      const key = cacheKey(agent, ref);
+      const cachedBefore = this.cache.entries[key];
+      if (cachedBefore !== void 0) {
+        delete this.cache.entries[key];
+        this.cacheDirty = true;
+      }
+      let indexed;
       try {
-        await deps.rename(temporary, target);
-        return;
-      } catch (error) {
-        if (attempt >= RENAME_RETRIES || !isRetryableRename(error, deps.platform)) throw error;
-        await deps.delay(RENAME_RETRY_MS);
+        const item = await history.item(ref);
+        indexed = item === null ? null : await this.readOrThrow(agent, history, item);
+      } catch {
+        if (cachedBefore !== void 0 && !(key in this.cache.entries)) this.cache.entries[key] = cachedBefore;
+        continue;
       }
+      if (indexed === null) {
+        if (this.sessions.delete(key)) changed = true;
+        continue;
+      }
+      if (indexed.cwd !== null) this.cwdExists.set(indexed.cwd, await pathExists3(indexed.cwd));
+      this.sessions.set(key, indexed);
+      changed = true;
     }
-  } catch (error) {
-    await rm3(temporary, { force: true }).catch(() => void 0);
-    throw error;
-  }
-}
-async function ensureVaultMarker(dir, deps = DEFAULT_WRITE_DEPS) {
-  const marker = vaultMarkerFile(dir);
-  try {
-    await stat18(marker);
-    return;
-  } catch {
-  }
-  await mkdir8(dir, { recursive: true });
-  await writeFileAtomic(marker, `${JSON.stringify({ format: VAULT_FORMAT, createdAt: deps.now() })}
-`, deps);
-}
-async function assetPresent(file, size) {
-  try {
-    const info = await stat18(file);
-    return info.isFile() && info.size === size;
-  } catch {
-    return false;
-  }
-}
-async function writeSessionFile(dir, serialized, deps = DEFAULT_WRITE_DEPS) {
-  const { agent, sessionId } = serialized.header;
-  const file = sessionFile(dir, agent, sessionId);
-  await ensureVaultMarker(dir, deps);
-  await mkdir8(agentSessionsDir(dir, agent), { recursive: true });
-  let assetsWritten = 0;
-  let assetBytesWritten = 0;
-  if (serialized.assets.size > 0) {
-    await mkdir8(assetsDir(dir, agent, sessionId), { recursive: true });
-    for (const [name, bytes] of serialized.assets) {
-      const target = assetFile(dir, agent, sessionId, name);
-      if (await assetPresent(target, bytes.length)) continue;
-      await writeFileAtomic(target, bytes, deps);
-      assetsWritten += 1;
-      assetBytesWritten += bytes.length;
-    }
+    if (changed) this.emitProjects();
+    await this.saveCache();
   }
-  const text = Buffer.from(serialized.text, "utf8");
-  await writeFileAtomic(file, text, deps);
-  return { file, bytes: text.length, assetsWritten, assetBytesWritten };
-}
+};
 
 // packages/server/src/settings-store.ts
+import { mkdir as mkdir10, readFile as readFile13, stat as stat20 } from "node:fs/promises";
+import path37 from "node:path";
 var SETTINGS_VERSION = 1;
 var VAULT_TOOL_RESULT_DEFAULT_CHARS = 64e3;
 var VAULT_TOOL_RESULT_MIN_CHARS = 4e3;
@@ -14065,13 +14874,14 @@ var VAULT_TOOL_RESULT_MAX_CHARS = 1e6;
 function defaultAppSettings() {
   return {
     version: SETTINGS_VERSION,
-    vault: { enabled: false, dir: null, toolResultMaxChars: VAULT_TOOL_RESULT_DEFAULT_CHARS }
+    vault: { enabled: false, dir: null, toolResultMaxChars: VAULT_TOOL_RESULT_DEFAULT_CHARS },
+    remote: { enabled: false, port: REMOTE_DEFAULT_PORT }
   };
 }
 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 path36.posix.isAbsolute(dir);
+  return path37.posix.isAbsolute(dir);
 }
 function clampToolResultMaxChars(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return VAULT_TOOL_RESULT_DEFAULT_CHARS;
@@ -14081,6 +14891,11 @@ function parseAppSettings(value, platform, warn = () => void 0) {
   const record = asRecord(value);
   if (record === null || record["version"] !== SETTINGS_VERSION) return null;
   const settings2 = defaultAppSettings();
+  const remote = asRecord(record["remote"]);
+  if (remote !== null) {
+    settings2.remote.enabled = asBoolean(remote["enabled"]) ?? false;
+    if (isRemotePort(remote["port"])) settings2.remote.port = remote["port"];
+  }
   const vault = asRecord(record["vault"]);
   if (vault === null) return settings2;
   settings2.vault.enabled = asBoolean(vault["enabled"]) ?? false;
@@ -14094,7 +14909,11 @@ function parseAppSettings(value, platform, warn = () => void 0) {
   return settings2;
 }
 function frozen(settings2) {
-  return Object.freeze({ ...settings2, vault: Object.freeze({ ...settings2.vault }) });
+  return Object.freeze({
+    ...settings2,
+    vault: Object.freeze({ ...settings2.vault }),
+    remote: Object.freeze({ ...settings2.remote })
+  });
 }
 var SettingsStore = class {
   /** La ruta es inyectable para las pruebas; por defecto, la de la carpeta de configuracion. */
@@ -14113,7 +14932,7 @@ var SettingsStore = class {
   async load() {
     let raw;
     try {
-      raw = await readFile12(this.filePath, "utf8");
+      raw = await readFile13(this.filePath, "utf8");
     } catch {
       this.current = frozen(defaultAppSettings());
       return;
@@ -14132,17 +14951,49 @@ var SettingsStore = class {
     }
     this.current = frozen(settings2 ?? defaultAppSettings());
   }
+  /**
+   * Relee **solo** lo del acceso remoto (hito 37). Otra instancia de la app
+   * comparte este archivo, y "apagar" desde una tiene que valer en la que tiene
+   * el puerto; lo de la copia propia no se toca, que cada instancia lo lleva en
+   * memoria como siempre. Sin archivo o ilegible, queda lo que habia.
+   */
+  async reloadRemote() {
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile13(this.filePath, "utf8"));
+    } catch {
+      return;
+    }
+    const settings2 = parseAppSettings(parsed, this.platform);
+    if (settings2 === null) return;
+    this.current = frozen({ ...this.current, remote: settings2.remote });
+  }
+  /** Una marca que cambia cuando el archivo cambia (fecha y tamano), o '' si no esta. */
+  async stamp() {
+    try {
+      const info = await stat20(this.filePath);
+      return `${info.mtimeMs}:${info.size}`;
+    } catch {
+      return "";
+    }
+  }
   /** Lo ultimo que quedo escrito. Congelado: nadie de afuera lo cambia sin pasar por `update`. */
   get() {
     return this.current;
   }
   /**
-   * Aplica un cambio y lo escribe. Lanza si la carpeta no es absoluta o si no
-   * se pudo escribir; en los dos casos `get()` sigue dando lo anterior.
+   * Aplica un cambio y lo escribe. Lanza si la carpeta no es absoluta, si el
+   * puerto no sirve o si no se pudo escribir; en todos los casos `get()` sigue
+   * dando lo anterior.
    */
   update(patch) {
     const run = async () => {
-      const next = { version: SETTINGS_VERSION, vault: { ...this.current.vault } };
+      if (patch.remote === void 0) await this.reloadRemote();
+      const next = {
+        version: SETTINGS_VERSION,
+        vault: { ...this.current.vault },
+        remote: { ...this.current.remote }
+      };
       const vault = patch.vault ?? {};
       if (vault.enabled !== void 0) next.vault.enabled = vault.enabled;
       if (vault.dir !== void 0) {
@@ -14154,7 +15005,13 @@ var SettingsStore = class {
       if (vault.toolResultMaxChars !== void 0) {
         next.vault.toolResultMaxChars = clampToolResultMaxChars(vault.toolResultMaxChars);
       }
-      await mkdir9(path36.dirname(this.filePath), { recursive: true });
+      const remote = patch.remote ?? {};
+      if (remote.enabled !== void 0) next.remote.enabled = remote.enabled;
+      if (remote.port !== void 0) {
+        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(path37.dirname(this.filePath), { recursive: true });
       await writeFileAtomic(this.filePath, `${JSON.stringify(next, null, 2)}
 `);
       this.current = frozen(next);
@@ -14181,6 +15038,19 @@ function statusLineStartupText(state) {
       return "couldn't read its settings.json";
   }
 }
+var REMOTE_ACCESS_LABEL = "Remote access";
+function remoteAccessStartupLine(state, port, pairedDevices) {
+  switch (state) {
+    case "off":
+      return null;
+    case "active":
+      return `  ${REMOTE_ACCESS_LABEL}  on, port ${port}, ${pairedDevices} paired device${pairedDevices === 1 ? "" : "s"}`;
+    case "port-busy":
+      return `  ${REMOTE_ACCESS_LABEL}  NOT WORKING: port ${port} is busy (another Agent Workbench, or another program)`;
+    case "restart-needed":
+      return `  ${REMOTE_ACCESS_LABEL}  on, takes effect after a restart`;
+  }
+}
 var AVAILABLE_AGENTS_LABEL = "Available CLIs";
 var HISTORY_LABEL = "History";
 function missingText(text) {
@@ -14219,11 +15089,18 @@ function startupAgentLines(agents) {
   }
   return lines;
 }
+var SUPPORT_LABEL = "Support";
+function supportStartupLine() {
+  return `  ${SUPPORT_LABEL}      If Agent Workbench is useful to you, consider supporting it: ${SUPPORT_URL}`;
+}
+function supportStartupLineColored() {
+  return `  \x1B[95m${SUPPORT_LABEL}\x1B[0m      \x1B[33mIf Agent Workbench is useful to you, consider supporting it:\x1B[0m \x1B[4;94m${SUPPORT_URL}\x1B[0m`;
+}
 
 // packages/server/src/notes-store.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { mkdir as mkdir10, readFile as readFile13, rename as rename5, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
-import path37 from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { mkdir as mkdir11, readFile as readFile14, rename as rename5, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
+import path38 from "node:path";
 var STATE_VERSION2 = 1;
 var WRITE_DEBOUNCE_MS2 = 500;
 var NotesError = class extends ServerTextError {
@@ -14266,7 +15143,7 @@ var NotesStore = class {
   }
   async load() {
     try {
-      const raw = await readFile13(this.statePath, "utf8");
+      const raw = await readFile14(this.statePath, "utf8");
       this.notes = parseState2(raw) ?? [];
     } catch {
       this.notes = [];
@@ -14350,11 +15227,11 @@ var NotesStore = class {
       throw new NotesError(serverText("imageUnknownFormat"));
     }
     const image = {
-      imageId: randomUUID3(),
+      imageId: randomUUID4(),
       mediaType: format.mediaType,
       bytes: bytes.length
     };
-    await mkdir10(this.imagesDir, { recursive: true });
+    await mkdir11(this.imagesDir, { recursive: true });
     await writeFile6(this.imagePath(image), bytes);
     note.images.push(image);
     note.updatedAt = now;
@@ -14383,7 +15260,7 @@ var NotesStore = class {
     const image = this.findImage(imageId);
     if (image === null) return null;
     try {
-      const bytes = await readFile13(this.imagePath(image));
+      const bytes = await readFile14(this.imagePath(image));
       return { mediaType: image.mediaType, data: bytes.toString("base64") };
     } catch {
       return null;
@@ -14403,7 +15280,7 @@ var NotesStore = class {
     const images = [];
     for (const image of note.images) {
       try {
-        const bytes = await readFile13(this.imagePath(image));
+        const bytes = await readFile14(this.imagePath(image));
         images.push({ mediaType: image.mediaType, data: bytes.toString("base64") });
       } catch {
       }
@@ -14427,7 +15304,7 @@ var NotesStore = class {
   }
   imagePath(image) {
     const safe = image.imageId.replace(/[^a-zA-Z0-9-]/g, "");
-    return path37.join(this.imagesDir, `${safe}.${extensionFor(image.mediaType)}`);
+    return path38.join(this.imagesDir, `${safe}.${extensionFor(image.mediaType)}`);
   }
   async unlinkImage(image) {
     await rm4(this.imagePath(image), { force: true }).catch(() => {
@@ -14445,8 +15322,8 @@ var NotesStore = class {
   async writeNow() {
     this.dirty = false;
     try {
-      await mkdir10(path37.dirname(this.statePath), { recursive: true });
-      const temporary = path37.join(path37.dirname(this.statePath), `notes.${process.pid}.tmp`);
+      await mkdir11(path38.dirname(this.statePath), { recursive: true });
+      const temporary = path38.join(path38.dirname(this.statePath), `notes.${process.pid}.tmp`);
       await writeFile6(
         temporary,
         JSON.stringify({ version: STATE_VERSION2, notes: this.notes }, null, 2),
@@ -14459,10 +15336,226 @@ var NotesStore = class {
   }
 };
 
+// packages/server/src/draft-store.ts
+import { mkdir as mkdir12, readFile as readFile15, rename as rename6, writeFile as writeFile7 } from "node:fs/promises";
+import path39 from "node:path";
+var STATE_VERSION3 = 1;
+var WRITE_DEBOUNCE_MS3 = 500;
+var MAX_STORED_DRAFTS = 100;
+function draftOwnerOf(descriptor) {
+  if (descriptor === null || descriptor.kind !== "agent" || descriptor.agent === null) return null;
+  if (descriptor.sessionId.length === 0) return null;
+  return { agent: descriptor.agent, sessionId: descriptor.sessionId };
+}
+function workspaceDraftOwners(state) {
+  const owners = state.tabs.map(({ agent, sessionId }) => ({ agent, sessionId }));
+  for (const { raw } of state.foreignTabs) {
+    const agent = raw["agent"];
+    const sessionId = raw["sessionId"];
+    if (typeof agent === "string" && typeof sessionId === "string") owners.push({ agent, sessionId });
+  }
+  return owners;
+}
+var DraftTabs = class {
+  seen = /* @__PURE__ */ new Set();
+  owners = /* @__PURE__ */ new Map();
+  update(descriptors) {
+    const appeared = [];
+    const moved = [];
+    const present = /* @__PURE__ */ new Set();
+    for (const descriptor of descriptors) {
+      const { terminalId } = descriptor;
+      present.add(terminalId);
+      if (!this.seen.has(terminalId)) appeared.push(descriptor);
+      const current = draftOwnerOf(descriptor);
+      if (current === null) continue;
+      const previous = this.owners.get(terminalId);
+      if (previous !== void 0 && keyOf(previous) !== keyOf(current)) moved.push({ from: previous, to: current });
+      this.owners.set(terminalId, current);
+    }
+    for (const terminalId of [...this.owners.keys()]) {
+      if (!present.has(terminalId)) this.owners.delete(terminalId);
+    }
+    this.seen = present;
+    return { appeared, moved };
+  }
+};
+function keyOf(owner) {
+  return JSON.stringify([owner.agent, owner.sessionId]);
+}
+function copyOf(draft) {
+  return { text: draft.text, pasted: draft.pasted.map((paste) => ({ ...paste })) };
+}
+function parseEntry(value) {
+  const record = asRecord(value);
+  if (record === null) return null;
+  const agent = asNonEmptyString(record["agent"]);
+  const sessionId = asNonEmptyString(record["sessionId"]);
+  const draft = parseComposerDraft(record["draft"]);
+  const updatedAt = asFiniteNumber(record["updatedAt"]);
+  if (agent === null || sessionId === null || draft === null || updatedAt === null) return null;
+  if (isEmptyComposerDraft(draft) || composerDraftChars(draft) > MAX_COMPOSER_DRAFT_CHARS) return null;
+  return { agent, sessionId, draft, updatedAt };
+}
+function parseState3(raw) {
+  const drafts = /* @__PURE__ */ new Map();
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return drafts;
+  }
+  const record = asRecord(parsed);
+  if (record === null || record["version"] !== STATE_VERSION3) return drafts;
+  for (const entry of asArrayFiltered(record["drafts"], parseEntry) ?? []) drafts.set(keyOf(entry), entry);
+  return drafts;
+}
+function trimOldest(drafts) {
+  if (drafts.size <= MAX_STORED_DRAFTS) return [];
+  const oldest = [...drafts.entries()].sort(([, a], [, b]) => a.updatedAt - b.updatedAt).slice(0, drafts.size - MAX_STORED_DRAFTS).map(([key]) => key);
+  for (const key of oldest) drafts.delete(key);
+  return oldest;
+}
+var DraftStore = class {
+  drafts = /* @__PURE__ */ new Map();
+  /** Las claves que cambiaron aca desde la ultima escritura: lo unico que se escribe. */
+  changed = /* @__PURE__ */ new Set();
+  writeTimer = null;
+  /** La escritura en curso: van de a una, porque dos se pisarian el temporal. */
+  writing = Promise.resolve();
+  statePath;
+  now;
+  /** Ruta y reloj inyectables para las pruebas; por defecto, la carpeta de configuracion. */
+  constructor(options = {}) {
+    this.statePath = options.statePath ?? composerDraftsPath();
+    this.now = options.now ?? Date.now;
+  }
+  async load() {
+    try {
+      this.drafts = parseState3(await readFile15(this.statePath, "utf8"));
+    } catch {
+      this.drafts = /* @__PURE__ */ new Map();
+    }
+  }
+  /** El borrador guardado de una conversacion, o null. Una copia. */
+  get(owner) {
+    const stored = this.drafts.get(keyOf(owner));
+    return stored === void 0 ? null : copyOf(stored.draft);
+  }
+  /** Cuantos hay. Para las pruebas. */
+  get size() {
+    return this.drafts.size;
+  }
+  save(owner, draft) {
+    if (composerDraftChars(draft) > MAX_COMPOSER_DRAFT_CHARS) {
+      this.delete(owner);
+      return "too-long";
+    }
+    if (isEmptyComposerDraft(draft)) return this.delete(owner) ? "deleted" : "unchanged";
+    const key = keyOf(owner);
+    const current = this.drafts.get(key);
+    if (current !== void 0 && sameComposerDraft(current.draft, draft)) return "unchanged";
+    this.drafts.set(key, { agent: owner.agent, sessionId: owner.sessionId, draft: copyOf(draft), updatedAt: this.now() });
+    this.changed.add(key);
+    for (const gone of trimOldest(this.drafts)) this.changed.add(gone);
+    this.schedule();
+    return "saved";
+  }
+  /** Borra el de esa conversacion: se mando, o se cerro su pestana. false si no habia. */
+  delete(owner) {
+    const key = keyOf(owner);
+    if (!this.drafts.delete(key)) return false;
+    this.changed.add(key);
+    this.schedule();
+    return true;
+  }
+  /**
+   * La pestana cambio de conversacion —una CLI que la descubre, o que empieza
+   * otra con `/clear`— y su borrador va con ella: es lo que se restaura con la
+   * pestana, que desde ahora se guarda con el id nuevo.
+   */
+  move(from, to) {
+    const fromKey = keyOf(from);
+    const stored = this.drafts.get(fromKey);
+    if (stored === void 0 || fromKey === keyOf(to)) return;
+    this.delete(from);
+    this.save(to, stored.draft);
+  }
+  /**
+   * Deja solo los de estas conversaciones: las pestanas del archivo del
+   * arranque. Lo demas es de una pestana que ya no esta —se cerro con una build
+   * anterior, o su carpeta se borro— y nadie lo va a pedir.
+   */
+  retainOnly(owners) {
+    const keep = new Set([...owners].map(keyOf));
+    let removed = false;
+    for (const key of [...this.drafts.keys()]) {
+      if (keep.has(key)) continue;
+      this.drafts.delete(key);
+      this.changed.add(key);
+      removed = true;
+    }
+    if (removed) this.schedule();
+  }
+  /** Escritura inmediata, para el apagado. */
+  async flush() {
+    if (this.writeTimer !== null) {
+      clearTimeout(this.writeTimer);
+      this.writeTimer = null;
+    }
+    await this.write();
+  }
+  schedule() {
+    if (this.writeTimer !== null) return;
+    this.writeTimer = setTimeout(() => {
+      this.writeTimer = null;
+      void this.write();
+    }, WRITE_DEBOUNCE_MS3);
+    this.writeTimer.unref();
+  }
+  write() {
+    const run = async () => {
+      if (this.changed.size > 0) await this.writeNow();
+    };
+    this.writing = this.writing.then(run, run);
+    return this.writing;
+  }
+  async writeNow() {
+    let onDisk = /* @__PURE__ */ new Map();
+    try {
+      onDisk = parseState3(await readFile15(this.statePath, "utf8"));
+    } catch {
+    }
+    const changed = this.changed;
+    this.changed = /* @__PURE__ */ new Set();
+    const merged = onDisk;
+    for (const key of changed) {
+      const mine = this.drafts.get(key);
+      if (mine === void 0) merged.delete(key);
+      else merged.set(key, mine);
+    }
+    trimOldest(merged);
+    this.drafts = new Map(merged);
+    try {
+      await mkdir12(path39.dirname(this.statePath), { recursive: true });
+      const temporary = path39.join(path39.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 }))
+      };
+      await writeFile7(temporary, JSON.stringify(payload, null, 2), { encoding: "utf8", mode: 384 });
+      await rename6(temporary, this.statePath);
+    } catch (error) {
+      for (const key of changed) this.changed.add(key);
+      console.warn("[drafts] couldn't save the message box drafts:", error);
+    }
+  }
+};
+
 // packages/server/src/shell-locator.ts
 import { access as access2 } from "node:fs/promises";
 import { constants as fsConstants2 } from "node:fs";
-import path38 from "node:path";
+import path40 from "node:path";
 async function isExecutable(candidate) {
   try {
     await access2(candidate, process.platform === "win32" ? fsConstants2.R_OK : fsConstants2.X_OK);
@@ -14474,7 +15567,7 @@ async function isExecutable(candidate) {
 function windowsPowerShellPath() {
   const systemRoot = process.env["SystemRoot"] ?? process.env["windir"];
   if (systemRoot === void 0 || systemRoot.length === 0) return null;
-  return path38.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  return path40.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
 }
 async function locateWindowsShell() {
   const pwsh = await findInPath("pwsh");
@@ -14494,7 +15587,7 @@ async function locateWindowsShell() {
 async function locatePosixShell() {
   const preferred = process.env["SHELL"];
   if (preferred !== void 0 && preferred.length > 0 && await isExecutable(preferred)) {
-    return { file: preferred, args: [], name: path38.basename(preferred) };
+    return { file: preferred, args: [], name: path40.basename(preferred) };
   }
   if (await isExecutable("/bin/bash")) return { file: "/bin/bash", args: [], name: "bash" };
   if (await isExecutable("/bin/sh")) return { file: "/bin/sh", args: [], name: "sh" };
@@ -14505,13 +15598,13 @@ async function locateShell() {
 }
 
 // packages/server/src/session-watcher.ts
-import { stat as stat19 } from "node:fs/promises";
+import { stat as stat21 } 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 stat19(target)).isDirectory();
+    return (await stat21(target)).isDirectory();
   } catch {
     return false;
   }
@@ -14612,9 +15705,9 @@ function watchSessions(index, hub, agents, options = {}) {
 }
 
 // packages/server/src/terminal-registry.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { EventEmitter as EventEmitter5 } from "node:events";
-import { stat as stat20 } from "node:fs/promises";
+import { stat as stat22 } from "node:fs/promises";
 
 // packages/server/src/launch-hook-slot.ts
 var LaunchHookSlot = class {
@@ -14876,10 +15969,10 @@ async function resolveLaunchPlan(launch) {
 }
 
 // packages/server/src/workspace-store.ts
-import { mkdir as mkdir11, readFile as readFile14, writeFile as writeFile7 } from "node:fs/promises";
-import path39 from "node:path";
-var STATE_VERSION3 = 1;
-var WRITE_DEBOUNCE_MS3 = 400;
+import { mkdir as mkdir13, readFile as readFile16, writeFile as writeFile8 } from "node:fs/promises";
+import path41 from "node:path";
+var STATE_VERSION4 = 1;
+var WRITE_DEBOUNCE_MS4 = 400;
 var LEGACY_TAB_AGENT = "claude-code";
 function placeByPosition(base, placed) {
   const result = [...base];
@@ -14935,11 +16028,11 @@ function readTab(tab, missingAgent) {
   if (agent === null) return null;
   return { kind: "known", tab: { agent, cwd, sessionId, label: typeof label === "string" ? label : "" } };
 }
-function parseState3(raw) {
+function parseState4(raw) {
   try {
     const parsed = JSON.parse(raw);
     if (!isRecord(parsed)) return null;
-    if (parsed["version"] !== STATE_VERSION3) return null;
+    if (parsed["version"] !== STATE_VERSION4) return null;
     const rawTabs = parsed["tabs"];
     if (!Array.isArray(rawTabs)) return null;
     const base = [];
@@ -14977,7 +16070,7 @@ function serializeState(state) {
       otherTabs.push({ ...entry.tab, position });
     }
   }
-  return otherTabs.length === 0 ? { version: STATE_VERSION3, tabs } : { version: STATE_VERSION3, tabs, otherTabs };
+  return otherTabs.length === 0 ? { version: STATE_VERSION4, tabs } : { version: STATE_VERSION4, tabs, otherTabs };
 }
 var EMPTY_STATE = () => ({ tabs: [], foreignTabs: [] });
 function persistableTabs(descriptors) {
@@ -14999,8 +16092,8 @@ var WorkspaceStore = class {
   pending = null;
   async load() {
     try {
-      const raw = await readFile14(workspaceStatePath(), "utf8");
-      return parseState3(raw) ?? EMPTY_STATE();
+      const raw = await readFile16(workspaceStatePath(), "utf8");
+      return parseState4(raw) ?? EMPTY_STATE();
     } catch {
       return EMPTY_STATE();
     }
@@ -15014,7 +16107,7 @@ var WorkspaceStore = class {
       const toWrite = this.pending;
       this.pending = null;
       if (toWrite !== null) void this.writeNow(toWrite);
-    }, WRITE_DEBOUNCE_MS3);
+    }, WRITE_DEBOUNCE_MS4);
     this.writeTimer.unref();
   }
   /** Escritura inmediata, para el apagado. */
@@ -15029,12 +16122,12 @@ var WorkspaceStore = class {
   }
   async writeNow(state) {
     try {
-      await mkdir11(appConfigDir(), { recursive: true });
+      await mkdir13(appConfigDir(), { recursive: true });
       const target = workspaceStatePath();
-      const temporary = path39.join(path39.dirname(target), `workspace.${process.pid}.tmp`);
-      await writeFile7(temporary, JSON.stringify(serializeState(state), null, 2), "utf8");
-      const { rename: rename6 } = await import("node:fs/promises");
-      await rename6(temporary, target);
+      const temporary = path41.join(path41.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);
     } catch (error) {
       console.warn("[workspace] couldn't save the state:", error);
     }
@@ -15151,14 +16244,14 @@ var TerminalRegistry = class extends EventEmitter5 {
     }
     await this.assertDirectory(options.cwd);
     const resumed = kind === "agent" && options.resumeSessionId !== void 0;
-    const terminalId = randomUUID4();
+    const terminalId = randomUUID5();
     const descriptor = {
       terminalId,
       kind,
       agent,
       cwd: options.cwd,
       // Provisional: `spawn` lo confirma con lo que diga el adaptador.
-      sessionId: kind === "agent" ? options.resumeSessionId ?? randomUUID4() : "",
+      sessionId: kind === "agent" ? options.resumeSessionId ?? randomUUID5() : "",
       label: options.label ?? "",
       resumed,
       createdAt: Date.now(),
@@ -15262,7 +16355,7 @@ var TerminalRegistry = class extends EventEmitter5 {
   async assertDirectory(cwd) {
     let info;
     try {
-      info = await stat20(cwd);
+      info = await stat22(cwd);
     } catch {
       throw new TerminalOpenError("invalid-cwd", serverText("cwdMissing", { cwd }));
     }
@@ -15290,7 +16383,7 @@ var TerminalRegistry = class extends EventEmitter5 {
     let launch;
     let adapter = null;
     let launchedSessionId = sessionId;
-    const launchToken = randomUUID4();
+    const launchToken = randomUUID5();
     if (launcher.kind === "agent") {
       adapter = launcher.agent.adapter;
       const { location } = launcher.agent;
@@ -15526,7 +16619,7 @@ var TerminalRegistry = class extends EventEmitter5 {
         console.warn(`[workspace] the tab of ${tab.cwd} wasn't restored: ${reason2}`);
         continue;
       }
-      const terminalId = randomUUID4();
+      const terminalId = randomUUID5();
       const descriptor = {
         terminalId,
         kind: "agent",
@@ -15688,20 +16781,20 @@ var TerminalRegistry = class extends EventEmitter5 {
 import { WebSocketServer } from "ws";
 
 // packages/server/src/directory-picker.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
-import { mkdir as mkdir12, readdir as readdir11, stat as stat21 } from "node:fs/promises";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { mkdir as mkdir14, readdir as readdir11, stat as stat23 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
-import path40 from "node:path";
+import path42 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 = path40.resolve(target);
+  const resolved = path42.resolve(target);
   return dirs.some((dir) => {
-    const protectedDir = path40.resolve(dir);
-    return resolved === protectedDir || resolved.startsWith(protectedDir + path40.sep);
+    const protectedDir = path42.resolve(dir);
+    return resolved === protectedDir || resolved.startsWith(protectedDir + path42.sep);
   });
 }
 async function listRoots() {
@@ -15713,7 +16806,7 @@ async function listRoots() {
       letters.map(async (letter) => {
         const drive = `${letter}:\\`;
         try {
-          await stat21(drive);
+          await stat23(drive);
           return drive;
         } catch {
           return null;
@@ -15740,7 +16833,7 @@ var DirectoryPickers = class {
     if (this.pickers.size >= MAX_PICKERS) {
       throw new DirectoryPickerError(serverText("pickerTooMany"));
     }
-    const picker = { id: randomUUID5(), current: homedir11(), entries: /* @__PURE__ */ new Set() };
+    const picker = { id: randomUUID6(), current: homedir11(), entries: /* @__PURE__ */ new Set() };
     this.pickers.set(picker.id, picker);
     return this.listing(picker);
   }
@@ -15765,14 +16858,14 @@ var DirectoryPickers = class {
   async enter(pickerId, name) {
     const picker = this.require(pickerId);
     if (name === "..") {
-      const parent = path40.dirname(picker.current);
+      const parent = path42.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 = path40.join(picker.current, name);
+    const target = path42.join(picker.current, name);
     if (isInsideProtected(target, this.protectedDirs)) {
       throw new DirectoryPickerError(serverText("pickerCliFolder"));
     }
@@ -15812,12 +16905,12 @@ var DirectoryPickers = class {
         throw new DirectoryPickerError(serverText("pickerNameChars"));
       }
     }
-    const target = path40.join(picker.current, clean);
+    const target = path42.join(picker.current, clean);
     if (isInsideProtected(target, this.protectedDirs)) {
       throw new DirectoryPickerError(serverText("pickerNoProjectsHere"));
     }
     try {
-      await mkdir12(target);
+      await mkdir14(target);
     } catch (error) {
       const code = error.code;
       throw new DirectoryPickerError(
@@ -15849,7 +16942,7 @@ var DirectoryPickers = class {
     let truncated = false;
     try {
       const found = await readdir11(picker.current, { withFileTypes: true });
-      const dirs = found.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !SKIPPED.has(name)).filter((name) => !isInsideProtected(path40.join(picker.current, name), this.protectedDirs)).sort((a, b) => a.localeCompare(b));
+      const dirs = found.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !SKIPPED.has(name)).filter((name) => !isInsideProtected(path42.join(picker.current, name), this.protectedDirs)).sort((a, b) => a.localeCompare(b));
       truncated = dirs.length > MAX_ENTRIES;
       names = dirs.slice(0, MAX_ENTRIES);
     } catch {
@@ -15860,15 +16953,15 @@ var DirectoryPickers = class {
       path: picker.current,
       entries: names,
       roots,
-      canGoUp: path40.dirname(picker.current) !== picker.current,
+      canGoUp: path42.dirname(picker.current) !== picker.current,
       truncated
     };
   }
 };
 
 // packages/server/src/file-browser.ts
-import { readFile as readFile15, readdir as readdir12, stat as stat22 } from "node:fs/promises";
-import path41 from "node:path";
+import { readFile as readFile17, readdir as readdir12, stat as stat24 } from "node:fs/promises";
+import path43 from "node:path";
 var MAX_ENTRIES2 = 1e3;
 var SEARCH_MAX_RESULTS = 200;
 var SEARCH_MAX_DIRECTORIES = 4e3;
@@ -15931,7 +17024,7 @@ function languageFor(fileName) {
   const lower = fileName.toLowerCase();
   const byName = LANGUAGE_BY_NAME[lower];
   if (byName !== void 0) return byName;
-  const extension = path41.extname(lower);
+  const extension = path43.extname(lower);
   return LANGUAGE_BY_EXTENSION[extension] ?? null;
 }
 function looksBinary2(buffer) {
@@ -15963,7 +17056,7 @@ async function listDirectory(cwd, relativePath, options = {}) {
     let sizeBytes = 0;
     let modifiedAt = 0;
     try {
-      const info = await stat22(path41.join(absolute, candidate.name));
+      const info = await stat24(path43.join(absolute, candidate.name));
       sizeBytes = candidate.isDirectory ? 0 : info.size;
       modifiedAt = info.mtimeMs;
     } catch {
@@ -15996,7 +17089,7 @@ async function readLevel(absolute) {
     const always = ALWAYS_SKIP.has(dirent.name.toLowerCase());
     if (dirent.isSymbolicLink()) {
       try {
-        const target = await stat22(path41.join(absolute, dirent.name));
+        const target = await stat24(path43.join(absolute, dirent.name));
         candidates.push({
           name: dirent.name,
           isDirectory: target.isDirectory(),
@@ -16025,7 +17118,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(path41.relative(repoRoot2, path41.join(level.absolute, entry.name))));
+      keys.set(entry, toPosixPath(path43.relative(repoRoot2, path43.join(level.absolute, entry.name))));
     }
   }
   if (keys.size === 0) return;
@@ -16086,7 +17179,7 @@ async function searchFiles(cwd, query, options = {}) {
         let sizeBytes = 0;
         let modifiedAt = 0;
         try {
-          const info = await stat22(path41.join(level.absolute, candidate.name));
+          const info = await stat24(path43.join(level.absolute, candidate.name));
           sizeBytes = candidate.isDirectory ? 0 : info.size;
           modifiedAt = info.mtimeMs;
         } catch {
@@ -16120,12 +17213,12 @@ async function searchFiles(cwd, query, options = {}) {
 }
 async function readPreview(cwd, relativePath) {
   const absolute = await resolveInside(cwd, relativePath, { mustExist: true });
-  const info = await stat22(absolute);
+  const info = await stat24(absolute);
   if (info.isDirectory()) {
     throw new Error("It's a directory, not a file.");
   }
-  const content = await readFile15(absolute);
-  const fileName = path41.basename(absolute);
+  const content = await readFile17(absolute);
+  const fileName = path43.basename(absolute);
   if (looksBinary2(content)) {
     return {
       path: relativePath,
@@ -16714,14 +17807,14 @@ var TerminalWriteQueue = class {
 };
 
 // packages/server/src/vault/service.ts
-import { mkdir as mkdir15, stat as stat26 } from "node:fs/promises";
+import { mkdir as mkdir17, stat as stat28 } from "node:fs/promises";
 import { homedir as homedir12 } from "node:os";
-import path45 from "node:path";
+import path47 from "node:path";
 
 // packages/server/src/vault/move.ts
 import { constants } from "node:fs";
-import { copyFile as copyFile2, lstat, mkdir as mkdir13, readdir as readdir13, rm as rm5, stat as stat23, utimes, writeFile as writeFile8 } from "node:fs/promises";
-import path42 from "node:path";
+import { copyFile as copyFile2, lstat, mkdir as mkdir15, readdir as readdir13, rm as rm5, stat as stat25, utimes, writeFile as writeFile9 } from "node:fs/promises";
+import path44 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) {
@@ -16732,14 +17825,14 @@ async function copyTree(source, target, result) {
     return;
   }
   if (info.isDirectory()) {
-    await mkdir13(target, { recursive: true });
+    await mkdir15(target, { recursive: true });
     for (const name of await readdir13(source)) {
-      await copyTree(path42.join(source, name), path42.join(target, name), result);
+      await copyTree(path44.join(source, name), path44.join(target, name), result);
     }
     return;
   }
   if (!info.isFile() || OWN_TEMP_FILE.test(source)) return;
-  await mkdir13(path42.dirname(target), { recursive: true });
+  await mkdir15(path44.dirname(target), { recursive: true });
   try {
     await copyFile2(source, target, constants.COPYFILE_EXCL);
   } catch (error) {
@@ -16754,9 +17847,9 @@ async function copyTree(source, target, result) {
 }
 async function moveVault(from, to) {
   const result = { copied: 0, skipped: 0 };
-  await mkdir13(to, { recursive: true });
+  await mkdir15(to, { recursive: true });
   for (const entry of MOVED_ENTRIES) {
-    await copyTree(path42.join(from, entry), path42.join(to, entry), result);
+    await copyTree(path44.join(from, entry), path44.join(to, entry), result);
   }
   return result;
 }
@@ -16788,11 +17881,11 @@ function checkVaultTarget(current, target, options) {
   return { kind: "ok" };
 }
 async function canWriteInto(dir) {
-  const probe = temporaryPathFor(path42.join(dir, ".escritura"));
+  const probe = temporaryPathFor(path44.join(dir, ".escritura"));
   try {
-    await mkdir13(dir, { recursive: true });
-    if (!(await stat23(dir)).isDirectory()) return false;
-    await writeFile8(probe, "");
+    await mkdir15(dir, { recursive: true });
+    if (!(await stat25(dir)).isDirectory()) return false;
+    await writeFile9(probe, "");
     return true;
   } catch {
     return false;
@@ -16802,12 +17895,12 @@ async function canWriteInto(dir) {
 }
 
 // packages/server/src/vault/serialize.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function imageKey(eventId, source, index) {
   return `${eventId}|${source}|${index}`;
 }
 function assetName(bytes) {
-  const hash = createHash3("sha256").update(bytes).digest("hex").slice(0, 32);
+  const hash = createHash4("sha256").update(bytes).digest("hex").slice(0, 32);
   return `${hash}.${detectImageFormat(bytes)?.ext ?? "bin"}`;
 }
 function buildHeader(input) {
@@ -16894,12 +17987,12 @@ function serializeSession(input) {
 }
 
 // packages/server/src/vault/writer.ts
-import { readdir as readdir15, rm as rm6, stat as stat25 } from "node:fs/promises";
-import path44 from "node:path";
+import { readdir as readdir15, rm as rm6, stat as stat27 } from "node:fs/promises";
+import path46 from "node:path";
 
 // packages/server/src/vault/memory-copy.ts
-import { mkdir as mkdir14, readdir as readdir14, readFile as readFile16, stat as stat24, utimes as utimes2 } from "node:fs/promises";
-import path43 from "node:path";
+import { mkdir as mkdir16, readdir as readdir14, readFile as readFile18, stat as stat26, utimes as utimes2 } from "node:fs/promises";
+import path45 from "node:path";
 var MEMORY_FILE_MAX_BYTES = 1024 * 1024;
 var MEMORY_MAX_FILES = 500;
 var MEMORY_SOURCE_FILE = "source.json";
@@ -16924,7 +18017,7 @@ async function listMemoryNotes(cwd) {
     let absolute;
     try {
       absolute = await resolveInside(cwd, `${MEMORY_DIR}/${name}`, { mustExist: true });
-      const info = await stat24(absolute);
+      const info = await stat26(absolute);
       if (!info.isFile() || info.size > MEMORY_FILE_MAX_BYTES) continue;
       notes.push({ name, absolute, size: info.size, mtimeMs: info.mtimeMs });
     } catch {
@@ -16938,7 +18031,7 @@ async function measureProjectMemory(cwd) {
 }
 async function isUpToDate(target, note) {
   try {
-    const info = await stat24(target);
+    const info = await stat26(target);
     return info.isFile() && info.size === note.size && Math.abs(info.mtimeMs - note.mtimeMs) < SAME_MTIME_MS;
   } catch {
     return false;
@@ -16946,7 +18039,7 @@ async function isUpToDate(target, note) {
 }
 async function exists3(file) {
   try {
-    await stat24(file);
+    await stat26(file);
     return true;
   } catch {
     return false;
@@ -16962,14 +18055,14 @@ async function copyProjectMemory(dir, cwd, platform, deps = DEFAULT_WRITE_DEPS)
     if (prepared) return;
     prepared = true;
     await ensureVaultMarker(dir, deps);
-    await mkdir14(target, { recursive: true });
+    await mkdir16(target, { recursive: true });
   };
   for (const note of notes) {
-    const destination = path43.join(target, note.name);
+    const destination = path45.join(target, note.name);
     if (await isUpToDate(destination, note)) continue;
     let content;
     try {
-      content = await readFile16(note.absolute);
+      content = await readFile18(note.absolute);
     } catch {
       continue;
     }
@@ -16981,7 +18074,7 @@ async function copyProjectMemory(dir, cwd, platform, deps = DEFAULT_WRITE_DEPS)
     result.files += 1;
     result.bytes += content.length;
   }
-  const source = path43.join(target, MEMORY_SOURCE_FILE);
+  const source = path45.join(target, MEMORY_SOURCE_FILE);
   if (result.files > 0 || !await exists3(source)) {
     await prepare();
     await writeFileAtomic(source, `${JSON.stringify({ cwd, copiedAt: deps.now() })}
@@ -17475,7 +18568,7 @@ var VaultWriter = class {
   }
   async assetOnDisk(dir, agent, sessionId, asset, bytes) {
     try {
-      const info = await stat25(assetFile(dir, agent, sessionId, asset));
+      const info = await stat27(assetFile(dir, agent, sessionId, asset));
       return info.isFile() && info.size === bytes;
     } catch {
       return false;
@@ -17575,17 +18668,17 @@ var VaultWriter = class {
     const folders = [dir];
     const subfolders = async (parent) => {
       try {
-        return (await readdir15(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path44.join(parent, entry.name));
+        return (await readdir15(parent, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path46.join(parent, entry.name));
       } catch {
         return [];
       }
     };
     for (const agentDir of await subfolders(sessionsRoot2(dir))) {
-      if (!SESSION_AGENT_IDS.includes(path44.basename(agentDir))) continue;
+      if (!SESSION_AGENT_IDS.includes(path46.basename(agentDir))) continue;
       folders.push(agentDir);
       folders.push(...(await subfolders(agentDir)).filter((folder) => folder.endsWith(".assets")));
     }
-    folders.push(...await subfolders(path44.join(dir, "memory")));
+    folders.push(...await subfolders(path46.join(dir, "memory")));
     for (const folder of folders) {
       let names;
       try {
@@ -17595,9 +18688,9 @@ var VaultWriter = class {
       }
       for (const name of names) {
         if (!OWN_TEMP_FILE2.test(name)) continue;
-        const file = path44.join(folder, name);
+        const file = path46.join(folder, name);
         try {
-          const info = await stat25(file);
+          const info = await stat27(file);
           if (info.isFile() && now - info.mtimeMs > TEMP_MAX_AGE_MS) await rm6(file, { force: true });
         } catch {
         }
@@ -17785,14 +18878,14 @@ var VaultService = class {
   async setDir(target) {
     const { platform, agents, settings: settings2, catalog } = this.options;
     const current = this.dir();
-    const protectedDirs = [...agents.protectedDirs(), path45.join(this.options.homeDir ?? homedir12(), ".gemini")];
+    const protectedDirs = [...agents.protectedDirs(), path47.join(this.options.homeDir ?? homedir12(), ".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 stat26(vaultMarkerFile(current)).then(
+        const hadCopy = await stat28(vaultMarkerFile(current)).then(
           () => true,
           () => false
         );
@@ -17826,7 +18919,7 @@ var VaultService = class {
   /** Abre la carpeta de la copia con el explorador del sistema. */
   async reveal() {
     const dir = this.activeDir();
-    const isFolder = await stat26(dir).then(
+    const isFolder = await stat28(dir).then(
       (info) => info.isDirectory(),
       () => false
     );
@@ -17850,7 +18943,7 @@ var VaultService = class {
       fromCopy: true
     });
     const file = sessionExportFile(dir, agent, sessionId);
-    await mkdir15(path45.dirname(file), { recursive: true });
+    await mkdir17(path47.dirname(file), { recursive: true });
     await writeFileAtomic(file, text, this.writeDeps);
     this.openWithSystem(file);
     return file;
@@ -17937,7 +19030,7 @@ var VaultService = class {
     const project = this.options.index.getProjects().find((candidate) => candidate.key === projectKey);
     if (project === void 0) throw new VaultError(serverText("vaultProjectGone"));
     const folder = projectExportDirFor(this.activeDir(), project, this.options.platform);
-    await mkdir15(folder, { recursive: true });
+    await mkdir17(folder, { recursive: true });
     const entries = [];
     const names = /* @__PURE__ */ new Set();
     let skipped = 0;
@@ -17954,7 +19047,7 @@ var VaultService = class {
         continue;
       }
       const fileName = this.exportFileName(summary, names);
-      await writeFileAtomic(path45.join(folder, fileName), text, this.writeDeps);
+      await writeFileAtomic(path47.join(folder, fileName), text, this.writeDeps);
       entries.push({
         updatedAt: summary.updatedAt,
         agentLabel: this.labelOf(summary.agent),
@@ -17965,9 +19058,9 @@ var VaultService = class {
       });
       await nextTurn3();
     }
-    const name = project.cwd.length > 0 ? path45.basename(project.cwd) || project.cwd : project.fallbackName;
+    const name = project.cwd.length > 0 ? path47.basename(project.cwd) || project.cwd : project.fallbackName;
     const index = renderProjectIndex({ name, cwd: project.cwd, exportedAt: this.now(), entries, skipped });
-    await writeFileAtomic(path45.join(folder, "index.md"), index, this.writeDeps);
+    await writeFileAtomic(path47.join(folder, "index.md"), index, this.writeDeps);
     this.openWithSystem(folder);
     return { sessions: entries.length, skipped, folder };
   }
@@ -18123,12 +19216,14 @@ function attachTerminalSocket(options) {
     index,
     archived,
     notes,
+    drafts,
     conversations,
     repos,
     memory,
     agents,
     defaultCwd,
-    vault
+    vault,
+    remote
   } = options;
   const pasteStore = options.pasteStore ?? new PasteStore();
   const writeQueue = new TerminalWriteQueue();
@@ -18143,6 +19238,14 @@ function attachTerminalSocket(options) {
       if (socket.readyState === socket.OPEN) socket.send(payload);
     }
   };
+  const remoteSockets = /* @__PURE__ */ new Map();
+  let phonePairingOwner = null;
+  const broadcastToHost = (message) => {
+    const payload = encodeServerMessage(message);
+    for (const socket of clients) {
+      if (!remoteSockets.has(socket) && socket.readyState === socket.OPEN) socket.send(payload);
+    }
+  };
   const broadcastExcept = (except, message) => {
     const payload = encodeServerMessage(message);
     for (const socket of clients) {
@@ -18193,7 +19296,25 @@ function attachTerminalSocket(options) {
     }
     return false;
   };
-  const onRegistryChanged = () => broadcast(terminalListMessage());
+  const draftEntriesOf = (descriptors) => {
+    const entries = [];
+    for (const descriptor of descriptors) {
+      const owner = draftOwnerOf(descriptor);
+      const draft = owner === null ? null : drafts.get(owner);
+      if (draft !== null) entries.push({ terminalId: descriptor.terminalId, draft });
+    }
+    return entries;
+  };
+  const draftTabs = new DraftTabs();
+  draftTabs.update(registry.list());
+  const onRegistryChanged = () => {
+    const terminals = registry.list();
+    broadcast({ type: "terminal.list", terminals, order: registry.getOrder() });
+    const { appeared, moved } = draftTabs.update(terminals);
+    for (const { from, to } of moved) drafts.move(from, to);
+    const entries = draftEntriesOf(appeared);
+    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 }
@@ -18221,7 +19342,9 @@ function attachTerminalSocket(options) {
   };
   const pieceWriter = (socket, terminalId) => (piece) => writeToTerminal(socket, terminalId, piece);
   const dropTab = (terminalId) => {
+    const draftOwner = draftOwnerOf(registry.get(terminalId));
     if (!registry.close(terminalId)) return false;
+    if (draftOwner !== null) drafts.delete(draftOwner);
     conversations.drop(terminalId);
     repos.drop(terminalId);
     memory.drop(terminalId);
@@ -18293,6 +19416,23 @@ function attachTerminalSocket(options) {
   memory.on("status", onMemoryStatus);
   const stopAgentChanges = agents.subscribeChanges(() => broadcast(agentsMessage()));
   const stopVaultStatus = vault.onStatus((status) => broadcast({ type: "vault.status", status }));
+  const stopRemoteStatus = remote.onChange(
+    () => broadcastToHost({ type: "remote.status", status: remote.status() })
+  );
+  const stopRemoteRevoked = remote.onRevoked((deviceId) => {
+    for (const [socket, id] of remoteSockets) {
+      if (deviceId === null || id === deviceId) socket.close(REMOTE_REVOKED_CLOSE_CODE, "revoked");
+    }
+  });
+  const sendRemoteError = (socket, error) => {
+    if (error instanceof ServerTextError) {
+      sendError(socket, "remote-failed", error.text);
+      return;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn("[remote] a request failed:", detail);
+    sendError(socket, "remote-failed", serverText("remoteFailed"), detail);
+  };
   const sendVaultError = (socket, error) => {
     if (error instanceof VaultError) {
       sendError(socket, "vault-failed", error.text);
@@ -18310,20 +19450,25 @@ function attachTerminalSocket(options) {
       return;
     }
     if (pathname !== WS_PATH) return;
-    const rejection = rejectRequest(request, port, token);
-    if (rejection !== null) {
+    const authorization = authorizeRequest(request, port, token, remote.verifier());
+    if (!authorization.ok) {
       socket.write("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
       socket.destroy();
-      console.warn(`[security] upgrade rejected on ${WS_PATH}: ${rejection}`);
+      console.warn(`[security] upgrade rejected on ${WS_PATH}: ${authorization.reason}`);
       return;
     }
     wss.handleUpgrade(request, socket, head, (client) => {
-      wss.emit("connection", client, request);
+      wss.emit("connection", client, request, authorization.credential);
     });
   };
   httpServer.on("upgrade", onUpgrade);
-  wss.on("connection", (socket) => {
+  wss.on("connection", (socket, _request, credential) => {
     clients.add(socket);
+    const deviceId = credential.kind === "device" ? credential.deviceId : null;
+    if (deviceId !== null) {
+      remoteSockets.set(socket, deviceId);
+      remote.noteConnected(deviceId);
+    }
     const listener = (terminalId, chunk) => {
       send(socket, { type: "terminal.output", terminalId, data: chunk });
     };
@@ -18386,7 +19531,8 @@ function attachTerminalSocket(options) {
       defaultAgent: agents.defaultAgent(),
       platform: process.platform,
       defaultCwd,
-      shellName: shell?.name ?? null
+      shellName: shell?.name ?? null,
+      remoteClient: deviceId !== null
     });
     send(socket, terminalListMessage());
     for (const entry of registry.activitySnapshot()) {
@@ -18395,7 +19541,9 @@ function attachTerminalSocket(options) {
     send(socket, { type: "index.status", status: index.getStatus() });
     send(socket, { type: "index.projects", projects: index.getProjects(), replace: true });
     send(socket, { type: "notes.list", notes: notes.list() });
+    send(socket, { type: "composer.drafts", drafts: draftEntriesOf(registry.list()) });
     send(socket, { type: "vault.status", status: vault.status() });
+    if (deviceId === null) send(socket, { type: "remote.status", status: remote.status() });
     socket.on("message", (raw) => {
       const text = Array.isArray(raw) ? Buffer.concat(raw).toString("utf8") : Buffer.from(raw).toString("utf8");
       const message = parseClientMessage(text);
@@ -18405,9 +19553,16 @@ function attachTerminalSocket(options) {
         return;
       }
       if (message.type !== "input") debugLog("socket", `received ${message.type}`);
+      const refusal = remoteRefusal(message.type, deviceId !== null);
+      if (refusal !== null) {
+        sendError(socket, "remote-refused", refusal);
+        return;
+      }
       switch (message.type) {
         case "input":
-          writeToTerminal(socket, message.terminalId, message.data);
+          if (!registry.write(message.terminalId, message.data) && registry.get(message.terminalId) === null) {
+            sendError(socket, "unknown-terminal", serverText("terminalGone"));
+          }
           break;
         /*
                   Un mensaje del cuadro de escritura.
@@ -18423,6 +19578,8 @@ function attachTerminalSocket(options) {
                 */
         case "agent.submit": {
           const { terminalId, text: text2, images } = message;
+          const submittedOwner = draftOwnerOf(registry.get(terminalId));
+          if (submittedOwner !== null) drafts.delete(submittedOwner);
           const files = message.files ?? [];
           if (files.length > MAX_FILES_PER_SUBMIT) {
             sendError(
@@ -18450,7 +19607,7 @@ function attachTerminalSocket(options) {
           if (submitting !== null) {
             const launchedAt = registry.launchedAtOf(terminalId);
             const blind = isBlind();
-            const refusal = submitRefusal({
+            const refusal2 = submitRefusal({
               label: submitting.label,
               approvesPendingOnCycle: guardsPending,
               waitingFor: conversations.getWaitingFor(terminalId),
@@ -18459,8 +19616,8 @@ function attachTerminalSocket(options) {
               blind,
               openToolCall: blind && launchedAt !== null && conversations.hasOpenToolCall(terminalId, launchedAt)
             });
-            if (refusal !== null) {
-              sendError(socket, "submit-failed", refusal);
+            if (refusal2 !== null) {
+              sendError(socket, "submit-failed", refusal2);
               break;
             }
           }
@@ -19131,6 +20288,19 @@ function attachTerminalSocket(options) {
             }
           })();
           break;
+        /*
+          El borrador del cuadro de una pestana, despues de una pausa del
+          teclado (§6.29). No se contesta. Una consola, o una pestana cuya CLI
+          todavia no dijo su conversacion, no tiene donde guardarlo: lo escrito
+          sigue en el cuadro, y se guarda con la pausa siguiente a que aparezca.
+        */
+        case "composer.draft": {
+          const owner = draftOwnerOf(registry.get(message.terminalId));
+          if (owner === null) break;
+          const outcome = drafts.save(owner, message.draft);
+          debugLog("drafts", `${message.terminalId.slice(0, 8)}: ${outcome}`);
+          break;
+        }
         /*
                   Notas sueltas. No van dirigidas a ninguna pestana.
         
@@ -19415,9 +20585,70 @@ function attachTerminalSocket(options) {
         case "search.cancel":
           globalSearch.cancel(message.searchId);
           break;
+        /*
+          El acceso remoto (hito 37). Hasta aca solo llega una ventana del
+          anfitrion: a un equipo remoto lo freno `remoteRefusal`. El estado
+          nuevo sale a las ventanas del anfitrion por `remote.onChange`; aca
+          solo se contesta lo que falla, y el codigo, que va **solo** a quien lo
+          pidio.
+        */
+        case "remote.configure": {
+          const patch = {};
+          if (message.enabled !== void 0) patch.enabled = message.enabled;
+          if (message.port !== void 0) patch.port = message.port;
+          void remote.configure(patch).catch((error) => sendRemoteError(socket, error));
+          break;
+        }
+        case "remote.pairing.start":
+          try {
+            send(socket, { type: "remote.pairing.code", pairing: remote.startPairing() });
+          } catch (error) {
+            sendRemoteError(socket, error);
+          }
+          break;
+        case "remote.pairing.cancel":
+          remote.cancelPairing();
+          break;
+        /*
+          El telefono (hito 38): la respuesta lleva su llave privada dentro del
+          texto del QR, asi que va solo a esta ventana, y si esta ventana se
+          cierra sin cancelar, la llave se olvida igual (`teardown`).
+        */
+        case "remote.phone.start":
+          phonePairingOwner = socket;
+          void remote.startPhonePairing().then((pairing) => send(socket, { type: "remote.phone.pairing", pairing })).catch((error) => sendRemoteError(socket, error));
+          break;
+        case "remote.phone.cancel":
+          if (phonePairingOwner === socket) phonePairingOwner = null;
+          remote.cancelPhonePairing();
+          break;
+        case "remote.device.rename":
+          void remote.renameDevice(message.deviceId, message.label).then((renamed) => {
+            if (!renamed) sendError(socket, "remote-failed", serverText("remoteDeviceGone"));
+          }).catch((error) => sendRemoteError(socket, error));
+          break;
+        case "remote.device.revoke":
+          void remote.revokeDevice(message.deviceId).then((revoked) => {
+            if (!revoked) sendError(socket, "remote-failed", serverText("remoteDeviceGone"));
+          }).catch((error) => sendRemoteError(socket, error));
+          break;
+        /*
+          "Olvidar este equipo" del teléfono: se revoca el equipo con el que
+          entró esta ventana, y ningún otro. Revocar cierra sus ventanas con
+          4001, esta incluida: ése es el acuse. Una ventana del anfitrión no es
+          un equipo, y no tiene nada que olvidar.
+        */
+        case "remote.device.forgetSelf":
+          if (deviceId === null) break;
+          void remote.revokeDevice(deviceId).catch((error) => sendRemoteError(socket, error));
+          break;
       }
     });
     const teardown = () => {
+      if (phonePairingOwner === socket) {
+        phonePairingOwner = null;
+        remote.cancelPhonePairing();
+      }
       globalSearch.cancel();
       pickers.closeAll();
       registry.detachAll(listener);
@@ -19428,6 +20659,7 @@ function attachTerminalSocket(options) {
       for (const terminalId of memorySubscriptions) memory.unsubscribe(terminalId);
       memorySubscriptions.clear();
       clients.delete(socket);
+      if (deviceId !== null && remoteSockets.delete(socket)) remote.noteDisconnected(deviceId);
     };
     socket.on("close", teardown);
     socket.on("error", teardown);
@@ -19452,18 +20684,20 @@ function attachTerminalSocket(options) {
     memory.off("status", onMemoryStatus);
     stopAgentChanges();
     stopVaultStatus();
+    stopRemoteStatus();
+    stopRemoteRevoked();
     for (const client of wss.clients) client.terminate();
     wss.close();
   };
 }
 
 // packages/server/src/vault/catalog.ts
-import { open as open7, readdir as readdir16, stat as stat27 } from "node:fs/promises";
-import path46 from "node:path";
+import { open as open7, readdir as readdir16, stat as stat29 } from "node:fs/promises";
+import path48 from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 var HEADER_MAX_BYTES = 64 * 1024;
 var LOAD_CONCURRENCY = 16;
-var keyOf = (agent, sessionId) => `${agent}/${sessionId}`;
+var keyOf2 = (agent, sessionId) => `${agent}/${sessionId}`;
 function isSessionAgentId2(value) {
   return SESSION_AGENT_IDS.includes(value);
 }
@@ -19479,7 +20713,7 @@ async function assetBytesOf(dir, agent, sessionId) {
   for (const name of names) {
     if (!VAULT_ASSET_NAME_PATTERN.test(name)) continue;
     try {
-      const info = await stat27(path46.join(folder, name));
+      const info = await stat29(path48.join(folder, name));
       if (info.isFile()) total += info.size;
     } catch {
     }
@@ -19490,7 +20724,7 @@ async function readEntry(dir, agent, sessionId) {
   const file = sessionFile(dir, agent, sessionId);
   let sizeBytes;
   try {
-    const info = await stat27(file);
+    const info = await stat29(file);
     if (!info.isFile()) return { kind: "absent" };
     sizeBytes = info.size;
   } catch {
@@ -19571,8 +20805,8 @@ var VaultCatalog = class {
     const foreign = /* @__PURE__ */ new Set();
     keys.forEach((key, position) => {
       const read = reads[position];
-      if (read?.kind === "listed") entries.set(keyOf(key.agent, key.sessionId), read.entry);
-      else if (read?.kind === "foreign") foreign.add(keyOf(key.agent, key.sessionId));
+      if (read?.kind === "listed") entries.set(keyOf2(key.agent, key.sessionId), read.entry);
+      else if (read?.kind === "foreign") foreign.add(keyOf2(key.agent, key.sessionId));
     });
     this.entries = entries;
     this.foreign = foreign;
@@ -19586,7 +20820,7 @@ var VaultCatalog = class {
     const generation = this.generation;
     const read = await readEntry(dir, agent, sessionId);
     if (generation !== this.generation) return;
-    const key = keyOf(agent, sessionId);
+    const key = keyOf2(agent, sessionId);
     const before = JSON.stringify(this.entries.get(key) ?? null);
     const wasForeign = this.foreign.has(key);
     this.entries.delete(key);
@@ -19616,11 +20850,11 @@ var VaultCatalog = class {
     return this.summaryCache;
   }
   header(agent, sessionId) {
-    return this.entries.get(keyOf(agent, sessionId))?.header ?? null;
+    return this.entries.get(keyOf2(agent, sessionId))?.header ?? null;
   }
   /** true si en disco hay una copia de esa sesion con un formato que esta app no conoce. */
   hasForeignFormat(agent, sessionId) {
-    return this.foreign.has(keyOf(agent, sessionId));
+    return this.foreign.has(keyOf2(agent, sessionId));
   }
   /**
    * El cuerpo de una sesion listada, linea por linea: eventos y documentos.
@@ -19643,7 +20877,7 @@ var VaultCatalog = class {
    */
   async *bodyLines(agent, sessionId) {
     const dir = this.dir;
-    if (dir === null || !this.entries.has(keyOf(agent, sessionId))) return;
+    if (dir === null || !this.entries.has(keyOf2(agent, sessionId))) return;
     const handle = await open7(sessionFile(dir, agent, sessionId), "r").catch(() => null);
     if (handle === null) return;
     const input = handle.createReadStream({ encoding: "utf8" });
@@ -19699,38 +20933,77 @@ var VaultCatalog = class {
 };
 
 // packages/server/src/index.ts
-var serverDir = path47.dirname(fileURLToPath2(import.meta.url));
+var serverDir = path49.dirname(fileURLToPath2(import.meta.url));
 var isPackaged = true;
-var webRoot = isPackaged ? serverDir : path47.resolve(serverDir, "../../web");
-var webDist = isPackaged ? path47.join(serverDir, "web") : path47.join(webRoot, "dist");
-var repoRoot = path47.resolve(serverDir, "../../..");
+var webRoot = isPackaged ? serverDir : path49.resolve(serverDir, "../../web");
+var webDist = isPackaged ? path49.join(serverDir, "web") : path49.join(webRoot, "dist");
+var repoRoot = path49.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 path47.resolve(override);
+  if (override !== void 0 && override.length > 0) return path49.resolve(override);
   if (isPackaged) return process.cwd();
   return repoRoot;
 }
 var ORIGIN_REFUSED_TEXT = "Origin not allowed.\nOrigen no permitido.";
 var TOKEN_MISSING_TEXT = "The session token is missing. Open the URL the server printed at startup.\nFalta el token de sesi\xF3n. Abre la URL que imprimi\xF3 el servidor al arrancar.";
 var NOT_FOUND_TEXT = "Not found.\nNo encontrado.";
-function createAuthMiddleware(port, token) {
+var PAIRING_HINT_TEXT = '\n\nFrom another computer: pair it first. On the computer that runs Agent Workbench, open "Remote access" and choose "Pair a device".\nDesde otro equipo: primero empar\xE9jalo. En el equipo donde corre Agent Workbench, abre "Acceso remoto" y elige "Emparejar un equipo".';
+var PAIRING_REFUSED_TEXT = `That pairing code isn't valid or has expired. Ask for a new one in "Remote access".
+Ese c\xF3digo para emparejar no es v\xE1lido o venci\xF3. Pide uno nuevo en "Acceso remoto".`;
+function createAuthMiddleware(port, token, remote) {
   return (request, response, next) => {
-    if (!hasValidHost(request, port) || !hasValidOrigin(request, port)) {
-      response.status(403).type("text/plain").send(ORIGIN_REFUSED_TEXT);
+    const authorization = authorizeRequest(request, port, token, remote.verifier());
+    if (authorization.ok) {
+      const { credential } = authorization;
+      if (credential.kind === "session" && credential.source === "query") {
+        response.setHeader("Set-Cookie", buildTokenCookie(token));
+      }
+      if (credential.kind === "device" && request.method === "GET" && request.path === "/") {
+        response.setHeader("Set-Cookie", buildDeviceCookie(credential.credential));
+      }
+      next();
       return;
     }
-    const match = matchToken(request, token);
-    if (match === null) {
-      response.status(401).type("text/plain").send(TOKEN_MISSING_TEXT);
+    if (authorization.reason !== "bad-token") {
+      response.status(403).type("text/plain").send(ORIGIN_REFUSED_TEXT);
       return;
     }
-    if (match.source === "query") {
-      response.setHeader("Set-Cookie", buildTokenCookie(token));
+    const code = request.method === "GET" && request.path === "/" ? readPairingCode(request) : null;
+    if (code !== null && remote.verifier() !== null) {
+      response.setHeader("Cache-Control", "no-store");
+      void remote.redeemPairing(code, request.headers["user-agent"]).catch(() => null).then((redeemed) => {
+        if (redeemed === null) {
+          response.status(401).type("text/plain").send(PAIRING_REFUSED_TEXT);
+          return;
+        }
+        response.setHeader("Set-Cookie", buildDeviceCookie(redeemed.credential));
+        response.redirect(303, "/");
+      });
+      return;
     }
-    next();
+    response.status(401).type("text/plain").send(remote.verifier() === null ? TOKEN_MISSING_TEXT : TOKEN_MISSING_TEXT + PAIRING_HINT_TEXT);
   };
 }
+function isPortUnavailable(error) {
+  const code = error?.code;
+  return code === "EADDRINUSE" || code === "EACCES";
+}
+function listenOnLoopback(httpServer, port) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      httpServer.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      httpServer.off("error", onError);
+      resolve();
+    };
+    httpServer.once("error", onError);
+    httpServer.once("listening", onListening);
+    httpServer.listen(port, LOOPBACK_HOST);
+  });
+}
 async function mountDevUi(app, httpServer) {
   const { createServer: createViteServer } = await import("vite");
   const vite = await createViteServer({
@@ -19743,7 +21016,7 @@ async function mountDevUi(app, httpServer) {
 }
 var LOOKS_LIKE_FILE = /\.[a-zA-Z0-9]{1,8}$/;
 function mountBuiltUi(app) {
-  const indexHtml = path47.join(webDist, "index.html");
+  const indexHtml = path49.join(webDist, "index.html");
   if (!existsSync4(indexHtml)) {
     throw new Error(
       `There's no compiled interface in ${webDist}.
@@ -19760,7 +21033,7 @@ Run "pnpm build" before "pnpm start", or use "pnpm dev".`
   });
   return () => Promise.resolve();
 }
-function describeStartup(url, cwd, agents, shell) {
+function describeStartup(url, cwd, agents, shell, remoteLine) {
   const agentList = agents.list();
   const line = "-".repeat(64);
   console.log(`
@@ -19782,6 +21055,9 @@ ${line}`);
   }));
   for (const agentLine of startupAgentLines(startupAgents)) console.log(agentLine);
   console.log(`  Console      ${shell === null ? "not found" : shell.file}`);
+  if (remoteLine !== null) console.log(remoteLine);
+  const colored = process.stdout.isTTY === true && process.env["NO_COLOR"] === void 0;
+  console.log(colored ? supportStartupLineColored() : supportStartupLine());
   if (agentList.some((info) => info.environmentNotice === "child-session-marker")) {
     console.log("");
     console.log("  Note: this process inherited CLAUDE_CODE_CHILD_SESSION, which turns off");
@@ -19818,6 +21094,8 @@ async function main() {
   );
   const notes = new NotesStore();
   await notes.load();
+  const drafts = new DraftStore();
+  await drafts.load();
   const conversations = new ConversationHub(registry, agents);
   const repos = new RepoHub(registry);
   const memory = new MemoryHub(registry);
@@ -19825,16 +21103,31 @@ async function main() {
   const app = express();
   app.disable("x-powered-by");
   const httpServer = createServer(app);
-  await new Promise((resolve, reject) => {
-    httpServer.once("error", reject);
-    httpServer.listen(0, LOOPBACK_HOST, resolve);
-  });
+  const remoteSettings = settings2.get().remote;
+  let listeningFixed = false;
+  let fixedPortBusy = false;
+  if (remoteSettings.enabled) {
+    try {
+      await listenOnLoopback(httpServer, remoteSettings.port);
+      listeningFixed = true;
+    } catch (error) {
+      if (!isPortUnavailable(error)) throw error;
+      fixedPortBusy = true;
+    }
+  }
+  if (!listeningFixed) await listenOnLoopback(httpServer, 0);
   const address = httpServer.address();
   if (address === null || typeof address === "string") {
     throw new Error("Couldn't determine the assigned port.");
   }
   const { port } = address;
-  app.use(createAuthMiddleware(port, token));
+  const remote = new RemoteAccessService({
+    settings: settings2,
+    store: new RemoteDevicesStore(),
+    listening: { port, fixed: listeningFixed, fixedPortBusy }
+  });
+  await remote.load();
+  app.use(createAuthMiddleware(port, token, remote));
   const closeUi = isProduction ? mountBuiltUi(app) : await mountDevUi(app, httpServer);
   const detachSocket = attachTerminalSocket({
     pasteStore,
@@ -19846,18 +21139,21 @@ async function main() {
     index,
     archived,
     notes,
+    drafts,
     conversations,
     repos,
     memory,
     agents,
     defaultCwd,
-    vault
+    vault,
+    remote
   });
   void pasteStore.purgeStale();
   void index.start();
   const stopWatching = watchSessions(index, conversations, agents);
   if (process.env["AGENT_WORKBENCH_NO_RESTORE"] !== "1") {
     void store.load().then((state) => {
+      drafts.retainOnly(workspaceDraftOwners(state));
       if (state.tabs.length === 0 && state.foreignTabs.length === 0) return;
       if (agents.anyAvailable()) {
         console.log(`Restoring ${state.tabs.length} tab(s) from the previous run...`);
@@ -19866,7 +21162,14 @@ async function main() {
     });
   }
   const url = `http://${LOOPBACK_HOST}:${port}/?${TOKEN_QUERY_PARAM}=${token}`;
-  describeStartup(url, defaultCwd, agents, shell);
+  const remoteStatus = remote.status();
+  describeStartup(
+    url,
+    defaultCwd,
+    agents,
+    shell,
+    remoteAccessStartupLine(remoteStatus.state, remoteStatus.port, remote.pairedDevices)
+  );
   if (process.env["AGENT_WORKBENCH_NO_OPEN"] !== "1") openBrowser(url);
   let shuttingDown = false;
   const shutdown = () => {
@@ -19881,7 +21184,8 @@ async function main() {
     repos.disposeAll();
     void memory.disposeAll();
     registry.disposeAll();
-    void Promise.all([store.flush(), archived.flush(), notes.flush(), agentsDisposed]).catch(() => void 0).then(() => closeUi()).catch(() => void 0).finally(() => {
+    remote.dispose();
+    void Promise.all([store.flush(), archived.flush(), notes.flush(), drafts.flush(), remote.flush(), agentsDisposed]).catch(() => void 0).then(() => closeUi()).catch(() => void 0).finally(() => {
       httpServer.close(() => process.exit(0));
       setTimeout(() => process.exit(0), 2e3).unref();
     });