ds-harness-remote 0.5.13 → 0.5.15

package/dist/index.js

@@ -5586,10 +5586,10 @@ var util;
       return obj[e];
     });
   };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => {
     const keys = [];
-    for (const key in object) {
-      if (Object.prototype.hasOwnProperty.call(object, key)) {
+    for (const key in object3) {
+      if (Object.prototype.hasOwnProperty.call(object3, key)) {
         keys.push(key);
       }
     }
@@ -8692,8 +8692,8 @@ var ZodSet = class _ZodSet extends ZodType {
       maxSize: { value: maxSize, message: errorUtil.toString(message) }
     });
   }
-  size(size, message) {
-    return this.min(size, message).max(size, message);
+  size(size2, message) {
+    return this.min(size2, message).max(size2, message);
   }
   nonempty(message) {
     return this.min(1, message);
@@ -9579,6 +9579,7 @@ var rpcMethods = [
   "workspace.upload.commit",
   "workspace.upload.abort",
   "harness.transport.describe",
+  "remote.history.configure",
   "harness.api.call",
   "harness.api.transfer.open",
   "harness.api.transfer.chunk",
@@ -9943,8 +9944,8 @@ function createRpcRequest(method, params, id5) {
 function createRpcResponse(requestId, result) {
   return createMessage("rpc.response", { requestId, result });
 }
-function createRpcError(requestId, code, message, details, retryable) {
-  return createMessage("rpc.error", { requestId, code, message, details, retryable });
+function createRpcError(requestId, code, message, details2, retryable) {
+  return createMessage("rpc.error", { requestId, code, message, details: details2, retryable });
 }
 function createEvent(event, data2, options = {}) {
   return createMessage("event", { event, data: data2, ...options });
@@ -10099,10 +10100,10 @@ function remoteWorkspaceTypeAvailable(capabilities, workspaceTypes, id5, capabil
 var RemoteGatewayError = class extends Error {
   code;
   details;
-  constructor(code, message, details = {}, options) {
+  constructor(code, message, details2 = {}, options) {
     super(message, options);
     this.code = code;
-    this.details = details;
+    this.details = details2;
     this.name = "RemoteGatewayError";
   }
 };
@@ -10119,12 +10120,26 @@ var CODEX_IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg"
 var DATA_IMAGE_URL = /^data:(image\/(?:png|jpeg|webp|gif));base64,([A-Za-z0-9+/]+={0,2})$/u;
 var CodexRemoteClient = class {
   core;
-  constructor(core) {
+  historyPreview;
+  constructor(core, historyPreview = false) {
     this.core = core;
+    this.historyPreview = historyPreview;
   }
   /** Low-level allowlisted request used by the Desktop Web loopback facade. */
-  request(method, params, signal) {
-    const largeHistory = method === "dsh/sessionHistory" || method === "thread/read" && isRecord(params) && params.includeTurns === true;
+  previewSupported = true;
+  async request(method, params, signal) {
+    if (method === "dsh/sessionHistory" && this.historyPreview && this.previewSupported) {
+      try {
+        return await this.core.rpc("codex.app.call", { method, params, previewHistory: true }, signal);
+      } catch (error) {
+        const code = error?.code;
+        if (code !== "INVALID_MESSAGE" && code !== "RESPONSE_TOO_LARGE")
+          throw error;
+        if (code === "INVALID_MESSAGE")
+          this.previewSupported = false;
+      }
+    }
+    const largeHistory = method === "dsh/historyDetail" || method === "dsh/sessionHistory" || method === "thread/read" && isRecord(params) && params.includeTurns === true;
     return this.call(method, params, largeHistory || hasImageInput(params), signal);
   }
   async account(signal) {
@@ -11316,8 +11331,8 @@ function rcEndpoint(endpoint) {
 function success(value) {
   return { ok: true, value };
 }
-function failure(code, message, details = {}) {
-  return { ok: false, error: { code, message, details } };
+function failure(code, message, details2 = {}) {
+  return { ok: false, error: { code, message, details: details2 } };
 }
 function business(value) {
   if (isRecord3(value) && value.ok === false && isRecord3(value.error)) {
@@ -11333,8 +11348,8 @@ function business(value) {
   if (isRecord3(value) && value.ok === true) return { ok: true, value: value.value };
   return { ok: true, value };
 }
-function fail(code, message, details = {}) {
-  return { ok: false, error: { code, message, details } };
+function fail(code, message, details2 = {}) {
+  return { ok: false, error: { code, message, details: details2 } };
 }
 function failFrom(error) {
   const source = error instanceof Error ? error : new Error(String(error));
@@ -11476,12 +11491,12 @@ var AcpEventCarrier = class {
     } else if (event === "api-session/removed" && sessionId !== void 0) {
       this.broadcastRcHost({ type: "host/session-removed", sessionId });
     } else if (event === "api-session/added" && isRecord3(args[0])) {
-      const summary = args[0];
+      const summary2 = args[0];
       this.broadcastRcHost({
         type: "host/session-added",
-        sessionId: summary.sessionId,
-        blank: summary.blank === true,
-        ...typeof summary.cwd === "string" ? { cwd: summary.cwd } : {}
+        sessionId: summary2.sessionId,
+        blank: summary2.blank === true,
+        ...typeof summary2.cwd === "string" ? { cwd: summary2.cwd } : {}
       });
     }
   }
@@ -13311,10 +13326,10 @@ function normalizeProtocol(value) {
   return value.toLowerCase();
 }
 function relatedAddressSummary(address) {
-  const summary = summarizeAddress(address);
+  const summary2 = summarizeAddress(address);
   return {
-    relatedAddressFamily: summary.addressFamily,
-    relatedAddressScope: summary.addressScope
+    relatedAddressFamily: summary2.addressFamily,
+    relatedAddressScope: summary2.addressScope
   };
 }
 function summarizeIpv4Scope(parts) {
@@ -13789,19 +13804,19 @@ var RtcDataChannelTransport = class {
     }
   }
   async handleIce(candidate) {
-    const summary = summarizeIceCandidate(candidate);
+    const summary2 = summarizeIceCandidate(candidate);
     if (!this.remoteDescriptionSet) {
-      recordCandidate(this.remoteCandidateTelemetry, summary);
-      this.emitDiagnostic({ type: "remote-candidate", candidate: summary, action: "buffered", diagnostics: this.diagnostics() });
+      recordCandidate(this.remoteCandidateTelemetry, summary2);
+      this.emitDiagnostic({ type: "remote-candidate", candidate: summary2, action: "buffered", diagnostics: this.diagnostics() });
       this.remoteCandidates.push(candidate);
       return;
     }
     try {
       await this.pc.addIceCandidate(candidate);
-      recordCandidate(this.remoteCandidateTelemetry, summary);
-      this.emitDiagnostic({ type: "remote-candidate", candidate: summary, action: "added", diagnostics: this.diagnostics() });
+      recordCandidate(this.remoteCandidateTelemetry, summary2);
+      this.emitDiagnostic({ type: "remote-candidate", candidate: summary2, action: "added", diagnostics: this.diagnostics() });
     } catch {
-      this.emitDiagnostic({ type: "remote-candidate", candidate: summary, action: "ignored", diagnostics: this.diagnostics() });
+      this.emitDiagnostic({ type: "remote-candidate", candidate: summary2, action: "ignored", diagnostics: this.diagnostics() });
     }
   }
   async flushRemoteCandidates() {
@@ -14203,19 +14218,19 @@ function isExplicitlyNonLanScope(scope2) {
 function increment(map, key) {
   map[key] = (map[key] ?? 0) + 1;
 }
-function selectedPathTelemetry(details) {
+function selectedPathTelemetry(details2) {
   return {
-    ...details.transport === void 0 ? {} : { transport: details.transport },
-    ...details.mode === void 0 ? {} : { mode: details.mode },
-    ...details.relayUrl === void 0 ? {} : { relayUrl: details.relayUrl },
-    ...details.localCandidateType === void 0 ? {} : { localCandidateType: details.localCandidateType },
-    ...details.remoteCandidateType === void 0 ? {} : { remoteCandidateType: details.remoteCandidateType },
-    ...details.localAddressScope === void 0 ? {} : { localAddressScope: details.localAddressScope },
-    ...details.remoteAddressScope === void 0 ? {} : { remoteAddressScope: details.remoteAddressScope },
-    ...details.protocol === void 0 ? {} : { protocol: details.protocol },
-    ...details.relayProtocol === void 0 ? {} : { relayProtocol: details.relayProtocol },
-    ...details.currentRoundTripTimeMs === void 0 ? {} : { currentRoundTripTimeMs: details.currentRoundTripTimeMs },
-    ...details.availableOutgoingBitrate === void 0 ? {} : { availableOutgoingBitrate: details.availableOutgoingBitrate }
+    ...details2.transport === void 0 ? {} : { transport: details2.transport },
+    ...details2.mode === void 0 ? {} : { mode: details2.mode },
+    ...details2.relayUrl === void 0 ? {} : { relayUrl: details2.relayUrl },
+    ...details2.localCandidateType === void 0 ? {} : { localCandidateType: details2.localCandidateType },
+    ...details2.remoteCandidateType === void 0 ? {} : { remoteCandidateType: details2.remoteCandidateType },
+    ...details2.localAddressScope === void 0 ? {} : { localAddressScope: details2.localAddressScope },
+    ...details2.remoteAddressScope === void 0 ? {} : { remoteAddressScope: details2.remoteAddressScope },
+    ...details2.protocol === void 0 ? {} : { protocol: details2.protocol },
+    ...details2.relayProtocol === void 0 ? {} : { relayProtocol: details2.relayProtocol },
+    ...details2.currentRoundTripTimeMs === void 0 ? {} : { currentRoundTripTimeMs: details2.currentRoundTripTimeMs },
+    ...details2.availableOutgoingBitrate === void 0 ? {} : { availableOutgoingBitrate: details2.availableOutgoingBitrate }
   };
 }
 function requireSdp(description) {
@@ -14309,11 +14324,11 @@ var AdaptiveTransport = class extends BaseTransport {
       };
       socket.onerror = () => {
         if (this.lifetime === lifetime)
-          this.failConnection(new Error(`AdaptiveTransport failed to connect to ${this.url}`));
+          this.failConnection(new Error(`AdaptiveTransport failed to connect to ${this.url}`), { reason: "control-error" });
       };
       socket.onclose = (event) => {
         if (this.lifetime === lifetime)
-          this.failConnection(adaptiveControlCloseError(event));
+          this.failConnection(adaptiveControlCloseError(event), { reason: "control-closed", closeCode: event.code });
       };
     });
   }
@@ -14483,7 +14498,7 @@ var AdaptiveTransport = class extends BaseTransport {
       if (frame.type === "ping")
         this.sendControl("pong", frame.payload);
     } catch (error) {
-      this.failConnection(error instanceof Error ? error : new Error("Invalid adaptive control frame"));
+      this.failConnection(error instanceof Error ? error : new Error("Invalid adaptive control frame"), { reason: "invalid-control-frame" });
     }
   }
   handleRelay(payload) {
@@ -14596,8 +14611,9 @@ var AdaptiveTransport = class extends BaseTransport {
       this.emit(data2);
     });
     rtc.onClose(() => {
-      if (this.rtc === rtc && this.dataMode === "webrtc")
-        this.emitClose();
+      if (this.rtc === rtc && this.dataMode === "webrtc") {
+        this.failConnection(new Error("Active WebRTC channel closed"), { reason: "webrtc-closed" });
+      }
     });
     try {
       await rtc.connect(signal);
@@ -14688,7 +14704,8 @@ var AdaptiveTransport = class extends BaseTransport {
     this.readyResolve = void 0;
     this.readyReject = void 0;
   }
-  failConnection(error) {
+  failConnection(error, diagnostic) {
+    const established = this.connectedAt !== void 0;
     this.clearHandshake();
     const reject = this.readyReject;
     this.readyResolve = void 0;
@@ -14707,6 +14724,12 @@ var AdaptiveTransport = class extends BaseTransport {
     reject?.(error);
     void rtc?.close();
     socket?.close();
+    if (established && diagnostic !== void 0) {
+      try {
+        this.options.onDisconnect?.(diagnostic);
+      } catch {
+      }
+    }
     if (socket !== void 0)
       this.emitClose();
   }
@@ -15686,11 +15709,11 @@ function bitLen(n) {
   return len;
 }
 var bitMask = (n) => (_1n << BigInt(n)) - _1n;
-function _validateObject(object, fields, optFields = {}) {
-  if (!object || typeof object !== "object")
+function _validateObject(object3, fields, optFields = {}) {
+  if (!object3 || typeof object3 !== "object")
     throw new Error("expected valid options object");
   function checkField(fieldName, expectedType, isOpt) {
-    const val = object[fieldName];
+    const val = object3[fieldName];
     if (isOpt && val === void 0)
       return;
     const current = typeof val;
@@ -16786,18 +16809,18 @@ function eddsa(Point, cHash, eddsaOpts = {}) {
      */
     toMontgomery(publicKey) {
       const { y } = Point.fromBytes(publicKey);
-      const size = lengths.publicKey;
-      const is25519 = size === 32;
-      if (!is25519 && size !== 57)
+      const size2 = lengths.publicKey;
+      const is25519 = size2 === 32;
+      if (!is25519 && size2 !== 57)
         throw new Error("only defined for 25519 and 448");
       const u = is25519 ? Fp2.div(_1n4 + y, _1n4 - y) : Fp2.div(y - _1n4, y + _1n4);
       return Fp2.toBytes(u);
     },
     toMontgomerySecret(secretKey2) {
-      const size = lengths.secretKey;
-      _abytes2(secretKey2, size);
-      const hashed = cHash(secretKey2.subarray(0, size));
-      return adjustScalarBytes3(hashed).subarray(0, size);
+      const size2 = lengths.secretKey;
+      _abytes2(secretKey2, size2);
+      const hashed = cHash(secretKey2.subarray(0, size2));
+      return adjustScalarBytes3(hashed).subarray(0, size2);
     },
     /** @deprecated */
     randomPrivateKey: randomSecretKey,
@@ -18592,14 +18615,14 @@ var bitMask2 = (n) => {
   asafenumber(n, "n");
   return (_1n7 << BigInt(n)) - _1n7;
 };
-function validateObject2(object, fields = {}, optFields = {}, title = "object") {
-  aobject2(object, title);
+function validateObject2(object3, fields = {}, optFields = {}, title = "object") {
+  aobject2(object3, title);
   aobject2(fields, "fields");
   aobject2(optFields, "optFields");
   function checkField(fieldName, expectedType, isOpt) {
     const label = title === "object" ? `param "${String(fieldName)}"` : `"${title}.${String(fieldName)}"`;
-    const val = object[fieldName];
-    if (!Object.hasOwn(object, fieldName) && (isOpt ? val !== void 0 : expectedType !== "function")) {
+    const val = object3[fieldName];
+    if (!Object.hasOwn(object3, fieldName) && (isOpt ? val !== void 0 : expectedType !== "function")) {
       throw new TypeError(`${label} is invalid: expected own property`);
     }
     if (isOpt && val === void 0)
@@ -19110,24 +19133,24 @@ var pointWindowSizes2 = /* @__PURE__ */ new WeakMap();
 function getWindowSize(P) {
   return pointWindowSizes2.get(P) || 1;
 }
-function oddMultiples(p, size) {
+function oddMultiples(p, size2) {
   const dbl = p.double();
   const t = [p];
-  for (let j = 1; j < size; j++)
+  for (let j = 1; j < size2; j++)
     t.push(t[j - 1].add(dbl));
   return t;
 }
 function wnafDigits(n, W) {
-  const size = 2 ** W;
-  const half = size / 2;
-  const mask = BigInt(size - 1);
+  const size2 = 2 ** W;
+  const half = size2 / 2;
+  const mask = BigInt(size2 - 1);
   const d = [];
   while (n > _0n9) {
     let w = 0;
     if (n & _1n9) {
       w = Number(n & mask);
       if (w >= half)
-        w -= size;
+        w -= size2;
       n -= BigInt(w);
     }
     d.push(w);
@@ -19136,16 +19159,16 @@ function wnafDigits(n, W) {
   return d;
 }
 function signedWindowDigits(n, W, windows) {
-  const size = 2 ** W;
-  const half = size / 2;
-  const mask = BigInt(size - 1);
+  const size2 = 2 ** W;
+  const half = size2 / 2;
+  const mask = BigInt(size2 - 1);
   const shiftBy = BigInt(W);
   const d = [];
   for (let w = 0; w < windows; w++) {
     let v = Number(n & mask);
     n >>= shiftBy;
     if (v > half) {
-      v -= size;
+      v -= size2;
       n += _1n9;
     }
     d.push(v);
@@ -19316,11 +19339,11 @@ var ScalarMultiplier = class {
    */
   fixedWindowCT(point, n, bits) {
     const W = FW_WINDOW;
-    const size = 1 << W;
+    const size2 = 1 << W;
     const mask = bitMask2(W);
-    const table = new Array(size);
+    const table = new Array(size2);
     table[0] = this.ZERO;
-    for (let i = 1; i < size; i++)
+    for (let i = 1; i < size2; i++)
       table[i] = table[i - 1].add(point);
     const windows = Math.ceil(bits / W);
     let acc = this.ZERO;
@@ -19330,7 +19353,7 @@ var ScalarMultiplier = class {
           acc = acc.double();
       const digit = Number(n >> BigInt(window2 * W) & mask);
       let sel = table[0];
-      for (let i = 1; i < size; i++)
+      for (let i = 1; i < size2; i++)
         sel = i === digit ? table[i] : sel;
       acc = acc.add(sel);
     }
@@ -22260,16 +22283,24 @@ var ClientConnection = class {
     this.context.connectionProgress = { runId: progressRunId, targetDeviceId, phase: "checking-host" };
     const identity2 = this.context.requireIdentity();
     let client;
+    const onAbort = () => {
+      void client?.close().catch(() => void 0);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
     try {
       const serverDevice = (await this.context.server.listDevices()).find((device) => device.deviceId === targetDeviceId);
+      signal?.throwIfAborted();
       if (serverDevice === void 0) {
         throw new ClientModeError("MEMBERSHIP_REQUIRED", "The selected Host is not authorized for this account.");
       }
       this.updateConnectionProgress(progressRunId, "authorizing-peer");
       const target2 = await this.authorizeHostPeer(serverDevice);
+      signal?.throwIfAborted();
       const presence = await this.context.server.presenceFor(targetDeviceId);
+      signal?.throwIfAborted();
       if (!presence.online) throw new ClientModeError("HOST_OFFLINE", "The selected Host is offline.", true);
       const credentials = await this.context.server.authenticate(identity2);
+      signal?.throwIfAborted();
       const rtcFactory = this.context.config.forceRelay ? void 0 : await this.context.rtcFactoryProvider({ routeTargets: [this.context.server.baseUrl] }).catch(() => void 0);
       if (!this.context.config.forceRelay && rtcFactory === void 0) {
         this.context.logger.warn("remote Harness WebRTC backend unavailable; using relay", {
@@ -22315,16 +22346,8 @@ var ClientConnection = class {
           transport = createTransport(attempt);
           client = new RemoteClientCore(new ClientSecureTransport(transport, identity2, target2), 6e4);
           const attemptClient = client;
-          const onAbort = () => {
-            void attemptClient.close();
-          };
-          signal?.addEventListener("abort", onAbort, { once: true });
-          try {
-            signal?.throwIfAborted();
-            await attemptClient.connect();
-          } finally {
-            signal?.removeEventListener("abort", onAbort);
-          }
+          signal?.throwIfAborted();
+          await attemptClient.connect();
           signal?.throwIfAborted();
         } finally {
           stopProgressTimer();
@@ -22382,6 +22405,7 @@ var ClientConnection = class {
         });
       }
       const features = await probeRemoteHostFeatures(connectedClient, serverDevice.clientVersion);
+      signal?.throwIfAborted();
       return {
         client: connectedClient,
         target: target2,
@@ -22395,6 +22419,8 @@ var ClientConnection = class {
       this.clearConnectionProgress(progressRunId);
       await client?.close().catch(() => void 0);
       throw error;
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
     }
   }
   beginAttemptProgress(runId, attempt) {
@@ -22453,10 +22479,10 @@ import { WebSocket as WebSocket2 } from "ws";
 
 // src/safe-error.ts
 var RpcError = class extends Error {
-  constructor(code, message, details, retryable = false) {
+  constructor(code, message, details2, retryable = false) {
     super(message);
     this.code = code;
-    this.details = details;
+    this.details = details2;
     this.retryable = retryable;
   }
 };
@@ -22985,6 +23011,7 @@ var BOT_REMOTE_OPERATIONS = [
   "send",
   "answer-question",
   "dismiss-question",
+  "view-reply",
   "approval-answer",
   "stop-member-work"
 ];
@@ -23529,7 +23556,7 @@ async function loadCatalog(client, signal, pendingThreads) {
     return session === void 0 ? void 0 : { thread, session };
   }).filter((value) => value !== void 0);
   const projectWorkspaces = projects.map(projectWorkspace);
-  const workspaceByProjectId = new Map(projects.map((project, index) => [project.id, projectWorkspaces[index]]));
+  const workspaceByProjectId = new Map(projects.map((project2, index) => [project2.id, projectWorkspaces[index]]));
   const visibleSessionIds = /* @__PURE__ */ new Set();
   const visibleThreads = [];
   for (const { thread, session } of projected) {
@@ -23558,8 +23585,8 @@ async function loadCodexProjects(client, signal) {
         ...cursor2 === void 0 ? {} : { cursor: cursor2 }
       }, signal));
       for (const value of array2(result.data)) {
-        const project = projectCodexProject(value, projects.length);
-        if (project !== void 0 && !projects.some((item) => item.id === project.id)) projects.push(project);
+        const project2 = projectCodexProject(value, projects.length);
+        if (project2 !== void 0 && !projects.some((item) => item.id === project2.id)) projects.push(project2);
       }
       cursor2 = typeof result.nextCursor === "string" && result.nextCursor.length > 0 ? result.nextCursor : void 0;
       if (cursor2 === void 0) break;
@@ -23635,16 +23662,16 @@ function nativeWorkspace2(view) {
 function nativeVisibleWorkspaces(catalog, selectedWorkspaceId) {
   return catalog.workspaces.filter((workspace) => workspace.sessionIds.length > 0 || workspace.workspaceId === selectedWorkspaceId);
 }
-function projectWorkspace(project) {
-  const root = project.roots[0];
+function projectWorkspace(project2) {
+  const root = project2.roots[0];
   return {
-    workspaceId: codexProjectWorkspaceId(project.id),
+    workspaceId: codexProjectWorkspaceId(project2.id),
     path: root.path,
-    title: project.name.trim() || basename(root.path),
+    title: project2.name.trim() || basename(root.path),
     sessionIds: [],
     sessionCount: 0,
-    createdAt: isoTime(project.createdAt),
-    updatedAt: isoTime(project.updatedAt || project.createdAt)
+    createdAt: isoTime(project2.createdAt),
+    updatedAt: isoTime(project2.updatedAt || project2.createdAt)
   };
 }
 function projectCodexProject(value, fallbackPosition) {
@@ -23667,7 +23694,7 @@ function findProjectWorkspace(thread, session, projects, workspaceByProjectId) {
   const explicitWorkspace = explicitProjectId === void 0 ? void 0 : workspaceByProjectId.get(explicitProjectId);
   if (explicitWorkspace !== void 0) return explicitWorkspace;
   if (session.cwd === void 0) return void 0;
-  const match = projects.flatMap((project) => project.roots.map((root) => ({ project, root }))).filter((value) => containsPath(value.root.path, session.cwd)).sort((left, right) => {
+  const match = projects.flatMap((project2) => project2.roots.map((root) => ({ project: project2, root }))).filter((value) => containsPath(value.root.path, session.cwd)).sort((left, right) => {
     const length = right.root.path.length - left.root.path.length;
     if (length !== 0) return length;
     const position = left.project.position - right.project.position;
@@ -24069,8 +24096,8 @@ function rcEndpoint2(endpoint) {
 function success2(value) {
   return { ok: true, value };
 }
-function failure2(code, message, details = {}) {
-  return { ok: false, error: { code, message, details } };
+function failure2(code, message, details2 = {}) {
+  return { ok: false, error: { code, message, details: details2 } };
 }
 function ok2(value) {
   return value === void 0 ? { ok: true } : { ok: true, value };
@@ -24084,8 +24111,8 @@ function business2(value) {
   }
   return ok2(value);
 }
-function fail3(code, message, details = {}) {
-  return { ok: false, error: { code, message, details } };
+function fail3(code, message, details2 = {}) {
+  return { ok: false, error: { code, message, details: details2 } };
 }
 function failFrom2(error) {
   const source = error instanceof Error ? error : new Error(String(error));
@@ -24203,12 +24230,12 @@ var CodexEventCarrier = class {
     } else if (event === "api-session/removed" && sessionId !== void 0) {
       this.broadcastRcHost({ type: "host/session-removed", sessionId });
     } else if (event === "api-session/added" && isRecord5(args[0])) {
-      const summary = args[0];
+      const summary2 = args[0];
       this.broadcastRcHost({
         type: "host/session-added",
-        sessionId: summary.sessionId,
-        blank: summary.blank === true,
-        ...typeof summary.cwd === "string" ? { cwd: summary.cwd } : {}
+        sessionId: summary2.sessionId,
+        blank: summary2.blank === true,
+        ...typeof summary2.cwd === "string" ? { cwd: summary2.cwd } : {}
       });
     }
   }
@@ -27404,7 +27431,7 @@ function normalizeServerUrl(value) {
 }
 
 // src/version.ts
-var PLUGIN_VERSION = "0.5.13";
+var PLUGIN_VERSION = "0.5.15";
 
 // src/server-api.ts
 var TERMINAL_CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/u;
@@ -28278,8 +28305,8 @@ var TypertGatewaySwitch = class {
     if (normalized !== void 0) return normalized;
     const source = error instanceof Error ? error : new Error("The Harness Gateway rejected the request.");
     const code = "code" in source && typeof source.code === "string" ? source.code : "internal";
-    const details = "details" in source && isRecord11(source.details) ? source.details : {};
-    return { code, message: source.message, details };
+    const details2 = "details" in source && isRecord11(source.details) ? source.details : {};
+    return { code, message: source.message, details: details2 };
   }
 };
 function workspaceConnectionResult(endpoint, result) {
@@ -29530,8 +29557,16 @@ var ClientModeRuntime = class {
     this.proxySwitch = apiProxy === void 0 ? void 0 : new ApiProxySwitch(apiProxy);
     this.gatewaySwitch = new TypertGatewaySwitch(typertGateway);
   }
-  connect(targetDeviceId, signal) {
-    return this.connection.connect(targetDeviceId, signal);
+  async connect(targetDeviceId, signal) {
+    const lifetime = this.remoteLifetime.signal;
+    const connectionSignal = signal === void 0 ? lifetime : AbortSignal.any([lifetime, signal]);
+    connectionSignal.throwIfAborted();
+    const remote = await this.connection.connect(targetDeviceId, connectionSignal);
+    if (connectionSignal.aborted || this.closed) {
+      await remote.client.close().catch(() => void 0);
+      throw new ClientModeError("CANCELLED", "The Remote connection request was superseded or closed.");
+    }
+    return remote;
   }
   handleControl(endpoint, payload, signal) {
     return this.control.handleControl(endpoint, payload, signal);
@@ -29555,6 +29590,7 @@ var ClientModeRuntime = class {
   connectionProgress;
   connectionProgressRun = 0;
   closed = false;
+  remoteLifetime = new AbortController();
   async start() {
     if (this.closed) throw new Error("client remote-mode runtime is closed");
     this.identity = await this.identities.loadOrCreate(this.config.deviceName);
@@ -29625,12 +29661,12 @@ var ClientModeRuntime = class {
   async detailedStatus() {
     const connected = this.connected;
     if (connected === void 0 || this.identity === void 0) return this.status();
-    const details = await connected.transport.connectionDetails();
+    const details2 = await connected.transport.connectionDetails();
     if (this.connected !== connected) return this.status();
     return {
       ...this.status(),
       network: {
-        ...details,
+        ...details2,
         local: {
           deviceId: this.identity.deviceId,
           name: this.identity.name,
@@ -29698,21 +29734,13 @@ var ClientModeRuntime = class {
     return result;
   }
   async clearClientAuthorization() {
-    const previous = this.connected;
-    this.connected = void 0;
-    this.connectionProgress = void 0;
-    this.pendingWorkspaceSelection = void 0;
-    await this.closeCodexVirtual();
+    const cleanup = this.leaveRemote();
     this.codexOpenedSessions.clear();
-    await this.closeCursorVirtual();
-    this.proxySwitch?.selectLocal();
-    await this.closePreview();
-    this.gatewaySwitch.selectLocal();
-    await this.codexStreamBridge.closeCodexStreams(previous?.client);
-    await previous?.client.close().catch(() => void 0);
-    await this.server.revokeCurrentDevice();
+    const results = await Promise.allSettled([cleanup, this.server.revokeCurrentDevice()]);
     this.identity = await this.identities.reset(this.config.deviceName);
     this.server.bindIdentity(this.identity);
+    const failure4 = results.find((result) => result.status === "rejected");
+    if (failure4?.status === "rejected") throw failure4.reason;
   }
   async setHostAuthorization(enabled) {
     if (this.host === void 0) throw new ClientModeError("METHOD_NOT_ALLOWED", "This plugin is not running as a Host.");
@@ -29726,23 +29754,14 @@ var ClientModeRuntime = class {
   }
   async setMode(mode2, targetDeviceId, signal) {
     if (mode2 === "local") {
-      await this.closeCodexVirtual();
-      await this.closeCursorVirtual();
-      this.proxySwitch?.selectLocal();
-      await this.closePreview();
-      this.gatewaySwitch.selectLocal();
-      const previous2 = this.connected;
-      this.connected = void 0;
-      this.connectionProgress = void 0;
-      this.pendingWorkspaceSelection = void 0;
-      await this.codexStreamBridge.closeCodexStreams(previous2?.client);
-      await previous2?.client.close().catch(() => void 0);
+      await this.leaveRemote();
       this.logger.info("Harness target switched", { mode: "local" });
       return this.status();
     }
     if (targetDeviceId === void 0 || targetDeviceId.length === 0) {
       throw new ClientModeError("INVALID_MESSAGE", "A targetDeviceId is required for remote mode.");
     }
+    const lifetime = this.remoteLifetime.signal;
     const next = await this.connect(targetDeviceId, signal);
     try {
       this.assertRemoteCompatible(next);
@@ -29753,11 +29772,17 @@ var ClientModeRuntime = class {
     }
     const previous = this.connected;
     await this.closePreview();
+    if (lifetime.aborted || this.closed) {
+      await next.client.close().catch(() => void 0);
+      throw new ClientModeError("CANCELLED", "The Remote connection request was superseded or closed.");
+    }
     this.connected = next;
     this.connection.clearConnectionProgress(next.progressRunId);
     this.pendingWorkspaceSelection = void 0;
     await this.closeCodexVirtual();
+    this.assertRemoteCurrent(next, signal);
     await this.closeCursorVirtual();
+    this.assertRemoteCurrent(next, signal);
     this.selectRemoteTarget(next);
     await this.codexStreamBridge.closeCodexStreams(previous?.client);
     await previous?.client.close().catch(() => void 0);
@@ -29815,8 +29840,11 @@ var ClientModeRuntime = class {
       });
       workspace = unwrapNativeResult(response);
     }
+    this.assertRemoteCurrent(remote, signal);
     await this.closeCodexVirtual();
+    this.assertRemoteCurrent(remote, signal);
     await this.closeCursorVirtual();
+    this.assertRemoteCurrent(remote, signal);
     this.selectRemoteTarget(remote, transport);
     const workspaceId = workspaceRecordId(workspace.workspace);
     this.pendingWorkspaceSelection = { targetDeviceId: remote.target.deviceId, workspaceId };
@@ -29897,11 +29925,12 @@ var ClientModeRuntime = class {
       roots: [{ path: trimmedPath }],
       idempotencyKey: uuidV7()
     }, signal));
-    const project = record2(result.project);
-    if (typeof project.id !== "string" || project.id.length === 0) {
+    const project2 = record2(result.project);
+    this.assertRemoteCurrent(remote, signal);
+    if (typeof project2.id !== "string" || project2.id.length === 0) {
       throw new ClientModeError("INVALID_MESSAGE", "The Host returned an invalid CodeX project.");
     }
-    return this.openCodexWorkspace(targetDeviceId, codexProjectWorkspaceId(project.id), signal);
+    return this.openCodexWorkspace(targetDeviceId, codexProjectWorkspaceId(project2.id), signal);
   }
   async listCursorWorkspaces(targetDeviceId, signal, backend = "cursor") {
     const remote = await this.ensureConnected(targetDeviceId, signal);
@@ -29929,23 +29958,32 @@ var ClientModeRuntime = class {
     }, backend, remote.features.acpModelLoadsSession ? ["agent.acp.antigravity.model-load.v1"] : [], new RemoteTypertGateway2(remote.client));
     let workspace;
     try {
-      workspace = await virtual.selectWorkspace(workspaceId);
-    } catch {
+      try {
+        workspace = await virtual.selectWorkspace(workspaceId);
+      } catch {
+        this.assertRemoteCurrent(remote, signal);
+        throw new ClientModeError("WORKSPACE_NOT_FOUND", `The selected ${backend} workspace is no longer available.`);
+      }
+      this.assertRemoteCurrent(remote, signal);
+      await this.closeCodexVirtual();
+      this.assertRemoteCurrent(remote, signal);
+      await this.closeCursorVirtual();
+      this.assertRemoteCurrent(remote, signal);
+      const preferredSessionId = await virtual.preferredSessionId();
+      this.assertRemoteCurrent(remote, signal);
+      this.cursorVirtual = virtual;
+      this.acpVirtualBackend = backend;
+      this.selectCursorTarget(virtual, remote);
+      this.pendingWorkspaceSelection = {
+        targetDeviceId: remote.target.deviceId,
+        workspaceId: workspace.workspaceId,
+        backend,
+        ...preferredSessionId === void 0 ? {} : { sessionId: preferredSessionId }
+      };
+    } catch (error) {
       await virtual.close();
-      throw new ClientModeError("WORKSPACE_NOT_FOUND", `The selected ${backend} workspace is no longer available.`);
+      throw error;
     }
-    await this.closeCodexVirtual();
-    await this.closeCursorVirtual();
-    this.cursorVirtual = virtual;
-    this.acpVirtualBackend = backend;
-    this.selectCursorTarget(virtual, remote);
-    const preferredSessionId = await virtual.preferredSessionId();
-    this.pendingWorkspaceSelection = {
-      targetDeviceId: remote.target.deviceId,
-      workspaceId: workspace.workspaceId,
-      backend,
-      ...preferredSessionId === void 0 ? {} : { sessionId: preferredSessionId }
-    };
     this.logger.info(`${backend} virtual workspace opened`, { targetDeviceId: shortId(remote.target.deviceId) });
     return { ...this.status(), workspace };
   }
@@ -29962,19 +30000,27 @@ var ClientModeRuntime = class {
       deviceId: remote.target.deviceId,
       name: remote.target.name
     }, backend, remote.features.acpModelLoadsSession ? ["agent.acp.antigravity.model-load.v1"] : [], new RemoteTypertGateway2(remote.client));
-    const workspace = await virtual.selectOrCreateWorkspace(trimmedPath);
-    await this.closeCodexVirtual();
-    await this.closeCursorVirtual();
-    this.cursorVirtual = virtual;
-    this.acpVirtualBackend = backend;
-    this.selectCursorTarget(virtual, remote);
-    this.pendingWorkspaceSelection = {
-      targetDeviceId: remote.target.deviceId,
-      workspaceId: workspace.workspaceId,
-      backend
-    };
-    this.logger.info(`${backend} virtual workspace created`, { targetDeviceId: shortId(remote.target.deviceId) });
-    return { ...this.status(), workspace };
+    try {
+      const workspace = await virtual.selectOrCreateWorkspace(trimmedPath);
+      this.assertRemoteCurrent(remote, signal);
+      await this.closeCodexVirtual();
+      this.assertRemoteCurrent(remote, signal);
+      await this.closeCursorVirtual();
+      this.assertRemoteCurrent(remote, signal);
+      this.cursorVirtual = virtual;
+      this.acpVirtualBackend = backend;
+      this.selectCursorTarget(virtual, remote);
+      this.pendingWorkspaceSelection = {
+        targetDeviceId: remote.target.deviceId,
+        workspaceId: workspace.workspaceId,
+        backend
+      };
+      this.logger.info(`${backend} virtual workspace created`, { targetDeviceId: shortId(remote.target.deviceId) });
+      return { ...this.status(), workspace };
+    } catch (error) {
+      await virtual.close();
+      throw error;
+    }
   }
   consumeWorkspaceSelection(selection) {
     const pending = this.pendingWorkspaceSelection;
@@ -29984,21 +30030,34 @@ var ClientModeRuntime = class {
     return this.status();
   }
   async close() {
-    await this.closePreview();
     if (this.closed) return;
     this.closed = true;
-    this.proxySwitch?.selectLocal();
-    await this.closePreview();
-    this.gatewaySwitch.selectLocal();
-    this.pendingWorkspaceSelection = void 0;
-    await this.closeCodexVirtual();
-    await this.closeCursorVirtual();
-    await this.codexStreamBridge.closeCodexStreams(this.connected?.client);
-    await this.connected?.client.close().catch(() => void 0);
+    this.server.close?.();
+    try {
+      await this.leaveRemote();
+    } finally {
+      this.proxySwitch?.restore();
+      this.gatewaySwitch.restore();
+    }
+  }
+  async leaveRemote() {
+    this.remoteLifetime.abort(new ClientModeError("CANCELLED", "The Remote connection was closed."));
+    this.remoteLifetime = new AbortController();
+    const previous = this.connected;
     this.connected = void 0;
     this.connectionProgress = void 0;
-    this.proxySwitch?.restore();
-    this.gatewaySwitch.restore();
+    this.pendingWorkspaceSelection = void 0;
+    this.proxySwitch?.selectLocal();
+    this.gatewaySwitch.selectLocal();
+    const results = await Promise.allSettled([
+      this.closeCodexVirtual(),
+      this.closeCursorVirtual(),
+      this.closePreview(),
+      this.codexStreamBridge.closeCodexStreams(previous?.client),
+      previous?.client.close()
+    ]);
+    const failure4 = results.find((result) => result.status === "rejected");
+    if (failure4?.status === "rejected") throw failure4.reason;
   }
   async callRemoteFileViewer(endpoint, payload, signal) {
     const remote = this.connected;
@@ -30111,11 +30170,12 @@ var ClientModeRuntime = class {
     );
   }
   async ensureConnected(targetDeviceId, signal, isCurrent) {
+    const lifetime = this.remoteLifetime.signal;
     if (this.connected?.target.deviceId === targetDeviceId) return this.connected;
     const next = await this.connect(targetDeviceId, signal);
     const assertCurrent = () => {
       signal?.throwIfAborted();
-      if (this.closed || isCurrent?.() === false) {
+      if (this.closed || lifetime.aborted || isCurrent?.() === false) {
         throw new ClientModeError("CANCELLED", "The Remote connection request was superseded or closed.");
       }
     };
@@ -30134,6 +30194,12 @@ var ClientModeRuntime = class {
     await previous?.client.close().catch(() => void 0);
     return next;
   }
+  assertRemoteCurrent(remote, signal) {
+    signal?.throwIfAborted();
+    if (this.closed || this.connected !== remote) {
+      throw new ClientModeError("CANCELLED", "The Remote workspace request was superseded or closed.");
+    }
+  }
   requireIdentity() {
     if (this.identity === void 0) throw new ClientModeError("IDENTITY_INVALID", "The client identity is not ready.");
     return this.identity;
@@ -30463,7 +30529,7 @@ var ControlStatusStream = class {
 };
 
 // src/codex/domain.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { accessSync, constants, existsSync as existsSync2, readFileSync } from "node:fs";
 import { readdir, realpath, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
@@ -30835,6 +30901,121 @@ function threadIdFromParams(params) {
   return typeof params.threadId === "string" ? params.threadId : void 0;
 }
 
+// src/compact-history.ts
+var LIMIT = 512;
+var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var summary = (value) => {
+  const text = typeof value === "string" ? value : JSON.stringify(value) ?? "";
+  return text.length > LIMIT ? text.slice(0, LIMIT) + "\n[Compact history: output omitted]" : text;
+};
+function toolValue(value) {
+  if (Array.isArray(value)) return value.map(toolValue);
+  if (!object(value)) return value;
+  const result = { ...value };
+  for (const [key, child] of Object.entries(value)) {
+    if (["input", "arguments", "output", "result", "rawInput", "rawOutput", "uiResultMeta", "meta", "argumentsDelta"].includes(key)) {
+      result[key] = typeof child === "string" ? summary(child) : { summary: summary(child) };
+    } else if (key === "content" && Array.isArray(child)) {
+      let previews = 0;
+      const blocks = child.flatMap((block) => {
+        if (object(block) && (block.type === "tool-call" || block.type === "tool-result")) return [toolValue(block)];
+        if (previews++ >= 2) return [];
+        return [{ type: "text", text: summary(object(block) ? block.text ?? block : block) }];
+      });
+      if (child.some((block) => object(block) && block.isError === true) && object(blocks[0])) blocks[0].isError = true;
+      result[key] = blocks;
+    } else if (key === "text" && typeof child === "string") result[key] = summary(child);
+    else result[key] = toolValue(child);
+  }
+  return result;
+}
+function messageValue(value) {
+  if (Array.isArray(value)) return value.map(messageValue);
+  if (!object(value)) return value;
+  if (value.type === "tool-call" || value.type === "tool-result") return toolValue(value);
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, messageValue(child)]));
+}
+function project(value) {
+  if (Array.isArray(value)) return value.map(project);
+  if (!object(value)) return value;
+  if (object(value.event) && ["tool/call", "tool/result"].includes(String(value.event.type))) {
+    const { view, ...rest } = value;
+    const event = toolValue(value.event);
+    const data2 = object(event.data) ? event.data : {};
+    const title = object(view) && object(view.view) ? view.view.title : void 0;
+    return { ...rest, event: { ...event, data: { ...data2, ...typeof title === "string" && !data2.name && !data2.toolName ? { toolName: title } : {} } } };
+  }
+  if (typeof value.type === "string" && ["tool/call", "tool/result"].includes(value.type)) return toolValue(value);
+  if (typeof value.type === "string" && ["user/message", "assistant/message"].includes(value.type)) return messageValue(value);
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, project(child)]));
+}
+function compactHistory(value) {
+  return project(value);
+}
+
+// src/codex/history-preview.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var object2 = (v) => v !== null && typeof v === "object" && !Array.isArray(v) ? v : {};
+var details = /* @__PURE__ */ new WeakMap();
+var MAX_CACHE = 16 * 1024 * 1024;
+var size = (v) => Buffer.byteLength(JSON.stringify(v), "utf8");
+async function previewCall(peer, input3, invoke) {
+  const call = object2(input3), params = object2(call.params);
+  if (call.method === "dsh/historyDetail") {
+    if (Object.keys(call).some((k) => !["method", "params"].includes(k)) || Object.keys(params).some((k) => !["threadId", "detailId"].includes(k)) || typeof params.threadId !== "string" || typeof params.detailId !== "string") throw new RpcError("INVALID_MESSAGE", "Invalid history detail request.");
+    const detail = details.get(peer)?.get(params.detailId);
+    if (!detail || detail.threadId !== params.threadId || detail.until < Date.now()) throw new RpcError("HISTORY_DETAIL_EXPIRED", "Tool details expired. Reopen the conversation and try again.");
+    await invoke({ method: "thread/read", params: { threadId: detail.threadId, includeTurns: false } });
+    return detail.record;
+  }
+  if (call.previewHistory !== true) return invoke(input3);
+  if (call.method !== "dsh/sessionHistory" || Object.keys(call).some((k) => !["method", "params", "previewHistory"].includes(k)))
+    throw new RpcError("INVALID_MESSAGE", "History preview is read-only.");
+  const result = object2(await invoke({ method: call.method, params: call.params }));
+  if (!Array.isArray(result.records) || typeof params.threadId !== "string") return result;
+  let cache = details.get(peer);
+  if (!cache) details.set(peer, cache = /* @__PURE__ */ new Map());
+  for (const [id5, value] of cache) if (value.until < Date.now()) cache.delete(id5);
+  const pending = /* @__PURE__ */ new Map();
+  let pendingBytes = 0;
+  const records = result.records.map((raw) => {
+    const record9 = object2(raw), event = object2(record9.event), data2 = object2(event.data);
+    if (event.type !== "tool/result" || size(record9) < 4096) return raw;
+    const bytes = size(record9);
+    if (bytes > MAX_CACHE) return raw;
+    if (pending.size >= 64 || pendingBytes + bytes > MAX_CACHE) {
+      throw new RpcError("RESPONSE_TOO_LARGE", "History requires chunked transfer.");
+    }
+    const id5 = randomUUID2();
+    pending.set(id5, { threadId: params.threadId, record: raw, bytes, until: Date.now() + 10 * 6e4 });
+    pendingBytes += bytes;
+    const message = object2(data2.message);
+    return { ...record9, view: void 0, event: { ...event, data: {
+      id: data2.id,
+      callId: data2.callId,
+      name: data2.name,
+      toolName: data2.toolName,
+      turn: data2.turn,
+      step: data2.step,
+      message: { source: message.source, isError: message.isError === true || Array.isArray(message.content) && message.content.some((v) => object2(v).isError === true), content: [{ type: "text", text: "Expand to load tool output" }] },
+      isError: data2.isError === true,
+      failed: data2.failed,
+      error: data2.error ? { message: "Tool execution failed" } : void 0,
+      remoteDetail: { threadId: params.threadId, detailId: id5 }
+    } } };
+  });
+  const preview = { ...result, records };
+  if (size(preview) > 2 * 1024 * 1024) throw new RpcError("RESPONSE_TOO_LARGE", "History requires chunked transfer.");
+  let cachedBytes = [...cache.values()].reduce((n, value) => n + value.bytes, 0);
+  while (cache.size + pending.size > 64 || cachedBytes + pendingBytes > MAX_CACHE) {
+    const oldest = cache.keys().next().value;
+    cachedBytes -= cache.get(oldest).bytes;
+    cache.delete(oldest);
+  }
+  for (const [id5, detail] of pending) cache.set(id5, detail);
+  return preview;
+}
+
 // src/codex/peer-bridge.ts
 import { Buffer as Buffer3 } from "node:buffer";
 var streamOpenSchema = external_exports.object({
@@ -30864,6 +31045,7 @@ var CodexPeerBridge = class {
     this.publish = publish;
     this.logger = logger;
   }
+  compactHistoryEnabled = false;
   streams = /* @__PURE__ */ new Map();
   incomingTransfers = /* @__PURE__ */ new Map();
   outgoingTransfers = /* @__PURE__ */ new Map();
@@ -30874,7 +31056,8 @@ var CodexPeerBridge = class {
   async callDomain(input3, logFailure) {
     this.requireOpen();
     try {
-      return await this.domain.call(this.context.connectionId, input3);
+      const result = await previewCall(this, input3, (value) => this.domain.call(this.context.connectionId, value));
+      return this.compactHistoryEnabled && safeMethod(input3) === "dsh/sessionHistory" ? compactHistory(result) : result;
     } catch (error) {
       if (logFailure) {
         this.logger?.warn("Codex call failed", {
@@ -31640,7 +31823,7 @@ var CodexRemoteDomain = class {
       await appServer.respond(message.id, { decision: "decline" });
       return;
     }
-    const requestHandle = randomUUID2();
+    const requestHandle = randomUUID3();
     this.approvals.set(requestHandle, {
       upstreamId: message.id,
       connectionId: owner.connectionId,
@@ -31893,10 +32076,10 @@ var CodexRemoteDomain = class {
           limit: CODEX_PAGE_LIMIT2,
           ...cursor2 === void 0 ? {} : { cursor: cursor2 }
         }));
-        for (const project of result.data) {
-          const projectRoots = project.roots.map((root) => root.path).filter((path) => isAbsolute2(path));
+        for (const project2 of result.data) {
+          const projectRoots = project2.roots.map((root) => root.path).filter((path) => isAbsolute2(path));
           if (projectRoots.length === 0) continue;
-          projectIds.add(project.id);
+          projectIds.add(project2.id);
           roots.push(...projectRoots);
         }
         cursor2 = typeof result.nextCursor === "string" && result.nextCursor.length > 0 ? result.nextCursor : void 0;
@@ -32194,11 +32377,11 @@ function sanitizeProjectList(result) {
   };
 }
 function sanitizeProjectCreate(result) {
-  const project = isRecord14(result) ? sanitizeProject(result.project) : void 0;
-  if (project === void 0) {
+  const project2 = isRecord14(result) ? sanitizeProject(result.project) : void 0;
+  if (project2 === void 0) {
     throw new RpcError("CODEX_INVALID_RESPONSE", "Codex App Server returned an invalid created project.");
   }
-  return { project };
+  return { project: project2 };
 }
 function isThreadAllowedByWorkspaceAuthority(thread, authority) {
   const projectId = typeof thread.projectId === "string" ? thread.projectId : void 0;
@@ -34087,7 +34270,7 @@ var AcpWorkspaceTools = class {
 };
 
 // src/acp/gateway.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { readdir as readdir3, realpath as realpath5, stat as stat5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { basename as basename4, isAbsolute as isAbsolute6, join as join11, relative as relative4, resolve as resolve4 } from "node:path";
@@ -34403,7 +34586,7 @@ function agySelectionArgs(catalog, modelId, effort) {
 import { promises as fs, realpathSync as realpathSync2, constants as constants3 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join8, basename as basename3 } from "node:path";
-import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash2, randomUUID as randomUUID4 } from "node:crypto";
 var EXTENSIONS = { "image/png": "png", "image/jpeg": "jpg", "image/webp": "webp", "image/gif": "gif" };
 var IMAGE_NAME = /^[0-9a-f-]{36}\.(png|jpg|webp|gif)$/;
 var TTL = 24 * 60 * 60 * 1e3;
@@ -34448,7 +34631,7 @@ async function stageImages(sessionId, images, root) {
   const paths = [];
   try {
     for (const image of parsed) {
-      const path = join8(directory, `${randomUUID3()}.${EXTENSIONS[image.mimeType]}`);
+      const path = join8(directory, `${randomUUID4()}.${EXTENSIONS[image.mimeType]}`);
       await fs.writeFile(path, Buffer.from(image.data, "base64"), { flag: "wx", mode: 384 });
       paths.push(path);
     }
@@ -36238,6 +36421,7 @@ var AcpPeerBridge = class {
     this.publish = publish;
     this.logger = logger;
   }
+  compactHistoryEnabled = false;
   toolControllers = /* @__PURE__ */ new Map();
   streams = /* @__PURE__ */ new Map();
   incomingTransfers = /* @__PURE__ */ new Map();
@@ -36252,7 +36436,8 @@ var AcpPeerBridge = class {
   async callDomain(input3, logFailure) {
     this.requireOpen();
     try {
-      return await this.domain.call(this.context.connectionId, input3);
+      const result = await this.domain.call(this.context.connectionId, input3);
+      return this.compactHistoryEnabled && safeMethod2(input3) === "dsh/sessionHistory" ? compactHistory(result) : result;
     } catch (error) {
       if (logFailure) {
         this.logger?.warn("Cursor call failed", {
@@ -37358,7 +37543,7 @@ var AcpRemoteGateway = class {
       await client.respondError(message.id, -32602, "The ACP permission options are invalid.");
       return;
     }
-    const requestHandle = randomUUID4();
+    const requestHandle = randomUUID5();
     this.approvals.set(requestHandle, {
       upstreamId: message.id,
       connectionId: owner,
@@ -37765,13 +37950,16 @@ function isRecord19(value) {
 
 // src/control-runtime.ts
 var PluginControlRuntime = class {
-  constructor(config, identityDirectory, settings, client, host) {
+  constructor(config, identityDirectory, settings, client, host, switchServer) {
     this.config = config;
     this.identityDirectory = identityDirectory;
     this.settings = settings;
     this.client = client;
     this.host = host;
+    this.switchServer = switchServer;
   }
+  logoutFlight;
+  serverSwitchFlight;
   register(connection, webServer) {
     const statusStream = new ControlStatusStream(() => this.streamStatus());
     return registerControlRoute(
@@ -37793,6 +37981,7 @@ var PluginControlRuntime = class {
   }
   async handle(endpoint, payload, signal) {
     try {
+      if (endpoint !== "settings.server.set") await this.serverSwitchFlight;
       if (endpoint === "settings.development.set") return ok3(await this.setDevelopment(payload));
       if (endpoint === "settings.get") return ok3(await this.settingsView());
       if (endpoint === "settings.configure") return ok3(await this.configure(payload));
@@ -37886,6 +38075,19 @@ var PluginControlRuntime = class {
     };
   }
   async setServer(payload) {
+    if (this.serverSwitchFlight !== void 0) {
+      throw new ClientModeError("SERVER_SWITCH_BUSY", "A Server switch is already in progress.");
+    }
+    const flight = this.applyServer(payload);
+    this.serverSwitchFlight = flight;
+    try {
+      return await flight;
+    } finally {
+      if (this.serverSwitchFlight === flight) this.serverSwitchFlight = void 0;
+    }
+  }
+  async applyServer(payload) {
+    await this.logoutFlight;
     if (this.settings === void 0) {
       throw new ClientModeError("SETTINGS_UNAVAILABLE", "DSH user settings are unavailable in this profile.");
     }
@@ -37896,6 +38098,15 @@ var PluginControlRuntime = class {
     const current = editableConfig(resolveConfig(this.settings.get()));
     const next = resolveConfig({ ...current, serverUrl: value.serverUrl });
     await this.settings.replace(editableConfig(next));
+    if (this.switchServer !== void 0) {
+      if (next.serverUrl !== this.config.serverUrl) {
+        const runtimes = await this.switchServer(next);
+        this.client = runtimes.client;
+        this.host = runtimes.host;
+      }
+      this.config = next;
+      return { ...await this.settingsView(), applies: "live" };
+    }
     return this.settingsView();
   }
   async setRole(payload) {
@@ -38017,20 +38228,28 @@ var PluginControlRuntime = class {
     const targetApi = targetRole === "host" ? new HostServerApi(serverUrl, new ServerCredentialStore(targetDirectory)) : new ClientServerApi(serverUrl, new ServerCredentialStore(targetDirectory));
     await targetApi.authorizeOwnedRole(targetIdentity, sourceCredentials.accessToken, sourceCredentials.account);
   }
-  async logout() {
-    if (this.settings === void 0) {
-      throw new ClientModeError("SETTINGS_UNAVAILABLE", "DSH user settings are unavailable in this profile.");
-    }
-    const config = resolveConfig(this.settings.get());
+  logout() {
+    if (this.logoutFlight !== void 0) return this.logoutFlight;
+    const task = this.clearAuthorization();
+    this.logoutFlight = task;
+    void task.finally(() => {
+      if (this.logoutFlight === task) this.logoutFlight = void 0;
+    }).catch(() => void 0);
+    return task;
+  }
+  async clearAuthorization() {
+    const config = this.settings === void 0 ? this.config : resolveConfig(this.settings.get());
     if (config.serverUrl !== void 0) {
-      await Promise.all([
+      const runtimes = await Promise.allSettled([
         this.client?.clearClientAuthorization(),
         this.host?.clearHostAuthorization()
       ]);
-      await Promise.all(["host", "client"].map(async (role) => {
+      const stores = await Promise.allSettled(["host", "client"].map(async (role) => {
         const directory = serverStorageDirectory(this.identityDirectory, config.serverUrl, role);
         await new ServerCredentialStore(directory).clear();
       }));
+      const failure4 = [...runtimes, ...stores].find((result) => result.status === "rejected");
+      if (failure4?.status === "rejected") throw failure4.reason;
     }
     return this.settingsView();
   }
@@ -38177,7 +38396,7 @@ function redact(value, key = "") {
 }
 
 // src/workspace-upload.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { constants as constants4 } from "node:fs";
 import { link, lstat as lstat2, open as open2, realpath as realpath6, stat as stat6, unlink } from "node:fs/promises";
 import { extname, isAbsolute as isAbsolute7, join as join12 } from "node:path";
@@ -38257,7 +38476,7 @@ var WorkspaceUploadHost = class {
     const root = await realpath6(sourceRoot);
     const directory = await stat6(root);
     if (!directory.isDirectory()) throw failure3("UPLOAD_WORKSPACE_UNAVAILABLE");
-    const temp = join12(root, `.dsh-upload-${randomUUID5()}.part`);
+    const temp = join12(root, `.dsh-upload-${randomUUID6()}.part`);
     const handle = await open2(temp, constants4.O_CREAT | constants4.O_EXCL | constants4.O_RDWR | (constants4.O_NOFOLLOW ?? 0), 384);
     const upload = { ...p, received: 0, touched: Date.now(), root, sourceRoot, dev: directory.dev, ino: directory.ino, temp, handle };
     this.uploads.set(p.uploadId, upload);
@@ -38392,7 +38611,7 @@ function unavailable2() {
 }
 
 // src/service.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 
 // src/connection-controller.ts
 var ConnectionController = class {
@@ -38494,10 +38713,10 @@ var ConnectionController = class {
     const revoked = [...this.active.values()].filter((connection) => connection.channel.peerDeviceId === deviceId);
     await Promise.all(revoked.map((connection) => this.disconnect(connection, "DEVICE_REVOKED")));
   }
-  async closeConnection(connectionId, code) {
+  async closeConnection(connectionId, code, detail) {
     const connection = this.active.get(connectionId);
     if (connection === void 0) return false;
-    await this.disconnect(connection, code);
+    await this.disconnect(connection, code, detail);
     return true;
   }
   async close() {
@@ -38548,7 +38767,7 @@ var ConnectionController = class {
       throw error instanceof Error ? error : new Error("peer send failed", { cause: error });
     }
   }
-  async disconnect(connection, code) {
+  async disconnect(connection, code, detail) {
     if (!this.isActive(connection)) return;
     this.active.delete(connection.channel.security.connectionId);
     connection.unsubscribe();
@@ -38560,7 +38779,9 @@ var ConnectionController = class {
     this.logger?.info("peer connection disconnected", {
       peerDeviceId: shortId2(connection.channel.peerDeviceId),
       connectionId: shortId2(connection.channel.security.connectionId),
-      code: code ?? "closed"
+      code: code ?? "closed",
+      closedBy: detail?.closedBy ?? "host",
+      ...detail?.retryable === void 0 ? {} : { retryable: detail.retryable }
     });
   }
   isActive(connection) {
@@ -38584,8 +38805,10 @@ function shortId2(value) {
 // src/rpc-router.ts
 var wireRequestSchema = external_exports.object({ method: external_exports.string().min(1), params: external_exports.unknown() }).strict();
 var emptyParamsSchema = external_exports.object({}).strict();
+var historyConfigureSchema = external_exports.object({ compact: external_exports.boolean() }).strict();
 var apiMethods = /* @__PURE__ */ new Set([
   "harness.transport.describe",
+  "remote.history.configure",
   "harness.api.call",
   "harness.api.transfer.open",
   "harness.api.transfer.chunk",
@@ -38710,7 +38933,7 @@ var RpcRouter = class {
     switch (method) {
       case "harness.transport.describe": {
         emptyParamsSchema.parse(params);
-        const capabilities = [...this.capabilities()];
+        const capabilities = [.../* @__PURE__ */ new Set([...this.capabilities(), "remote.history.compact.v1"])];
         let workspaceTypes;
         if (this.workspaceTypes !== void 0) {
           try {
@@ -38724,6 +38947,13 @@ var RpcRouter = class {
           ...workspaceTypes === void 0 ? {} : { workspaceTypes }
         };
       }
+      case "remote.history.configure": {
+        const { compact } = historyConfigureSchema.parse(params);
+        for (const bridge of [this.harnessApi, this.harnessRemote, this.codex, this.acp]) {
+          if (bridge !== void 0) bridge.compactHistoryEnabled = compact;
+        }
+        return { compact };
+      }
       case "harness.api.call":
         return this.requireApiProxy().call(params);
       case "harness.api.transfer.open":
@@ -39262,13 +39492,16 @@ var HostServerConnection = class {
         this.terminalError = payload.code;
         this.socket?.close(4004, "device revoked");
       } else if (payload.connectionId !== void 0) {
-        await this.dropTunnel(payload.connectionId, payload.code);
+        await this.dropTunnel(payload.connectionId, payload.code, {
+          closedBy: "server",
+          retryable: payload.retryable
+        });
         const fields = {
           code: payload.code,
           connectionId: shortId3(payload.connectionId),
           retryable: payload.retryable
         };
-        if (payload.retryable) this.logger.debug("server closed a remote connection", fields);
+        if (payload.retryable) this.logger.info("server closed a remote connection", fields);
         else this.logger.warn("server closed a remote connection", fields);
       } else {
         this.terminalError = payload.code;
@@ -39642,7 +39875,7 @@ var HostServerConnection = class {
     }));
     await this.connections.close();
   }
-  async dropTunnel(connectionId, code) {
+  async dropTunnel(connectionId, code, detail) {
     const tunnel = this.tunnels.get(connectionId);
     if (tunnel === void 0) return;
     this.tunnels.delete(connectionId);
@@ -39656,7 +39889,7 @@ var HostServerConnection = class {
     }
     if (tunnel.channel !== void 0) {
       try {
-        const closed = await this.connections.closeConnection(connectionId, code);
+        const closed = detail === void 0 ? await this.connections.closeConnection(connectionId, code) : await this.connections.closeConnection(connectionId, code, detail);
         if (!closed) await tunnel.channel.close(code);
       } catch (error) {
         await tunnel.channel.close(code).catch(() => void 0);
@@ -39896,10 +40129,16 @@ function closeCode(code) {
 }
 
 // src/remote-directory-browser.ts
-import { readdir as readdir4, stat as stat7 } from "node:fs/promises";
+import { mkdir as mkdir3, readdir as readdir4, stat as stat7 } from "node:fs/promises";
 import { homedir as homedir6, platform as platform2 } from "node:os";
 import { basename as basename5, dirname as dirname5, isAbsolute as isAbsolute8, parse, resolve as resolve5 } from "node:path";
 var MAX_ENTRIES = 500;
+async function ensureHostWorkspaceDirectory(path) {
+  if (typeof path !== "string" || path.trim() === "" || path.includes("\0") || !isAbsolute8(path) || resolve5(path) === parse(path).root) {
+    throw new RpcError("INVALID_MESSAGE", "Workspace path must be an absolute, non-root directory path.");
+  }
+  await mkdir3(path, { recursive: true });
+}
 async function listRemoteDirectory(path, signal) {
   signal?.throwIfAborted();
   const home = resolve5(homedir6());
@@ -40175,6 +40414,7 @@ var HarnessApiBridge = class {
     this.host = api.events.host.bind(api.events);
     this.answer = api.respond.bind(api);
   }
+  compactHistoryEnabled = false;
   methods;
   streams = /* @__PURE__ */ new Map();
   respondable = /* @__PURE__ */ new Map();
@@ -40206,7 +40446,10 @@ var HarnessApiBridge = class {
       );
       let response;
       if (params.method === "session.history") {
-        response = await callSessionHistory(callWithTimeout, params.payload, params.rpcId);
+        response = await callSessionHistory(async (payload) => {
+          const result = await callWithTimeout(payload);
+          return this.compactHistoryEnabled ? { ...result, result: compactHistory(result.result) } : result;
+        }, params.payload, params.rpcId);
       } else {
         response = await callWithTimeout(request.payload);
       }
@@ -40220,7 +40463,7 @@ var HarnessApiBridge = class {
         method: params.method,
         durationMs: Math.round(performance.now() - startedAt)
       });
-      return response;
+      return this.compactHistoryEnabled && params.method === "subagent.history" ? { ...response, result: compactHistory(response.result) } : response;
     } catch (error) {
       const durationMs = Math.round(performance.now() - startedAt);
       this.logger?.warn("harness api call failed", {
@@ -40838,9 +41081,16 @@ var HARNESS_REMOTE_ALLOWLIST = [
   "messageFeedback/list",
   "messageFeedback/put",
   "pluginInventory/list",
+  "pluginManager/listBundles",
+  "pluginManager/listPlugins",
+  "pluginManager/setBundleEnabled",
+  "pluginManager/setPluginEnabled",
   "permissionPresets/catalog",
   "schedule/list",
   "schedule/catalog",
+  "schedule/history",
+  "schedule/update",
+  "schedule/delete",
   "session/attachment",
   "session/cancel",
   "session/canOpenWorkspacePath",
@@ -40905,6 +41155,7 @@ var HarnessRemoteBridge = class {
     this.codexWorkspace = codexWorkspace;
     this.terminalCarrier = usesDuplexTerminal(harnessVersion) ? new TerminalCarrierCompat(gateway) : void 0;
   }
+  compactHistoryEnabled = false;
   streams = /* @__PURE__ */ new Map();
   incomingTransfers = /* @__PURE__ */ new Map();
   outgoingTransfers = /* @__PURE__ */ new Map();
@@ -40919,6 +41170,7 @@ var HarnessRemoteBridge = class {
         throw new RpcError("PERMISSION_DENIED", "Remote access settings can only be changed locally on the Host.");
       }
     }
+    await this.checkPluginManagement(params.endpoint, params.payload);
     const reservation = params.endpoint.startsWith("terminal/") ? this.terminal.check(params.endpoint, params.payload) : void 0;
     let codexResult;
     if (this.codexWorkspace !== void 0) {
@@ -40935,17 +41187,25 @@ var HarnessRemoteBridge = class {
     if (params.endpoint === "session/canOpenWorkspacePath") {
       return { ok: true, value: true };
     }
+    if (params.endpoint === "workspace/create") {
+      const request = requestArgs(params.payload);
+      const folder = typeof request.path === "string" ? request.path : "";
+      await ensureHostWorkspaceDirectory(folder);
+    }
     const startedAt = performance.now();
     const signal = AbortSignal.timeout(6e4);
     try {
       const nativePayload = normalizeWorkspaceRequestPayload(params.endpoint, params.payload, this.harnessVersion);
       const nativeResult = params.endpoint === "commands/execute" ? await dispatchCommandForHost(this.gateway, params.payload, signal, this.harnessVersion) : this.terminalCarrier !== void 0 && (params.endpoint === "terminal/write" || params.endpoint === "terminal/resize") ? await this.terminalCarrier.call(params.endpoint, nativePayload, signal) : await this.gateway.dispatch(params.endpoint, nativePayload, signal);
-      const result = params.endpoint === "directoryPicker/list" && needsDirectoryFallback(nativeResult) ? await this.directoryList(params.payload, signal) : nativeResult;
+      const result = params.endpoint === "directoryPicker/list" && needsDirectoryFallback(nativeResult) ? await this.directoryList(params.payload, signal) : filterRemotePluginInventory(params.endpoint, nativeResult);
       this.logger?.debug("harness remote call ok", {
         endpoint: params.endpoint,
         durationMs: Math.round(performance.now() - startedAt)
       });
-      const wireResult = normalizeWorkspaceBinaryResult2(params.endpoint, result);
+      const wireResult = normalizeWorkspaceBinaryResult2(
+        params.endpoint,
+        this.compactHistoryEnabled && ["session/page", "session/history", "subagent/history"].includes(params.endpoint) ? compactHistory(result) : result
+      );
       return reservation === void 0 ? wireResult : this.terminal.result(params.endpoint, params.payload, wireResult, reservation);
     } catch (error) {
       if (reservation !== void 0) this.terminal.result(params.endpoint, params.payload, { ok: false, error: { code: "FAILED", message: "", details: {} } }, reservation);
@@ -41075,6 +41335,7 @@ var HarnessRemoteBridge = class {
   async openStream(input3) {
     const params = streamOpenSchema4.parse(input3);
     this.assertAllowed(params.endpoint);
+    if (params.endpoint.startsWith("pluginManager/")) throw new RpcError("METHOD_NOT_ALLOWED", "Plugin management endpoints are not streams.");
     if (params.endpoint.startsWith("settings/")) throw new RpcError("METHOD_NOT_ALLOWED", "Settings endpoints are not streams.");
     if (TERMINAL_CALLS.has(params.endpoint)) throw new RpcError("METHOD_NOT_ALLOWED", "This terminal endpoint is not a stream.");
     if (TERMINAL_STREAMS.has(params.endpoint)) this.terminal.check(params.endpoint, params.payload);
@@ -41093,7 +41354,7 @@ var HarnessRemoteBridge = class {
       controller.abort();
       throw error;
     }
-    void this.pump(params.streamId, source, controller.signal);
+    void this.pump(params.streamId, source, controller.signal, params.endpoint === "session/follow");
     return { opened: true, streamId: params.streamId };
   }
   closeStream(input3) {
@@ -41113,6 +41374,25 @@ var HarnessRemoteBridge = class {
     for (const [, stream] of streams) stream.controller.abort(reason);
     await Promise.all([this.gateway.dispose?.(), this.codexWorkspace?.closeAll()]);
   }
+  async checkPluginManagement(endpoint, payload) {
+    if (endpoint !== "pluginManager/setPluginEnabled" && endpoint !== "pluginManager/setBundleEnabled") return;
+    const plugin = endpoint === "pluginManager/setPluginEnabled";
+    const key = plugin ? "id" : "name";
+    const parsed = external_exports.object({ args: external_exports.object({
+      [key]: external_exports.string().min(1).max(4096),
+      enabled: external_exports.boolean()
+    }).strict() }).strict().safeParse(payload);
+    if (!parsed.success) throw new RpcError("INVALID_MESSAGE", "Invalid plugin enablement request.");
+    const args = parsed.data.args;
+    const result = await this.gateway.dispatch(plugin ? "pluginManager/listPlugins" : "pluginManager/listBundles", { args: {} }, AbortSignal.timeout(6e4));
+    if (!result.ok || !Array.isArray(result.value)) throw new RpcError("PERMISSION_DENIED", "Cannot verify the Host plugin inventory.");
+    const row = result.value.find((value) => isRecord21(value) && value[plugin ? "entryId" : "name"] === args[key]);
+    if (!isRecord21(row) || row.readOnlyReason !== void 0) throw new RpcError("PERMISSION_DENIED", "The Host plugin cannot be changed remotely.");
+    const remoteModule = (value) => typeof value === "string" && /^(?:ds-harness-remote|dsh-remote)(?:\/|$)/.test(value);
+    if (remoteModule(plugin ? row.moduleName : row.name) || !plugin && (!Array.isArray(row.rows) || row.rows.some((value) => !isRecord21(value) || remoteModule(value.moduleName)) || Array.isArray(row.overrides) && row.overrides.some((value) => remoteModule(value) || value === "ds-harness-remote-tui"))) {
+      throw new RpcError("PERMISSION_DENIED", "The Remote plugin can only be enabled or disabled locally on the Host.");
+    }
+  }
   assertAllowed(endpoint) {
     if (!allowedEndpoints.has(endpoint) && !TERMINAL_CALLS.has(endpoint) && !TERMINAL_STREAMS.has(endpoint)) {
       throw new RpcError("METHOD_NOT_ALLOWED", "The requested Harness Remote endpoint is not allowed.");
@@ -41121,7 +41401,7 @@ var HarnessRemoteBridge = class {
       throw new RpcError("FEATURE_NOT_SUPPORTED", "This Harness version does not support Remote event transport.");
     }
   }
-  async pump(streamId, source, signal) {
+  async pump(streamId, source, signal, historyFollow = false) {
     let reason = "completed";
     let failure4;
     try {
@@ -41130,7 +41410,7 @@ var HarnessRemoteBridge = class {
         const frame = {
           streamId,
           hasValue: true,
-          ...value === void 0 ? {} : { value }
+          ...value === void 0 ? {} : { value: historyFollow && this.compactHistoryEnabled && isCompactSnapshot(value) ? compactHistory(value) : value }
         };
         if (encodeMessage(createEvent("harness.remote.frame", frame)).byteLength > MAX_SECURE_MESSAGE_BYTES) {
           throw new Error("Oversized Harness Remote frame");
@@ -41258,6 +41538,21 @@ function needsDirectoryFallback(result) {
   const message = result.error.message.toLocaleLowerCase();
   return code.includes("capability") || code === "directory-picker/unavailable" || code === "directory-picker-unavailable" || message.includes("browse capability") || message.includes("browser capability") || message.includes("brower capability") || message.includes("directory-picker-unavailable");
 }
+function filterRemotePluginInventory(endpoint, result) {
+  if (!result.ok) return result;
+  const isRemote = (value) => typeof value === "string" && /^(?:ds-harness-remote|dsh-remote)(?:\/|$)/.test(value);
+  const filterEntries = (entries) => entries.filter((entry) => !isRecord21(entry) || !isRemote(entry.moduleName));
+  if (endpoint === "pluginManager/listPlugins" && Array.isArray(result.value)) {
+    return { ...result, value: filterEntries(result.value) };
+  }
+  if (endpoint === "pluginManager/listBundles" && Array.isArray(result.value)) {
+    return { ...result, value: result.value.filter((bundle) => !isRecord21(bundle) || !isRemote(bundle.name)).map((bundle) => isRecord21(bundle) && Array.isArray(bundle.rows) ? { ...bundle, rows: filterEntries(bundle.rows) } : bundle) };
+  }
+  if (endpoint === "pluginInventory/list" && isRecord21(result.value) && Array.isArray(result.value.entries)) {
+    return { ...result, value: { ...result.value, entries: filterEntries(result.value.entries) } };
+  }
+  return result;
+}
 function requestArgs(payload) {
   const root = record8(payload);
   const args = isRecord21(root.args) ? root.args : root;
@@ -41269,6 +41564,9 @@ function record8(value) {
 function isRecord21(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isCompactSnapshot(value) {
+  return value !== null && typeof value === "object" && value.type === "snapshot";
+}
 
 // src/service.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
@@ -41662,7 +41960,7 @@ var HostPluginRuntime = class {
     let reportedVersion;
     let errorCode6;
     try {
-      const response = await this.apiProxy?.host.describe({ rpcId: randomUUID6(), payload: {} });
+      const response = await this.apiProxy?.host.describe({ rpcId: randomUUID7(), payload: {} });
       if (response === void 0) throw new Error("ApiProxy is unavailable");
       if (!response.result.ok) {
         errorCode6 = response.result.error.code;
@@ -42041,16 +42339,16 @@ async function renderTerminalQr(url) {
 async function renderCompactTerminalQr(url) {
   const { default: QRCode } = await import("qrcode");
   const modules = QRCode.create(url, { errorCorrectionLevel: "M" }).modules;
-  const size = modules.size + TERMINAL_QR_MARGIN * 2;
+  const size2 = modules.size + TERMINAL_QR_MARGIN * 2;
   const lines = [];
   const isBlack = (row, column) => {
     const qrRow = row - TERMINAL_QR_MARGIN;
     const qrColumn = column - TERMINAL_QR_MARGIN;
     return qrRow >= 0 && qrRow < modules.size && qrColumn >= 0 && qrColumn < modules.size && modules.get(qrRow, qrColumn) === 1;
   };
-  for (let row = 0; row < size; row += 2) {
+  for (let row = 0; row < size2; row += 2) {
     let line = "\x1B[30;47m";
-    for (let column = 0; column < size; column += 1) {
+    for (let column = 0; column < size2; column += 1) {
       const top = isBlack(row, column);
       const bottom = isBlack(row + 1, column);
       line += top ? bottom ? "\u2588" : "\u2580" : bottom ? "\u2584" : " ";
@@ -42704,9 +43002,6 @@ async function activate(ctx, readConfig, entryId, tuiBinding) {
       console.error(message);
     }
   }, config.logLevel);
-  const hostIdentities = new IdentityStore({
-    directory: config.serverUrl === void 0 ? defaultIdentityDirectory : serverStorageDirectory(defaultIdentityDirectory, config.serverUrl, "host")
-  });
   const apiProxy = ctx.get("apiProxy");
   const nativeTypertGateway = ctx.get("typertGateway");
   const hostGateway = new TypertGatewaySwitch(nativeTypertGateway);
@@ -42725,56 +43020,103 @@ async function activate(ctx, readConfig, entryId, tuiBinding) {
     };
   }
   const subprocess = ctx.get("subprocess", false);
-  const runtime = new HostPluginRuntime(
-    config,
-    hostIdentities,
-    apiProxy,
-    logger,
-    localTypertGateway,
-    () => ctx.get("fileViewerHost"),
-    subprocess === void 0 ? void 0 : subprocessTerminalSpawner(subprocess),
-    (peer) => createPluginRouteDispatcher(
-      () => ctx.get("connection"),
-      () => ctx.get("webServer")?.port,
-      peer
-    )
-  );
-  let clientRuntime;
-  const hostControl = runtime;
-  if (config.serverUrl !== void 0 && connection !== void 0) {
-    const clientIdentities = new IdentityStore({
-      directory: serverStorageDirectory(defaultIdentityDirectory, config.serverUrl, "client")
+  const createRuntimes = (config2) => {
+    const hostIdentities = new IdentityStore({
+      directory: config2.serverUrl === void 0 ? defaultIdentityDirectory : serverStorageDirectory(defaultIdentityDirectory, config2.serverUrl, "host")
     });
-    clientRuntime = new ClientModeRuntime(
-      config,
-      clientIdentities,
-      new ClientServerApi(config.serverUrl, new ServerCredentialStore(clientIdentities.directory)),
+    const runtime2 = new HostPluginRuntime(
+      config2,
+      hostIdentities,
       apiProxy,
-      nativeTypertGateway,
       logger,
-      hostControl
+      localTypertGateway,
+      () => ctx.get("fileViewerHost"),
+      subprocess === void 0 ? void 0 : subprocessTerminalSpawner(subprocess),
+      (peer) => createPluginRouteDispatcher(
+        () => ctx.get("connection"),
+        () => ctx.get("webServer")?.port,
+        peer
+      )
     );
-  }
-  const controlRuntime = connection === void 0 ? void 0 : new PluginControlRuntime(config, defaultIdentityDirectory, settingsBinding, clientRuntime, hostControl);
+    let clientRuntime2;
+    if (config2.serverUrl !== void 0 && connection !== void 0) {
+      const clientIdentities = new IdentityStore({
+        directory: serverStorageDirectory(defaultIdentityDirectory, config2.serverUrl, "client")
+      });
+      clientRuntime2 = new ClientModeRuntime(
+        config2,
+        clientIdentities,
+        new ClientServerApi(config2.serverUrl, new ServerCredentialStore(clientIdentities.directory)),
+        apiProxy,
+        nativeTypertGateway,
+        logger,
+        runtime2
+      );
+    }
+    return { runtime: runtime2, clientRuntime: clientRuntime2 };
+  };
+  let { runtime, clientRuntime } = createRuntimes(config);
+  let closed = false;
+  let clientServiceProvided = clientRuntime !== void 0;
+  let startup;
+  let replacement;
+  const replaceServer = (next) => {
+    const operation = async () => {
+      await startup;
+      if (closed) throw new Error("Remote plugin is closed");
+      const shutdown = await Promise.allSettled([clientRuntime?.close(), runtime.close()]);
+      const failure4 = shutdown.find((result) => result.status === "rejected");
+      if (failure4?.status === "rejected") throw failure4.reason;
+      if (closed) throw new Error("Remote plugin is closed");
+      const fresh = createRuntimes(next);
+      try {
+        await fresh.runtime.start();
+        await fresh.clientRuntime?.start();
+        if (closed) throw new Error("Remote plugin is closed");
+      } catch (error) {
+        await Promise.allSettled([fresh.clientRuntime?.close(), fresh.runtime.close()]);
+        throw error;
+      }
+      runtime = fresh.runtime;
+      clientRuntime = fresh.clientRuntime;
+      ctx.dshRemote = runtime;
+      if (clientRuntime !== void 0) {
+        if (clientServiceProvided) ctx.dshRemoteClient = clientRuntime;
+        else {
+          ctx.provide("dshRemoteClient", clientRuntime);
+          clientServiceProvided = true;
+        }
+      }
+      tuiTarget = { runtime, config: next };
+      if (tuiBinding !== void 0) tuiBinding.target = tuiTarget;
+      return { client: clientRuntime, host: runtime };
+    };
+    replacement = operation();
+    return replacement;
+  };
+  const controlRuntime = connection === void 0 ? void 0 : new PluginControlRuntime(config, defaultIdentityDirectory, settingsBinding, clientRuntime, runtime, replaceServer);
   ctx.provide("dshRemote", runtime);
   if (clientRuntime !== void 0) ctx.provide("dshRemoteClient", clientRuntime);
-  const tuiTarget = { runtime, config };
+  let tuiTarget = { runtime, config };
   if (tuiBinding !== void 0) tuiBinding.target = tuiTarget;
   await disableLegacyLoaderEntries(ctx, logger);
   await ctx.effect(async () => {
     const disposeControl = controlRuntime?.register(connection, webServer);
     try {
-      await runtime.start();
-      if (clientRuntime !== void 0) {
-        await clientRuntime.start();
-      } else {
-        logger.warn("client remote mode is unavailable", {
-          serverConfigured: config.serverUrl !== void 0,
-          apiProxyAvailable: apiProxy !== void 0,
-          remoteGatewayAvailable: localTypertGateway.supportsCarrier,
-          connectionAvailable: connection !== void 0
-        });
-      }
+      startup = (async () => {
+        await runtime.start();
+        if (clientRuntime !== void 0) {
+          await clientRuntime.start();
+        } else {
+          logger.warn("client remote mode is unavailable", {
+            serverConfigured: config.serverUrl !== void 0,
+            apiProxyAvailable: apiProxy !== void 0,
+            remoteGatewayAvailable: localTypertGateway.supportsCarrier,
+            connectionAvailable: connection !== void 0
+          });
+        }
+      })();
+      await startup;
     } catch (error) {
       if (tuiBinding?.target === tuiTarget) tuiBinding.target = void 0;
       await disposeControl?.();
@@ -42783,6 +43125,8 @@ async function activate(ctx, readConfig, entryId, tuiBinding) {
       throw error;
     }
     return async () => {
+      closed = true;
+      await replacement?.catch(() => void 0);
       if (tuiBinding?.target === tuiTarget) tuiBinding.target = void 0;
       await disposeControl?.();
       await clientRuntime?.close();