ds-harness-remote 0.5.11 → 0.5.13

package/dist/index.js

@@ -9574,6 +9574,10 @@ var controlFrameTypes = [
   "error"
 ];
 var rpcMethods = [
+  "workspace.upload.open",
+  "workspace.upload.chunk",
+  "workspace.upload.commit",
+  "workspace.upload.abort",
   "harness.transport.describe",
   "harness.api.call",
   "harness.api.transfer.open",
@@ -11747,6 +11751,12 @@ var AcpLiveProjection = class {
     const update = isRecord3(params.update) ? params.update : params;
     const kind = string(update.sessionUpdate) ?? string(update.type);
     const session = this.context.sessions.get(follow.sessionId);
+    if (kind === "session_info_update") {
+      if (session && params.sessionId === follow.acpSessionId && typeof update.title === "string") {
+        this.context.applySessionTitle(session, update.title);
+      }
+      return;
+    }
     if (kind === "model_selection" && isRecord3(update.selected) && update.selected.provider === this.context.backend && typeof update.selected.model === "string") {
       this.context.selectedModels.set(follow.sessionId, update.selected);
       this.context.publishProjection(follow.sessionId, "modelSelection", this.context.modelSelectionProjection(follow.sessionId), this.context.nextProjectionSeq());
@@ -12111,6 +12121,86 @@ var AcpLiveProjection = class {
   }
 };
 
+// src/acp/virtual-titles.ts
+var OPENCODE_DEFAULT_TITLE = /^(?:New|Child) session - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+var AcpSessionTitles = class {
+  constructor(backend, client, sessions, publish) {
+    this.backend = backend;
+    this.client = client;
+    this.sessions = sessions;
+    this.publish = publish;
+  }
+  pending = /* @__PURE__ */ new Map();
+  closed = false;
+  nativeTitle(title) {
+    const next = title?.trim();
+    if (!next || next === "Untitled Session" || this.backend === "opencode" && OPENCODE_DEFAULT_TITLE.test(next)) return void 0;
+    return next;
+  }
+  applyNative(session, title) {
+    const next = this.nativeTitle(title);
+    if (this.closed || session.titleOverridden || !next || this.sessions.get(session.sessionId) !== session) return;
+    session.titleFromPrompt = false;
+    this.pending.get(session.sessionId)?.abort();
+    if (next === session.title) return;
+    session.title = next;
+    this.publish(session.sessionId, next);
+  }
+  applyPrompt(session, text) {
+    if (this.backend !== "opencode" || this.closed || session.titleOverridden || session.titleFromPrompt || !session.blank && this.nativeTitle(session.title) !== void 0) return;
+    const next = Array.from(text?.replace(/\s+/g, " ").trim() ?? "").slice(0, 60).join("");
+    if (!next) return;
+    session.titleFromPrompt = true;
+    session.title = next;
+    this.publish(session.sessionId, next);
+  }
+  async refresh(session) {
+    if (this.backend === "cursor" || this.closed || session.titleOverridden || !this.client.listSessions) return;
+    this.pending.get(session.sessionId)?.abort();
+    const controller = new AbortController();
+    const signal = controller.signal;
+    this.pending.set(session.sessionId, controller);
+    const deadline = this.backend === "opencode" ? setTimeout(() => controller.abort(), 2e4) : void 0;
+    try {
+      for (const delay of this.backend === "opencode" ? [0, 1e3, 3e3, 6e3, 9e3] : [0]) {
+        if (delay) await waitForTitle(delay, signal);
+        if (signal.aborted || this.closed || session.titleOverridden) return;
+        const previous = session.title;
+        try {
+          const items = await this.client.listSessions(session.cwd, this.backend, 30, signal);
+          if (signal.aborted || this.sessions.get(session.sessionId) !== session || session.title !== previous) return;
+          const current = items.find((item) => item.conversationId === session.acpSessionId);
+          if (current && this.nativeTitle(current.title) !== void 0) {
+            this.applyNative(session, current.title);
+            return;
+          }
+        } catch {
+        }
+      }
+    } finally {
+      if (deadline !== void 0) clearTimeout(deadline);
+      if (this.pending.get(session.sessionId) === controller) this.pending.delete(session.sessionId);
+    }
+  }
+  close() {
+    this.closed = true;
+    for (const controller of this.pending.values()) controller.abort();
+    this.pending.clear();
+  }
+};
+function waitForTitle(delay, signal) {
+  return new Promise((resolve6) => {
+    const finish = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve6();
+    };
+    const timer = setTimeout(finish, delay);
+    signal.addEventListener("abort", finish, { once: true });
+    if (signal.aborted) finish();
+  });
+}
+
 // src/acp/virtual-harness.ts
 var AcpVirtualHarness = class _AcpVirtualHarness {
   constructor(client, host, backend = "cursor", hostCarrier) {
@@ -12142,7 +12232,8 @@ var AcpVirtualHarness = class _AcpVirtualHarness {
       },
       publishProjection: (...args) => owner.events.publishProjection(...args),
       nextProjectionSeq: (...args) => owner.nextProjectionSeq(...args),
-      refreshSessionTitle: (...args) => owner.refreshSessionTitle(...args),
+      refreshSessionTitle: (...args) => owner.titles.refresh(...args),
+      applySessionTitle: (...args) => owner.titles.applyNative(...args),
       publishWorkspaceBaseline: () => owner.publishWorkspaceBaseline(),
       get pendingApprovals() {
         return owner.pendingApprovals;
@@ -12190,6 +12281,12 @@ var AcpVirtualHarness = class _AcpVirtualHarness {
       },
       nextProjectionSeq: (...args) => owner.nextProjectionSeq(...args)
     });
+    this.titles = new AcpSessionTitles(
+      backend,
+      client,
+      this.sessions,
+      (sessionId, title) => this.events.publishProjection(sessionId, "title", title)
+    );
     this.api = this.events.createApiProxy();
     this.unsubscribeArchived = client.onSessionArchived?.((data2) => {
       if (this.closed || data2.backend !== this.backend) return;
@@ -12198,6 +12295,7 @@ var AcpVirtualHarness = class _AcpVirtualHarness {
   }
   live;
   events;
+  titles;
   api;
   workspaceById = /* @__PURE__ */ new Map();
   sessions = /* @__PURE__ */ new Map();
@@ -12408,6 +12506,7 @@ var AcpVirtualHarness = class _AcpVirtualHarness {
   async close() {
     if (this.closed) return;
     this.closed = true;
+    this.titles.close();
     this.unsubscribeArchived?.();
     for (const stream of this.workspaceStreams) stream.close();
     for (const stream of this.controlStreams) stream.close();
@@ -12563,6 +12662,7 @@ var AcpVirtualHarness = class _AcpVirtualHarness {
         source: requestId ? { kind: "user", rpcId: requestId } : { kind: "user" }
       });
     }
+    this.titles.applyPrompt(session, text);
     session.blank = false;
     session.running = true;
     session.updatedAt = Date.now();
@@ -12639,6 +12739,8 @@ var AcpVirtualHarness = class _AcpVirtualHarness {
     }
     if (events.length > 0) {
       session.events = events;
+      const firstUser = session.events.find((entry) => entry.event.type === "user/message");
+      this.titles.applyPrompt(session, extractPromptText(array(record(firstUser?.event.data).content)));
       session.blank = false;
       for (const event of session.events) this.cacheImageAttachments(session.sessionId, array(record(event.event.data).content ?? record(record(event.event.data).message).content));
     }
@@ -12729,11 +12831,12 @@ var AcpVirtualHarness = class _AcpVirtualHarness {
     return success(await this.client.listDirectory(path, signal));
   }
   registerSession(acpSessionId, cwd2, title, createdAt = Date.now(), updatedAt = Date.now(), blank = true) {
+    const nativeTitle = this.titles.nativeTitle(title);
     const session = {
       sessionId: `${sessionPrefix(this.backend)}${acpSessionId}`,
       acpSessionId,
       cwd: cwd2,
-      ...title === void 0 ? {} : { title },
+      ...nativeTitle === void 0 ? {} : { title: nativeTitle },
       blank,
       running: false,
       createdAt,
@@ -12743,23 +12846,9 @@ var AcpVirtualHarness = class _AcpVirtualHarness {
     this.sessions.set(session.sessionId, session);
     return session;
   }
-  applyDiscoveredTitle(session, title) {
-    const next = title.trim();
-    if (this.closed || session.titleOverridden || !next || next === "Untitled Session" || next === session.title) return;
-    session.title = next;
-    this.events.publishProjection(session.sessionId, "title", next);
-  }
-  async refreshSessionTitle(session) {
-    if (this.backend === "cursor" || this.closed || session.titleOverridden || this.client.listSessions === void 0) return;
-    try {
-      const items = await this.client.listSessions(session.cwd, this.backend, 30);
-      const current = items.find((item) => item.conversationId === session.acpSessionId);
-      if (current !== void 0 && this.sessions.get(session.sessionId) === session) this.applyDiscoveredTitle(session, current.title);
-    } catch {
-    }
-  }
   async discoverAndAttachSessions(workspace) {
     if (this.backend === "cursor") return;
+    const previousTitles = new Map([...this.sessions].map(([id5, session]) => [id5, session.title]));
     try {
       let discovered = [];
       if (this.client.listSessions !== void 0) {
@@ -12777,7 +12866,9 @@ var AcpVirtualHarness = class _AcpVirtualHarness {
         const existing = this.sessions.get(sessionId);
         if (existing !== void 0) {
           if (Number.isFinite(item.updatedAt)) existing.updatedAt = Math.max(existing.updatedAt, item.updatedAt);
-          this.applyDiscoveredTitle(existing, item.title);
+          if (!previousTitles.has(sessionId) || existing.title === previousTitles.get(sessionId)) {
+            this.titles.applyNative(existing, item.title);
+          }
         }
         if (!this.archivedSessionIds.has(sessionId) && !workspace.sessionIds.includes(sessionId)) {
           workspace.sessionIds.push(sessionId);
@@ -14103,11 +14194,11 @@ function isLanCandidatePair(localType, remoteType, localScope, remoteScope) {
     return true;
   return localType === "host" && isLocalNetworkScope(localScope) && remoteType === "prflx" && remoteScope === "unknown" || remoteType === "host" && isLocalNetworkScope(remoteScope) && localType === "prflx" && localScope === "unknown";
 }
-function isLocalNetworkScope(scope) {
-  return scope === "private" || scope === "link-local" || scope === "loopback";
+function isLocalNetworkScope(scope2) {
+  return scope2 === "private" || scope2 === "link-local" || scope2 === "loopback";
 }
-function isExplicitlyNonLanScope(scope) {
-  return scope === "public" || scope === "cgnat" || scope === "reserved";
+function isExplicitlyNonLanScope(scope2) {
+  return scope2 === "public" || scope2 === "cgnat" || scope2 === "reserved";
 }
 function increment(map, key) {
   map[key] = (map[key] ?? 0) + 1;
@@ -25962,8 +26053,15 @@ var CodexVirtualHarness = class _CodexVirtualHarness {
       }, signal));
     } catch (error) {
       if (!isLegacySessionHistoryUnsupported(error)) throw error;
-      const result = record4(await this.client.request("thread/read", { threadId, includeTurns: true }, signal));
-      const thread = record4(result.thread);
+      let thread;
+      try {
+        const result = record4(await this.client.request("thread/read", { threadId, includeTurns: true }, signal));
+        thread = record4(result.thread);
+      } catch (historyError) {
+        const code = historyError instanceof Error ? errorCode(historyError) : void 0;
+        if (!this.blankThreads.has(threadId) || code !== "CODEX_UPSTREAM_ERROR") throw historyError;
+        thread = { id: threadId, turns: [] };
+      }
       if (string2(thread.id) !== threadId) throw new Error("CodeX returned an invalid Thread history.");
       value = paginateCodexNativeHistory(
         projectCodexNativeHistory(thread, `codex:${threadId}`, this.sessionGeneration),
@@ -26949,11 +27047,11 @@ function routeStreamEvent2(event, streamId, queue) {
   const data2 = event.data;
   if (data2.streamId !== streamId) return;
   if (data2.reason === "failed") {
-    const failure3 = data2.failure;
+    const failure4 = data2.failure;
     queue.fail(remoteFailure({
-      code: typeof failure3?.code === "string" ? failure3.code : "internal",
-      message: typeof failure3?.message === "string" ? failure3.message : "The remote Harness stream failed.",
-      details: isRecord9(failure3?.details) ? failure3.details : {}
+      code: typeof failure4?.code === "string" ? failure4.code : "internal",
+      message: typeof failure4?.message === "string" ? failure4.message : "The remote Harness stream failed.",
+      details: isRecord9(failure4?.details) ? failure4.details : {}
     }));
   } else {
     queue.close();
@@ -26970,11 +27068,11 @@ function parseRpcResult(value) {
     error: { code: value.error.code, message: value.error.message, details: value.error.details }
   };
 }
-function remoteFailure(failure3) {
-  return Object.assign(new Error(failure3.message), {
+function remoteFailure(failure4) {
+  return Object.assign(new Error(failure4.message), {
     isDSHRemoteError: true,
-    code: failure3.code,
-    details: failure3.details
+    code: failure4.code,
+    details: failure4.details
   });
 }
 function bytesToBase643(bytes) {
@@ -27306,7 +27404,7 @@ function normalizeServerUrl(value) {
 }
 
 // src/version.ts
-var PLUGIN_VERSION = "0.5.11";
+var PLUGIN_VERSION = "0.5.13";
 
 // src/server-api.ts
 var TERMINAL_CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/u;
@@ -28072,7 +28170,7 @@ var TypertGatewaySwitch = class {
         return { ok: false, error: this.failure(error) };
       }
     }) : (endpoint, payload, signal) => this.localDispatch(endpoint, payload, signal, peer);
-    const open = this.localOpen === void 0 ? (async (endpoint, payload, signal) => {
+    const open3 = this.localOpen === void 0 ? (async (endpoint, payload, signal) => {
       if (this.localStream === void 0) throw new Error("The local Harness Gateway does not support Remote streams.");
       return this.localStream({ ...requestFromCarrier(endpoint, payload, signal), ...peer === void 0 ? {} : { peer } });
     }) : (endpoint, payload, signal, uplink) => this.localOpen(endpoint, payload, signal, uplink, peer);
@@ -28081,7 +28179,7 @@ var TypertGatewaySwitch = class {
       peer,
       ...this.localStream === void 0 ? {} : { stream: (request) => this.localStream({ ...request, ...peer === void 0 ? {} : { peer } }) },
       dispatch,
-      open,
+      open: open3,
       failure: (error) => this.failure(error),
       supportsCarrier: this.localDispatch !== void 0 && this.localOpen !== void 0
     };
@@ -28108,12 +28206,12 @@ var TypertGatewaySwitch = class {
       };
     }
     if (this.originalOpen !== void 0) {
-      const open = this.originalOpen;
-      const rc1 = usesRc1Arity(open);
+      const open3 = this.originalOpen;
+      const rc1 = usesRc1Arity(open3);
       this.runtime.openWireStream = (...callArgs) => {
         const endpoint = callArgs[0];
         if (this.remoteTarget === void 0 || isLocalOnlyEndpoint(endpoint)) {
-          return rc1 ? Reflect.apply(open, this.runtime, callArgs) : open.call(this.runtime, endpoint, callArgs[1], callArgs[2]);
+          return rc1 ? Reflect.apply(open3, this.runtime, callArgs) : open3.call(this.runtime, endpoint, callArgs[1], callArgs[2]);
         }
         const signal = rc1 ? callArgs[4] : callArgs[2];
         return this.openRemote(endpoint, callArgs[1], signal ?? new AbortController().signal, rc1 ? callArgs[2] : void 0);
@@ -28197,8 +28295,8 @@ function workspaceConnectionResult(endpoint, result) {
     ]
   };
 }
-function usesRc1Arity(open) {
-  return open.length >= 5;
+function usesRc1Arity(open3) {
+  return open3.length >= 5;
 }
 function endedUplink() {
   return {
@@ -28214,9 +28312,9 @@ function linkControl(signal) {
   return control;
 }
 function createLocalOpen(gateway, runtime) {
-  const open = runtime.openWireStream;
-  if (open !== void 0) {
-    return usesRc1Arity(open) ? (endpoint, payload, signal, uplink, peer) => open.call(runtime, endpoint, payload, uplink ?? endedUplink(), peer, signal, linkControl(signal)) : (endpoint, payload, signal) => open.call(runtime, endpoint, payload, signal);
+  const open3 = runtime.openWireStream;
+  if (open3 !== void 0) {
+    return usesRc1Arity(open3) ? (endpoint, payload, signal, uplink, peer) => open3.call(runtime, endpoint, payload, uplink ?? endedUplink(), peer, signal, linkControl(signal)) : (endpoint, payload, signal) => open3.call(runtime, endpoint, payload, signal);
   }
   const wire = gateway.wireStream;
   if (wire === void 0) return void 0;
@@ -28359,10 +28457,10 @@ function isUsableExternalNode(candidate, requireFrom) {
 }
 function isExecutableFile(candidate) {
   try {
-    const stat8 = statSync(candidate);
-    if (!stat8.isFile()) return false;
+    const stat9 = statSync(candidate);
+    if (!stat9.isFile()) return false;
     if (process.platform === "win32") return true;
-    return (stat8.mode & 73) !== 0;
+    return (stat9.mode & 73) !== 0;
   } catch {
     return false;
   }
@@ -30179,8 +30277,8 @@ var IdentityStore = class {
 };
 function serverStorageDirectory(root, serverUrl, role) {
   const origin = new URL(serverUrl).origin;
-  const scope = createHash("sha256").update(origin).digest("hex").slice(0, 24);
-  return join4(root, "servers", scope, role);
+  const scope2 = createHash("sha256").update(origin).digest("hex").slice(0, 24);
+  return join4(root, "servers", scope2, role);
 }
 function fingerprint(publicKey) {
   const compact = createHash("sha256").update(fromBase64Url2(publicKey)).digest("hex").slice(0, 12).toUpperCase();
@@ -30563,7 +30661,7 @@ var CodexAppServerClient = class {
       const pending = this.takePending(value.id);
       if (pending === void 0) return;
       if ("error" in value && value.error !== void 0) {
-        pending.reject(new CodexAppServerError("CODEX_UPSTREAM_ERROR", safeUpstreamError(value.error)));
+        pending.reject(safeUpstreamError(value.error));
       } else {
         pending.resolve(value.result);
       }
@@ -30599,12 +30697,26 @@ var CodexAppServerClient = class {
     for (const id5 of [...this.pending.keys()]) this.takePending(id5)?.reject(error);
   }
 };
+var CODEX_THREAD_UNMATERIALIZED = "CODEX_THREAD_UNMATERIALIZED";
+var CODEX_UNMATERIALIZED_THREAD_MESSAGE = "Codex thread has no turns yet.";
 function safeUpstreamError(value) {
-  if (!isRecord12(value) || typeof value.message !== "string") return "Codex App Server rejected the request.";
+  if (!isRecord12(value) || typeof value.message !== "string") {
+    return new CodexAppServerError("CODEX_UPSTREAM_ERROR", "Codex App Server rejected the request.");
+  }
   const message = value.message.toLowerCase();
-  if (message.includes("active writer")) return "Codex thread already has an active writer.";
-  if (message.includes("no rollout found")) return "Codex thread state is not persisted yet.";
-  return message.includes("not initialized") ? "Codex App Server is not initialized." : "Codex App Server rejected the request.";
+  if (message.includes("active writer")) {
+    return new CodexAppServerError("CODEX_UPSTREAM_ERROR", "Codex thread already has an active writer.");
+  }
+  if (message.includes("not materialized yet") || message.includes("before first user message")) {
+    return new CodexAppServerError(CODEX_THREAD_UNMATERIALIZED, CODEX_UNMATERIALIZED_THREAD_MESSAGE);
+  }
+  if (message.includes("no rollout found")) {
+    return new CodexAppServerError("CODEX_UPSTREAM_ERROR", "Codex thread state is not persisted yet.");
+  }
+  return new CodexAppServerError(
+    "CODEX_UPSTREAM_ERROR",
+    message.includes("not initialized") ? "Codex App Server is not initialized." : "Codex App Server rejected the request."
+  );
 }
 function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -30788,6 +30900,7 @@ var CodexPeerBridge = class {
       method: "thread/read",
       params: { threadId: params.threadId, includeTurns: false }
     });
+    this.requireOpen();
     this.streams.set(params.streamId, params.threadId);
     return { opened: true, streamId: params.streamId, threadId: params.threadId };
   }
@@ -30868,6 +30981,7 @@ var CodexPeerBridge = class {
       });
       throw error;
     }
+    this.requireOpen();
     const responseBytes = new TextEncoder().encode(JSON.stringify(response));
     if (responseBytes.byteLength <= INLINE_TRANSFER_RESPONSE_BYTES) return { kind: "inline", response };
     if (responseBytes.byteLength > MAX_CODEX_APP_TRANSFER_BYTES) {
@@ -30950,11 +31064,11 @@ var CodexPeerBridge = class {
     this.streams.clear();
     this.incomingTransfers.clear();
     this.outgoingTransfers.clear();
-    await Promise.all(streamIds.map((streamId) => this.publish("codex.app.stream.closed", {
+    const detach = this.domain.detachPeer(this.context.connectionId);
+    await Promise.all([detach, ...streamIds.map((streamId) => this.publish("codex.app.stream.closed", {
       streamId,
       reason: "peer-disconnected"
-    }).catch(() => void 0)));
-    await this.domain.detachPeer(this.context.connectionId);
+    }).catch(() => void 0))]);
   }
   pruneTransfers() {
     const staleBefore = Date.now() - TRANSFER_IDLE_MS;
@@ -31066,7 +31180,9 @@ var CodexRemoteDomain = class {
   async resolveThreadWorkspace(connectionId, threadId) {
     if (!this.peers.has(connectionId)) throw new RpcError("CODEX_THREAD_UNAVAILABLE", "The CodeX thread is not available on this connection.");
     try {
+      const assertCurrent = this.captureCallScope(connectionId);
       const known = await this.readKnownThread(threadId);
+      assertCurrent();
       return known.cwd;
     } catch (error) {
       if (error instanceof RpcError && error.code === "CODEX_THREAD_NOT_ALLOWED") {
@@ -31084,7 +31200,25 @@ var CodexRemoteDomain = class {
   async call(connectionId, input3) {
     const envelope = parseCallEnvelope(input3);
     const call = parseCodexCall(envelope.method, envelope.params);
-    this.requireAppServer();
+    const assertCurrent = this.captureCallScope(connectionId);
+    const result = await this.callInternal(connectionId, call, assertCurrent);
+    assertCurrent();
+    return result;
+  }
+  captureCallScope(connectionId) {
+    const appServer = this.requireAppServer();
+    const peer = this.peers.get(connectionId);
+    return () => {
+      if (this.closed || this.appServer !== appServer || !this.isAvailable()) {
+        throw new RpcError("CODEX_UNAVAILABLE", "The Codex App Server changed while handling the request.");
+      }
+      if (peer !== void 0 && this.peers.get(connectionId) !== peer) {
+        throw new RpcError("CODEX_CONNECTION_CLOSED", "The Codex connection is closed.");
+      }
+    };
+  }
+  async callInternal(connectionId, call, assertCurrent) {
+    assertCurrent();
     if (call.method === "account/read") {
       return sanitizeAccount(await this.callUpstream(call.method, call.params));
     }
@@ -31094,6 +31228,7 @@ var CodexRemoteDomain = class {
     if (call.method === "project/create") {
       const roots = call.params.roots;
       const path = await this.requireNewCodexProjectPath(roots[0].path);
+      assertCurrent();
       return sanitizeProjectCreate(await this.callUpstream(call.method, {
         name: call.params.name,
         roots: [{ path }],
@@ -31109,6 +31244,7 @@ var CodexRemoteDomain = class {
     }
     if (call.method === "thread/start") {
       const cwd2 = await this.requireCodexWorkspacePath(call.params.cwd);
+      assertCurrent();
       const permission = codexPermission(call.params, "workspace-write");
       const result = await this.callUpstream(call.method, {
         ...permission.params,
@@ -31116,6 +31252,7 @@ var CodexRemoteDomain = class {
         ...codexThreadPermissionParams(permission),
         serviceName: "deepseek_harness_remote"
       });
+      assertCurrent();
       if (extractThread(result)?.id === void 0) {
         throw new RpcError("CODEX_INVALID_RESPONSE", "Codex App Server returned an invalid thread.");
       }
@@ -31154,12 +31291,13 @@ var CodexRemoteDomain = class {
       return this.listCodexDirectory(call.params.path);
     }
     const allowedThread = threadId === void 0 ? void 0 : await this.readKnownThread(threadId);
+    assertCurrent();
     if (call.method === "thread/resume" && call.params.permissionPreset !== void 0) {
       const owner = this.turnOwners.get(threadId);
       if (owner !== void 0 && owner.connectionId !== connectionId) {
         throw new RpcError("CODEX_THREAD_BUSY", "Another Remote client is writing to this CodeX thread.");
       }
-      return this.changeThreadPermission(threadId, call.params, allowedThread);
+      return this.changeThreadPermission(threadId, call.params, allowedThread, assertCurrent);
     }
     if (call.method === "thread/read") {
       return this.callUpstream(call.method, call.params);
@@ -31172,6 +31310,7 @@ var CodexRemoteDomain = class {
     }
     let claimed = false;
     let previousOwner;
+    let claimedOwner;
     if (isThreadMutation(call.method) && threadId !== void 0) {
       const claim = this.claimTurn(
         threadId,
@@ -31181,6 +31320,7 @@ var CodexRemoteDomain = class {
       );
       claimed = claim.claimed;
       previousOwner = claim.previous;
+      claimedOwner = this.turnOwners.get(threadId);
     }
     try {
       const permission = codexPermission(call.params);
@@ -31202,13 +31342,16 @@ var CodexRemoteDomain = class {
       try {
         result = await this.callUpstream(call.method, upstreamParams);
       } catch (error) {
-        if (call.method === "thread/resume" && allowedThread !== void 0 && error instanceof RpcError && error.code === "CODEX_UPSTREAM_ERROR" && call.params.permissionPreset === void 0) {
+        assertCurrent();
+        if (call.method === "thread/resume" && allowedThread !== void 0 && error instanceof RpcError && (error.code === "CODEX_UPSTREAM_ERROR" || error.code === CODEX_THREAD_UNMATERIALIZED) && call.params.permissionPreset === void 0) {
           return { thread: allowedThread.thread };
         }
         throw error;
       }
+      assertCurrent();
       if (call.method === "thread/resume" || call.method === "thread/fork" || call.method === "thread/unarchive") {
         await this.assertResultThreadAllowed(result);
+        assertCurrent();
       }
       if (call.method === "thread/resume" || call.method === "thread/fork") {
         const resultId = extractThread(result)?.id;
@@ -31225,7 +31368,7 @@ var CodexRemoteDomain = class {
       }
       return result;
     } catch (error) {
-      if (claimed && threadId !== void 0) {
+      if (claimed && threadId !== void 0 && this.turnOwners.get(threadId) === claimedOwner) {
         if (previousOwner === void 0) this.turnOwners.delete(threadId);
         else this.turnOwners.set(threadId, previousOwner);
       }
@@ -31319,6 +31462,7 @@ var CodexRemoteDomain = class {
     const appServer = this.createAppServer(binary, this.logger);
     this.appServer = appServer;
     this.unsubscribeInbound = appServer.onInbound((message) => {
+      if (this.appServer !== appServer) return;
       void this.handleInbound(message).catch((error) => {
         this.logger.warn("Codex inbound handling failed", { code: errorCode2(error) });
       });
@@ -31434,7 +31578,7 @@ var CodexRemoteDomain = class {
     if (preset === void 0) this.permissionPresets.delete(threadId);
     else this.permissionPresets.set(threadId, preset);
   }
-  async changeThreadPermission(threadId, params, allowed) {
+  async changeThreadPermission(threadId, params, allowed, assertCurrent) {
     const permission = codexPermission(params);
     const settings = {
       ...codexTurnPermissionParams(permission, allowed.cwd),
@@ -31443,8 +31587,10 @@ var CodexRemoteDomain = class {
     let result;
     try {
       await this.callUpstream("thread/settings/update", { threadId, ...settings });
+      assertCurrent();
       result = { thread: allowed.thread, ...settings, sandbox: settings.sandboxPolicy };
     } catch (error) {
+      assertCurrent();
       if (isUnpersistedThreadError(error)) {
         return { thread: allowed.thread, ...settings, sandbox: settings.sandboxPolicy };
       }
@@ -31455,15 +31601,19 @@ var CodexRemoteDomain = class {
           ...codexThreadPermissionParams(permission),
           excludeTurns: true
         });
+        assertCurrent();
       } catch (resumeError) {
+        assertCurrent();
         if (isUnpersistedThreadError(resumeError)) {
           return { thread: allowed.thread, ...settings, sandbox: settings.sandboxPolicy };
         }
         throw resumeError;
       }
       await this.assertResultThreadAllowed(result);
+      assertCurrent();
       if (codexPermissionPresetFromResponse(result) !== params.permissionPreset) {
         await this.callUpstream("thread/settings/update", { threadId, ...settings });
+        assertCurrent();
         result = { ...isRecord14(result) ? result : {}, ...settings, sandbox: settings.sandboxPolicy };
       }
     }
@@ -31478,6 +31628,7 @@ var CodexRemoteDomain = class {
   async handleServerRequest(message) {
     const appServer = this.requireAppServer();
     await this.expireApprovals();
+    if (this.appServer !== appServer || !this.isAvailable()) return;
     if (message.method !== "item/commandExecution/requestApproval" && message.method !== "item/fileChange/requestApproval") {
       await appServer.respondError(message.id, -32601, "This Remote client does not support the server request.");
       return;
@@ -31532,13 +31683,13 @@ var CodexRemoteDomain = class {
   async readThreadForHistory(connectionId, threadId) {
     const { thread: metadata } = await this.readKnownThread(threadId);
     try {
-      return { ...metadata, turns: await this.readThreadTurns(threadId, "full") };
+      return { ...metadata, turns: await this.readThreadTurns(connectionId, threadId, "full") };
     } catch (fullError) {
       if (!isHistoryFormatFallback(fullError)) throw fullError;
       this.logHistoryFallback(connectionId, "turns-full", fullError);
     }
     try {
-      return { ...metadata, turns: await this.readThreadTurns(threadId, "summary") };
+      return { ...metadata, turns: await this.readThreadTurns(connectionId, threadId, "summary") };
     } catch (summaryError) {
       if (!isHistoryFormatFallback(summaryError)) throw summaryError;
       this.logHistoryFallback(connectionId, "turns-summary", summaryError);
@@ -31554,22 +31705,35 @@ var CodexRemoteDomain = class {
       }
       return legacyThread;
     } catch (legacyError) {
+      if (isUnmaterializedThreadError(legacyError)) {
+        this.logEmptyUnmaterializedHistory(connectionId, "thread-read-full");
+        return { ...metadata, turns: [] };
+      }
       if (!isHistoryReadRecoverable(legacyError)) throw legacyError;
       this.logHistoryFallback(connectionId, "thread-read-full", legacyError);
       throw legacyError;
     }
   }
-  async readThreadTurns(threadId, itemsView) {
+  async readThreadTurns(connectionId, threadId, itemsView) {
     const turns = [];
     let cursor2;
     for (let page = 0; page < MAX_CODEX_HISTORY_PAGES; page += 1) {
-      const result = await this.callUpstream("thread/turns/list", {
-        threadId,
-        limit: CODEX_HISTORY_PAGE_LIMIT,
-        sortDirection: "asc",
-        itemsView,
-        ...cursor2 === void 0 ? {} : { cursor: cursor2 }
-      });
+      let result;
+      try {
+        result = await this.callUpstream("thread/turns/list", {
+          threadId,
+          limit: CODEX_HISTORY_PAGE_LIMIT,
+          sortDirection: "asc",
+          itemsView,
+          ...cursor2 === void 0 ? {} : { cursor: cursor2 }
+        });
+      } catch (error) {
+        if (page === 0 && isUnmaterializedThreadError(error)) {
+          this.logEmptyUnmaterializedHistory(connectionId, `turns-${itemsView}`);
+          return [];
+        }
+        throw error;
+      }
       if (!isRecord14(result) || !Array.isArray(result.data)) {
         throw new RpcError("CODEX_INVALID_RESPONSE", "Codex App Server returned an invalid Turn page.");
       }
@@ -31622,6 +31786,12 @@ var CodexRemoteDomain = class {
       code: errorCode2(error)
     });
   }
+  logEmptyUnmaterializedHistory(connectionId, stage) {
+    this.logger.debug("Codex history projected as empty unmaterialized thread", {
+      connectionId: maskId(connectionId),
+      stage
+    });
+  }
   async assertResultThreadAllowed(result) {
     const thread = extractThread(result);
     if (thread === void 0 || typeof thread.id !== "string") {
@@ -31702,8 +31872,13 @@ var CodexRemoteDomain = class {
     return this.appServer;
   }
   async callUpstream(method, params) {
+    const appServer = this.requireAppServer();
     try {
-      return await this.requireAppServer().call(method, params);
+      const result = await appServer.call(method, params);
+      if (this.closed || this.appServer !== appServer || !this.isAvailable()) {
+        throw new RpcError("CODEX_UNAVAILABLE", "The Codex App Server changed while handling the request.");
+      }
+      return result;
     } catch (error) {
       throw mapAppServerError(error);
     }
@@ -32164,6 +32339,9 @@ function isActiveWriterMessage(message) {
 function isUnpersistedThreadError(error) {
   return error instanceof RpcError && error.code === "CODEX_UPSTREAM_ERROR" && error.message.toLowerCase().includes("not persisted yet");
 }
+function isUnmaterializedThreadError(error) {
+  return error instanceof RpcError && error.code === CODEX_THREAD_UNMATERIALIZED;
+}
 
 // src/acp/adapters/session-models.ts
 var AcpSessionModelState = class {
@@ -32803,6 +32981,9 @@ var IsolatedAcpClient = class {
         if (typeof id6 !== "string" || !/^[A-Za-z0-9_-]{1,240}$/.test(id6) || this.clients.has(id6) || this.closed || method === "session/load" && typeof result.sessionId === "string" && result.sessionId !== id6) throw new CursorAcpError("ACP_INVALID_SESSION", `${this.label} returned an invalid session.`);
         this.clients.set(id6, client2);
         const config = { ...result };
+        this.updateConfiguration(id6, { kind: "notification", method: "session/update", params: {
+          update: { sessionUpdate: "config_option_update", configOptions: config.configOptions }
+        } }, config);
         for (const key of ["models", "modes"]) {
           if (replayConfiguration[key]) config[key] = { ...config[key], ...replayConfiguration[key] };
         }
@@ -32831,10 +33012,12 @@ var IsolatedAcpClient = class {
       try {
         const modelResult = await client.call("session/set_config_option", { sessionId: id5, configId: "model", value: p.model });
         this.updateConfiguration(id5, { kind: "notification", method: "session/update", params: { update: { sessionUpdate: "config_option_update", configOptions: modelResult.configOptions } } });
+        if (this.configurations.get(id5)?.models?.currentModelId !== p.model) throw new CursorAcpError("ACP_MODEL_NOT_CONFIRMED", `${this.label} did not confirm the model change.`);
         if (p.reasoningEffort !== void 0) {
           if (!this.configurations.get(id5)?.modes?.availableModes?.some((item) => item.id === p.reasoningEffort)) throw new CursorAcpError("INVALID_MESSAGE", "The selected model does not support this thinking level.");
           const thinkingResult = await client.call("session/set_config_option", { sessionId: id5, configId: "thought_level", value: p.reasoningEffort });
           this.updateConfiguration(id5, { kind: "notification", method: "session/update", params: { update: { sessionUpdate: "config_option_update", configOptions: thinkingResult.configOptions } } });
+          if (this.configurations.get(id5)?.modes?.currentModeId !== p.reasoningEffort) throw new CursorAcpError("ACP_MODEL_NOT_CONFIRMED", `${this.label} did not confirm the thinking change.`);
         }
         return { selected: this.models(id5).current };
       } finally {
@@ -32860,14 +33043,15 @@ var IsolatedAcpClient = class {
     if (update.sessionUpdate === "current_mode_update" && typeof update.currentModeId === "string") config.modes = { ...config.modes, currentModeId: update.currentModeId };
     if (update.sessionUpdate === "config_option_update" && Array.isArray(update.configOptions)) {
       for (const option of update.configOptions) {
-        if (option.type !== "select" || !Array.isArray(option.options)) continue;
+        if (option?.type !== "select" || !Array.isArray(option.options)) continue;
+        const options = option.options.flatMap((item) => Array.isArray(item?.options) ? item.options : [item]).filter((item) => typeof item?.value === "string" && typeof item?.name === "string");
         if (option.id === "model") config.models = {
           currentModelId: option.currentValue,
-          availableModels: option.options.map((item) => ({ modelId: item.value, name: item.name }))
+          availableModels: options.map((item) => ({ modelId: item.value, name: item.name }))
         };
         if (option.id === "thought_level") config.modes = {
           currentModeId: option.currentValue,
-          availableModes: option.options.map((item) => ({ id: item.value, name: item.name }))
+          availableModes: options.map((item) => ({ id: item.value, name: item.name }))
         };
       }
     }
@@ -32956,7 +33140,7 @@ var IsolatedAcpClient = class {
 };
 
 // src/workspace-bridge.ts
-import { realpath as realpath2, lstat, readdir as readdir2, readFile as readFile4, stat as stat4, watch } from "node:fs/promises";
+import { realpath as realpath2, lstat, readdir as readdir2, open, stat as stat4, watch } from "node:fs/promises";
 import { isAbsolute as isAbsolute4, join as join7, relative as relative2, resolve as resolve2 } from "node:path";
 
 // src/remote-terminal-controller.ts
@@ -33577,11 +33761,11 @@ var AsyncQueue = class {
   }
 };
 var WorkspaceBridge = class {
-  constructor(resolveCwd, terminalEnabled, state = new WorkspaceBridgeState(), spawnTerminal = pipeTerminalSpawner(), scope) {
+  constructor(resolveCwd, terminalEnabled, state = new WorkspaceBridgeState(), spawnTerminal = pipeTerminalSpawner(), scope2) {
     this.resolveCwd = resolveCwd;
     this.terminalEnabled = terminalEnabled;
     this.state = state;
-    this.scope = scope;
+    this.scope = scope2;
     this.terminal = new RemoteTerminalController(state, spawnTerminal, terminalEnabled, (code, message) => this.scopeError(code, message));
   }
   terminal;
@@ -33652,10 +33836,26 @@ var WorkspaceBridge = class {
         return { ok: true, value: { absolutePath, version, bytes: info.size } };
       }
       if (!info.isFile()) throw this.scopeError("WORKSPACE_INVALID_PATH", "The requested workspace path is not a file.");
+      if (info.size > MAX_READ_BYTES) throw this.scopeError("WORKSPACE_TOO_LARGE", "The requested workspace file is too large.");
       const offset = readOffset(args);
       const limit = readLimit(args);
-      const bytes = await readFile4(target2);
-      if (bytes.byteLength > MAX_READ_BYTES) throw this.scopeError("WORKSPACE_TOO_LARGE", "The requested workspace file is too large.");
+      const file = await open(target2, "r");
+      let bytes;
+      try {
+        const buffer = Buffer.allocUnsafe(info.size + 1);
+        let length = 0;
+        while (length < buffer.length) {
+          signal.throwIfAborted();
+          const read = await file.read(buffer, length, buffer.length - length, length);
+          if (read.bytesRead === 0) break;
+          length += read.bytesRead;
+        }
+        if (length > MAX_READ_BYTES) throw this.scopeError("WORKSPACE_TOO_LARGE", "The requested workspace file is too large.");
+        if (length !== info.size) throw this.scopeError("WORKSPACE_CHANGED", "The workspace file changed while reading it. Retry the request.");
+        bytes = buffer.subarray(0, length);
+      } finally {
+        await file.close();
+      }
       if (endpoint === "workspaceFiles/readBytes") {
         const slice2 = bytes.subarray(offset, Math.min(offset + limit, bytes.length));
         return {
@@ -34363,16 +34563,16 @@ var TranscriptWatcher = class extends EventEmitter {
     await this.readNewLines();
   }
   async readNewLines() {
-    let stat8;
+    let stat9;
     try {
-      stat8 = await fs2.stat(this.transcriptPath);
+      stat9 = await fs2.stat(this.transcriptPath);
     } catch {
       return;
     }
-    if (stat8.size <= this.offset) return;
+    if (stat9.size <= this.offset) return;
     const handle = await fs2.open(this.transcriptPath, "r");
     try {
-      const bytesToRead = stat8.size - this.offset;
+      const bytesToRead = stat9.size - this.offset;
       const buffer = Buffer.alloc(bytesToRead);
       const { bytesRead } = await handle.read(buffer, 0, bytesToRead, this.offset);
       this.offset += bytesRead;
@@ -35047,7 +35247,32 @@ import { realpath as realpath4 } from "node:fs/promises";
 import { randomBytes as randomBytes8 } from "node:crypto";
 import { createServer as createServer2 } from "node:net";
 import { realpath as realpath3 } from "node:fs/promises";
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2, stripVTControlCharacters } from "node:util";
 var MAX_RESPONSE_BYTES = 64 * 1024;
+var execFileAsync = promisify2(execFile2);
+async function opencodeHasNativeApi(binary, args, cwd2, signal) {
+  try {
+    const { stdout, stderr } = await execFileAsync(binary, [...opencodePrivateArgs(args), "--help"], {
+      cwd: cwd2,
+      signal,
+      timeout: 2e4,
+      maxBuffer: MAX_RESPONSE_BYTES,
+      windowsHide: true,
+      killSignal: "SIGKILL"
+    });
+    const help = stripVTControlCharacters(`${stdout}
+${stderr}`);
+    const hasFlag = (name2) => new RegExp(`^\\s*(?:-[A-Za-z],?\\s+)?--${name2}(?=[\\s=,\\[]|$)`, "m").test(help);
+    const network = ["hostname", "port", "mdns"].map(hasFlag);
+    if (!/\bacp\b/i.test(help) || !hasFlag("help") || network.some(Boolean) && !network.every(Boolean)) throw new Error("Invalid ACP help");
+    return network.every(Boolean);
+  } catch (error) {
+    if (signal.aborted) throw new RpcError("OPENCODE_CLOSED", "OpenCode ACP was closed.");
+    if (error?.code === "ENOENT") throw new RpcError("OPENCODE_BINARY_UNAVAILABLE", "The Host OpenCode executable is unavailable.");
+    throw new RpcError("OPENCODE_CLI_PROBE_FAILED", "Could not inspect OpenCode ACP options. Check opencode acp --help on the Host.");
+  }
+}
 var OpencodeNativeApi = class {
   constructor(origin, request = fetch) {
     this.origin = origin;
@@ -35124,10 +35349,10 @@ function opencodePrivateArgs(args, port) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (/^--(?:port|hostname|mdns|no-mdns)(?:=|$)/.test(arg)) {
-      if (arg === "--port" || arg === "--hostname" || arg === "--mdns" && /^(true|false)$/.test(args[i + 1] ?? "")) i++;
+      if (arg === "--port" || arg === "--hostname" || (arg === "--mdns" || arg === "--no-mdns") && /^(true|false)$/.test(args[i + 1] ?? "")) i++;
     } else kept.push(arg);
   }
-  return [...kept, `--hostname=127.0.0.1`, `--port=${port}`, "--mdns=false"];
+  return port === void 0 ? kept : [...kept, `--hostname=127.0.0.1`, `--port=${port}`, "--mdns=false"];
 }
 function unavailable() {
   return new RpcError("OPENCODE_ARCHIVE_UNAVAILABLE", "OpenCode did not confirm the archive operation. Check the Host OpenCode version and retry after refreshing its session list.");
@@ -35165,6 +35390,8 @@ var OpencodeAcpClient = class _OpencodeAcpClient {
   failureNotified = false;
   startPromise;
   historyBusy = false;
+  historyStop;
+  startupAbort = new AbortController();
   nativeApi;
   archivedSessions = /* @__PURE__ */ new Set();
   archivingSessions = /* @__PURE__ */ new Set();
@@ -35206,7 +35433,10 @@ var OpencodeAcpClient = class _OpencodeAcpClient {
     if (this.closed) throw new OpencodeAcpError("OPENCODE_CLOSED", "The OpenCode domain is closed.");
     if (this.historyBusy) throw new OpencodeAcpError("OPENCODE_HISTORY_BUSY", "An OpenCode history read is already in progress.");
     this.historyBusy = true;
-    const client = new _OpencodeAcpClient(this.binary, this.logger, void 0, { ...this.options, historyReader: true });
+    const client = new _OpencodeAcpClient(this.binary, this.logger, this.spawnAcp, { ...this.options, historyReader: true });
+    let stopping;
+    const stop = () => stopping ??= client.close();
+    this.historyStop = stop;
     const updates = [];
     let bytes = 0;
     let count = 0;
@@ -35219,18 +35449,29 @@ var OpencodeAcpClient = class _OpencodeAcpClient {
       if (message.method !== "session/update" || message.params?.sessionId !== sessionId || overflow) return;
       count++;
       bytes += Buffer7.byteLength(JSON.stringify(message));
-      if (bytes > 8 * 1024 * 1024 || count > 1e4) overflow = true;
-      else updates.push(message);
+      if (bytes > 8 * 1024 * 1024 || count > 1e4) {
+        overflow = true;
+        void stop().catch(() => void 0);
+      } else updates.push(message);
     });
     try {
       await client.start();
+      if (this.closed) throw new OpencodeAcpError("OPENCODE_CLOSED", "OpenCode ACP was closed.");
       await client.call("session/load", { sessionId, cwd: cwd2, mcpServers: [] });
+      if (this.closed) throw new OpencodeAcpError("OPENCODE_CLOSED", "OpenCode ACP was closed.");
       if (overflow) throw new OpencodeAcpError("OPENCODE_HISTORY_TOO_LARGE", "OpenCode history exceeds the transfer limit.");
       return acpHistoryEvents(updates, sessionId, "opencode");
+    } catch (error) {
+      if (overflow) throw new OpencodeAcpError("OPENCODE_HISTORY_TOO_LARGE", "OpenCode history exceeds the transfer limit.");
+      throw error;
     } finally {
       unsubscribe();
-      await client.close().catch(() => void 0);
-      this.historyBusy = false;
+      try {
+        await stop();
+      } finally {
+        this.historyStop = void 0;
+        this.historyBusy = false;
+      }
     }
   }
   models = /* @__PURE__ */ new Map();
@@ -35340,14 +35581,19 @@ var OpencodeAcpClient = class _OpencodeAcpClient {
   async close() {
     if (this.closed) return;
     this.closed = true;
+    this.startupAbort.abort();
     this.ready = false;
     this.models.clear();
     this.nativeApi?.close();
     this.failPending(new OpencodeAcpError("OPENCODE_CLOSED", "OpenCode ACP was closed."));
+    const history = this.historyStop?.();
     const child = this.process;
     this.process = void 0;
-    if (child === void 0 || child.exitCode !== null || child.killed) return;
-    await new Promise((resolve6) => {
+    if (child === void 0 || child.exitCode !== null || child.killed) {
+      await history;
+      return;
+    }
+    await Promise.all([history, new Promise((resolve6) => {
       const timer = setTimeout(() => {
         child.kill("SIGKILL");
         resolve6();
@@ -35358,7 +35604,7 @@ var OpencodeAcpClient = class _OpencodeAcpClient {
         resolve6();
       });
       child.kill("SIGTERM");
-    });
+    })]);
   }
   async startOnce() {
     if (this.process !== void 0) {
@@ -35367,25 +35613,32 @@ var OpencodeAcpClient = class _OpencodeAcpClient {
     let child;
     if (this.spawnAcp) child = this.spawnAcp(this.binary);
     else {
-      const port = await opencodeLoopbackPort();
+      const args = this.options.args ?? ["acp"];
+      const nativeApiSupported = await opencodeHasNativeApi(this.binary, args, this.options.cwd, this.startupAbort.signal);
+      const port = nativeApiSupported ? await opencodeLoopbackPort() : void 0;
       if (this.closed) throw new OpencodeAcpError("OPENCODE_CLOSED", "OpenCode ACP was closed.");
-      this.nativeApi = new OpencodeNativeApi(`http://127.0.0.1:${port}`);
-      child = spawn6(this.binary, opencodePrivateArgs(this.options.args ?? ["acp"], port), {
+      if (port !== void 0) this.nativeApi = new OpencodeNativeApi(`http://127.0.0.1:${port}`);
+      child = spawn6(this.binary, opencodePrivateArgs(args, port), {
         cwd: this.options.cwd,
         stdio: ["pipe", "pipe", "pipe"],
         windowsHide: true,
-        env: { ...process.env, OPENCODE_SERVER_USERNAME: "opencode", OPENCODE_SERVER_PASSWORD: this.nativeApi.password }
+        env: { ...process.env, ...this.nativeApi ? { OPENCODE_SERVER_USERNAME: "opencode", OPENCODE_SERVER_PASSWORD: this.nativeApi.password } : {} }
       });
     }
     this.process = child;
     this.failureNotified = false;
     this.stdoutBuffer = Buffer7.alloc(0);
     this.stderrBytes = 0;
-    child.stdout.on("data", (chunk) => this.consumeStdout(Buffer7.from(chunk)));
+    child.stdout.on("data", (chunk) => {
+      if (this.process === child) this.consumeStdout(Buffer7.from(chunk));
+    });
     child.stderr.on("data", (chunk) => {
+      if (this.process !== child) return;
       this.stderrBytes = Math.min(MAX_STDERR_CAPTURE_BYTES4, this.stderrBytes + Buffer7.byteLength(chunk));
     });
-    child.on("error", (error) => this.handleProcessFailure("OPENCODE_BINARY_UNAVAILABLE", error));
+    child.on("error", (error) => {
+      if (this.process === child) this.handleProcessFailure("OPENCODE_BINARY_UNAVAILABLE", error);
+    });
     child.on("exit", (code, signal) => {
       if (this.process !== child) return;
       this.process = void 0;
@@ -35393,6 +35646,7 @@ var OpencodeAcpClient = class _OpencodeAcpClient {
       this.nativeApi?.close();
       this.nativeApi = void 0;
       this.models.clear();
+      void this.historyStop?.().catch(() => void 0);
       this.failPending(new OpencodeAcpError("OPENCODE_ACP_EXITED", "OpenCode ACP exited unexpectedly."));
       if (!this.closed) {
         this.logger?.warn("OpenCode ACP exited", {
@@ -35415,6 +35669,7 @@ var OpencodeAcpClient = class _OpencodeAcpClient {
           version: PLUGIN_VERSION
         }
       }, ACP_START_TIMEOUT_MS3);
+      if (this.closed || this.process !== child) throw new OpencodeAcpError("OPENCODE_CLOSED", "OpenCode ACP was closed.");
       this.ready = true;
       this.logger?.info("OpenCode ACP ready");
     } catch (error) {
@@ -35502,6 +35757,7 @@ var OpencodeAcpClient = class _OpencodeAcpClient {
     this.publish(inbound);
   }
   handleProcessFailure(code, cause) {
+    void this.historyStop?.().catch(() => void 0);
     this.nativeApi?.close();
     this.nativeApi = void 0;
     this.ready = false;
@@ -35778,15 +36034,15 @@ async function querySqliteJson(dbPath, sql, params = []) {
   } catch {
   }
   try {
-    const { execFile: execFile2 } = await import("node:child_process");
-    const { promisify: promisify2 } = await import("node:util");
-    const execFileAsync = promisify2(execFile2);
+    const { execFile: execFile3 } = await import("node:child_process");
+    const { promisify: promisify3 } = await import("node:util");
+    const execFileAsync2 = promisify3(execFile3);
     let formattedSql = sql;
     for (const p of params) {
       const val = typeof p === "number" ? String(p) : `'${String(p).replace(/'/g, "''")}'`;
       formattedSql = formattedSql.replace("?", val);
     }
-    const { stdout } = await execFileAsync("sqlite3", [dbPath, "-json", formattedSql]);
+    const { stdout } = await execFileAsync2("sqlite3", [dbPath, "-json", formattedSql]);
     return JSON.parse(stdout || "[]");
   } catch {
     return [];
@@ -35836,7 +36092,7 @@ async function readTranscriptSummary(baseDir, conversationId) {
   try {
     const path = await transcriptPath(baseDir, conversationId);
     if (path === void 0) return void 0;
-    const stat8 = await fs3.stat(path);
+    const stat9 = await fs3.stat(path);
     const handle = await fs3.open(path, "r");
     try {
       const buffer = Buffer.alloc(4096);
@@ -35847,7 +36103,7 @@ async function readTranscriptSummary(baseDir, conversationId) {
       if (record9.type !== "USER_INPUT") return void 0;
       const title = cleanUserPrompt(record9.content).split("\n")[0]?.trim().slice(0, 40) || (agyImageReferences(record9.content ?? "").length > 0 ? "Image" : void 0);
       if (!title) return void 0;
-      return { conversationId, title, createdAt: record9.created_at ? new Date(record9.created_at).getTime() : stat8.mtimeMs, updatedAt: stat8.mtimeMs };
+      return { conversationId, title, createdAt: record9.created_at ? new Date(record9.created_at).getTime() : stat9.mtimeMs, updatedAt: stat9.mtimeMs };
     } finally {
       await handle.close();
     }
@@ -36150,6 +36406,7 @@ var AcpPeerBridge = class {
       });
       throw error;
     }
+    this.requireOpen();
     const responseBytes = new TextEncoder().encode(JSON.stringify(response));
     if (responseBytes.byteLength <= INLINE_TRANSFER_RESPONSE_BYTES2) return { kind: "inline", response };
     if (responseBytes.byteLength > MAX_AGENT_ACP_TRANSFER_BYTES) {
@@ -36243,11 +36500,11 @@ var AcpPeerBridge = class {
     this.toolControllers.clear();
     this.incomingTransfers.clear();
     this.outgoingTransfers.clear();
+    this.domain.dropPeer(this.context.connectionId);
     await Promise.all(streamIds.map((streamId) => this.publish("agent.acp.stream.closed", {
       streamId,
       reason: "peer-disconnected"
     }).catch(() => void 0)));
-    this.domain.dropPeer(this.context.connectionId);
   }
   pruneTransfers() {
     const staleBefore = Date.now() - TRANSFER_IDLE_MS2;
@@ -36348,7 +36605,7 @@ var AcpRemoteGateway = class {
   /** Catch-up buffer for turns that finish while the Client is reconnecting. */
   recentFrames = /* @__PURE__ */ new Map();
   /** Per-prompt live updates; attached to prompt_completed when streaming was lossy. */
-  promptsInProgress = /* @__PURE__ */ new Set();
+  promptsInProgress = /* @__PURE__ */ new Map();
   cancelledSessions = /* @__PURE__ */ new Set();
   /** Identity fences asynchronous Pi preparation from a later retry of the same session. */
   preparingPrompts = /* @__PURE__ */ new Map();
@@ -36436,13 +36693,16 @@ var AcpRemoteGateway = class {
     const call = parseAcpCall(envelope.method, envelope.params);
     const sessionId = sessionIdFromParams(call.method, call.params);
     const backend = call.params.backend ?? (sessionId ? this.sessionBackends.get(sessionId) ?? this.defaultBackend() : void 0);
+    const assertCurrent = this.captureCallScope(connectionId, typeof backend === "string" ? backend : this.defaultBackend());
     const reserve = backend === "opencode" && sessionId !== void 0 && ["session/load", "session/prompt", "dsh/selectModel"].includes(call.method);
     if (reserve) {
       if (this.archivingSessions.has(sessionId)) throw new RpcError("ACP_SESSION_BUSY", "The OpenCode session is being archived.");
       this.opencodeOperations.set(sessionId, (this.opencodeOperations.get(sessionId) ?? 0) + 1);
     }
     try {
-      return await this.callInternal(connectionId, call);
+      const result = await this.callInternal(connectionId, call, assertCurrent);
+      assertCurrent();
+      return result;
     } finally {
       if (reserve) {
         const remaining = (this.opencodeOperations.get(sessionId) ?? 1) - 1;
@@ -36451,7 +36711,20 @@ var AcpRemoteGateway = class {
       }
     }
   }
-  async callInternal(connectionId, call) {
+  captureCallScope(connectionId, backend) {
+    const peer = this.peers.get(connectionId);
+    const instance = this.backendInstances.get(backend);
+    return () => {
+      if (this.closed || this.backendInstances.get(backend) !== instance || instance !== void 0 && this.requireAcp(backend) !== instance.client) {
+        throw new RpcError("CURSOR_UNAVAILABLE", "The ACP backend changed while handling the request.");
+      }
+      if (peer !== void 0 && this.peers.get(connectionId) !== peer) {
+        throw new RpcError("ACP_CONNECTION_CLOSED", "The ACP connection is closed.");
+      }
+    };
+  }
+  async callInternal(connectionId, call, assertCurrent) {
+    assertCurrent();
     this.logger.info("ACP call received", {
       method: call.method,
       sessionId: typeof call.params?.sessionId === "string" ? shortSessionId(call.params.sessionId) : void 0
@@ -36482,6 +36755,7 @@ var AcpRemoteGateway = class {
         const client = this.requireAcp(backend);
         const instance = this.backendInstances.get(backend);
         const cwd2 = await this.catalogSessionCwd(backend, sessionId2);
+        assertCurrent();
         if (this.closed || this.requireAcp(backend) !== client || this.backendInstances.get(backend) !== instance) throw new RpcError("OPENCODE_ARCHIVE_UNAVAILABLE", "The OpenCode backend changed. Refresh the session list.");
         if (this.promptsInProgress.has(sessionId2) || [...this.approvals.values()].some((item) => item.sessionId === sessionId2)) throw new RpcError("ACP_SESSION_BUSY", "Stop the OpenCode reply and resolve its approvals before archiving.");
         if (!client.archiveSession) throw new RpcError("OPENCODE_ARCHIVE_UNAVAILABLE", "The Host OpenCode adapter does not support native archiving.");
@@ -36511,6 +36785,7 @@ var AcpRemoteGateway = class {
         if (archived) throw new RpcError("ACP_SESSION_ARCHIVED", "This OpenCode session is archived.");
       }
     }
+    assertCurrent();
     if (call.method === "dsh/directoryList") {
       return this.listDirectory(String(call.params.path));
     }
@@ -36576,11 +36851,13 @@ var AcpRemoteGateway = class {
       if (backend === "antigravity") {
         if (path.trim() !== "" && call.params.prewarm !== false) {
           const cwd2 = await this.requireExistingDirectory(path);
+          assertCurrent();
           this.requireAcp("antigravity").prewarmSession?.(cwd2);
         }
         const items = await discoverAntigravitySessions(path, limit);
         if (path) {
           const cwd2 = await this.requireExistingDirectory(path);
+          assertCurrent();
           for (const item of items) this.sessionCwds.set(item.conversationId, { backend, cwd: cwd2 });
         }
         this.logger.info("ACP session list fetched", { count: items.length });
@@ -36619,6 +36896,7 @@ var AcpRemoteGateway = class {
     }
     if (call.method === "session/new") {
       const cwd2 = await this.requireExistingDirectory(String(call.params.cwd));
+      assertCurrent();
       const requestedBackend = typeof call.params.backend === "string" ? call.params.backend : this.defaultBackend();
       const acp = this.requireAcp(requestedBackend);
       const result = await acp.call("session/new", {
@@ -36626,6 +36904,7 @@ var AcpRemoteGateway = class {
         mcpServers: [],
         ...typeof call.params.mode === "string" ? { mode: call.params.mode } : {}
       });
+      assertCurrent();
       const sessionId2 = readSessionId(result);
       if (sessionId2 !== void 0) {
         const bound = this.sessionBackends.get(sessionId2);
@@ -36661,9 +36940,12 @@ var AcpRemoteGateway = class {
         throw new RpcError("INVALID_MESSAGE", "The ACP session backend does not match.");
       }
       if (targetBackend === "pi" || targetBackend === "claude" || targetBackend === "opencode") await this.catalogSessionCwd(targetBackend, sessionId);
+      assertCurrent();
       this.requireSessionOwner(connectionId, sessionId);
       const acp = this.requireAcp(targetBackend);
+      this.sessionBackends.set(sessionId, targetBackend);
       const result = await acp.call(call.method, { ...call.params, ...sessionId && this.sessionCwds.get(sessionId) ? { cwd: this.sessionCwds.get(sessionId).cwd, mcpServers: [] } : {} });
+      assertCurrent();
       const loadedId = readSessionId(result) ?? sessionId;
       if (loadedId !== void 0) {
         if (loadedId !== sessionId || this.sessionBackends.has(loadedId) && targetBackend !== void 0 && this.sessionBackends.get(loadedId) !== targetBackend) {
@@ -36681,7 +36963,9 @@ var AcpRemoteGateway = class {
       this.requireSessionOwner(connectionId, sessionId);
       const backend = call.params.backend;
       const cwd2 = await this.catalogSessionCwd(backend, sessionId);
+      assertCurrent();
       await this.requireAcp(backend).call("session/load", { sessionId, cwd: cwd2, mcpServers: [] });
+      assertCurrent();
     }
     if (call.method === "dsh/selectModel") {
       if (this.promptsInProgress.has(sessionId)) throw new RpcError("PROMPT_IN_PROGRESS", "Stop the ACP reply before changing its model.");
@@ -36690,12 +36974,15 @@ var AcpRemoteGateway = class {
         throw new RpcError("ACP_WORKSPACE_UNAVAILABLE", "The ACP session has no trusted workspace.");
       }
       const result = await this.requireAcp(session.backend).call(call.method, { ...call.params, cwd: session.cwd });
+      assertCurrent();
       this.sessionBackends.set(sessionId, session.backend);
       return sanitizeSessionResult(result);
     }
     if (call.method === "session/prompt" && sessionId !== void 0) {
       if (this.promptsInProgress.has(sessionId)) throw new RpcError("PROMPT_IN_PROGRESS", "An ACP reply is already in progress.");
-      this.promptsInProgress.add(sessionId);
+      const backend = this.sessionBackends.get(sessionId) ?? this.defaultBackend();
+      const task = { backend, client: this.requireAcp(backend) };
+      this.promptsInProgress.set(sessionId, task);
       this.cancelledSessions.delete(sessionId);
       const preparationBackend = this.sessionBackends.get(sessionId);
       if (preparationBackend === "pi" || preparationBackend === "claude") {
@@ -36704,16 +36991,18 @@ var AcpRemoteGateway = class {
         try {
           const cwd2 = await this.catalogSessionCwd(preparationBackend, sessionId);
           if (preparation.cancelled) return { accepted: false, stopReason: "cancelled" };
-          await this.requireAcp(preparationBackend).call("session/load", { sessionId, cwd: cwd2, mcpServers: [] });
+          assertCurrent();
+          await task.client.call("session/load", { sessionId, cwd: cwd2, mcpServers: [] });
           if (preparation.cancelled) return { accepted: false, stopReason: "cancelled" };
+          assertCurrent();
         } catch (error) {
           if (preparation.cancelled) return { accepted: false, stopReason: "cancelled" };
-          this.promptsInProgress.delete(sessionId);
+          if (this.promptsInProgress.get(sessionId) === task) this.promptsInProgress.delete(sessionId);
           throw error;
         } finally {
           if (this.preparingPrompts.get(sessionId) === preparation) {
             this.preparingPrompts.delete(sessionId);
-            if (preparation.cancelled) this.promptsInProgress.delete(sessionId);
+            if (preparation.cancelled && this.promptsInProgress.get(sessionId) === task) this.promptsInProgress.delete(sessionId);
           }
         }
       }
@@ -36724,7 +37013,7 @@ var AcpRemoteGateway = class {
         });
       }
       this.turnCatchUp.set(sessionId, []);
-      void this.runPromptInBackground(sessionId, call.params);
+      void this.runPromptInBackground(sessionId, call.params, task);
       return { accepted: true, stopReason: "in_progress" };
     }
     if (call.method === "session/cancel" && sessionId !== void 0) {
@@ -36747,12 +37036,12 @@ var AcpRemoteGateway = class {
     const sessionBackend = sessionId !== void 0 ? this.sessionBackends.get(sessionId) : void 0;
     return sanitizeSessionResult(await this.requireAcp(typeof call.params.backend === "string" ? call.params.backend : sessionBackend).call(call.method, call.params));
   }
-  async runPromptInBackground(sessionId, params) {
+  async runPromptInBackground(sessionId, params, task) {
+    const current = () => !this.closed && this.promptsInProgress.get(sessionId) === task && !this.pendingReconfiguration.has(task.backend) && this.backendInstances.get(task.backend)?.client === task.client;
     try {
-      const sessionBackend = this.sessionBackends.get(sessionId);
-      const acp = this.requireAcp(sessionBackend);
-      const result = await acp.call("session/prompt", params);
+      const result = await task.client.call("session/prompt", params);
       await this.inboundChain;
+      if (!current()) return;
       const stopReason = isRecord19(result) && typeof result.stopReason === "string" ? result.stopReason : "end_turn";
       const catchUp = takeTurnCatchUp(this.turnCatchUp, sessionId);
       this.logger.info("ACP prompt finished", {
@@ -36772,8 +37061,10 @@ var AcpRemoteGateway = class {
         }
       });
     } catch (error) {
+      if (!current()) return;
       this.logger?.warn("ACP session/prompt failed", { code: errorCode3(error) });
       await this.inboundChain.catch(() => void 0);
+      if (!current()) return;
       const catchUp = takeTurnCatchUp(this.turnCatchUp, sessionId);
       await this.publishToSession(sessionId, {
         method: "session/update",
@@ -36787,7 +37078,7 @@ var AcpRemoteGateway = class {
         }
       }).catch(() => void 0);
     } finally {
-      this.promptsInProgress.delete(sessionId);
+      if (this.promptsInProgress.get(sessionId) === task) this.promptsInProgress.delete(sessionId);
     }
   }
   async respond(connectionId, input3) {
@@ -36832,6 +37123,18 @@ var AcpRemoteGateway = class {
     if (!tools) throw new RpcError("ACP_CONNECTION_CLOSED", "The ACP workspace connection is closed.");
     return tools;
   }
+  /** Trusted, connection-scoped authority for the dedicated workspace uploader. */
+  resolveUploadWorkspace(connectionId, publicId) {
+    const match = /^(acp|cursor|pi|opencode|claude):(.+)$/.exec(publicId);
+    const backend = match?.[1] === "acp" ? "antigravity" : match?.[1];
+    const session = match ? this.sessionCwds.get(match[2]) : void 0;
+    if (!this.peers.has(connectionId) || !session || session.backend !== backend || this.closed) {
+      throw new RpcError("ACP_WORKSPACE_UNAVAILABLE", "The ACP session has no trusted workspace.");
+    }
+    this.requireAcp(backend);
+    this.requireSessionOwner(connectionId, match[2]);
+    return session.cwd;
+  }
   async openToolStream(connectionId, sessionId, backend, endpoint, args, signal) {
     const session = this.sessionCwds.get(sessionId);
     if (!session || session.backend !== backend) throw new RpcError("ACP_WORKSPACE_UNAVAILABLE", "The ACP session has no trusted workspace.");
@@ -36898,6 +37201,10 @@ var AcpRemoteGateway = class {
     const terminalError = await this.workspaceState.dispose((sessionId) => changed.has(sessionId.startsWith("acp:") ? "antigravity" : sessionId.startsWith("pi:") ? "pi" : sessionId.startsWith("opencode:") ? "opencode" : "cursor")).then(() => void 0, () => new RpcError("TERMINAL_CLEANUP_FAILED", "Some ACP terminal processes could not be stopped. Save the backend settings again to retry."));
     for (const id5 of sessions) {
       this.sessionOwners.delete(id5);
+      this.promptsInProgress.delete(id5);
+      const preparation = this.preparingPrompts.get(id5);
+      if (preparation) preparation.cancelled = true;
+      this.preparingPrompts.delete(id5);
       this.sessionBackends.delete(id5);
       this.recentFrames.delete(id5);
       this.turnCatchUp.delete(id5);
@@ -36932,6 +37239,9 @@ var AcpRemoteGateway = class {
     this.sessionBackends.clear();
     this.recentFrames.clear();
     this.turnCatchUp.clear();
+    this.promptsInProgress.clear();
+    for (const preparation of this.preparingPrompts.values()) preparation.cancelled = true;
+    this.preparingPrompts.clear();
     this.approvals.clear();
     const processes = await Promise.allSettled([...this.startingClients.keys()].map((client) => client.close()).concat(this.disposeAllInstances()));
     const terminalError = await terminals;
@@ -36969,8 +37279,8 @@ var AcpRemoteGateway = class {
       this.restartAttempt = 0;
       return;
     }
-    const failure3 = results.find((result) => result.status === "rejected");
-    throw failure3?.status === "rejected" ? failure3.reason : new CursorAcpError("CURSOR_BINARY_UNAVAILABLE", "No ACP backend is available.");
+    const failure4 = results.find((result) => result.status === "rejected");
+    throw failure4?.status === "rejected" ? failure4.reason : new CursorAcpError("CURSOR_BINARY_UNAVAILABLE", "No ACP backend is available.");
   }
   backendCurrent(backend) {
     return this.config.enabled && backend.enabled && !this.pendingReconfiguration.has(backend.id) && JSON.stringify(this.config.backends.find((item) => item.id === backend.id)) === JSON.stringify(backend);
@@ -37866,8 +38176,223 @@ function redact(value, key = "") {
   return Object.fromEntries(Object.entries(value).map(([childKey, child]) => [childKey, redact(child, childKey)]));
 }
 
-// src/service.ts
+// src/workspace-upload.ts
 import { randomUUID as randomUUID5 } 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";
+var WORKSPACE_UPLOAD_BYTES = 20 * 1024 * 1024;
+var WORKSPACE_UPLOAD_CHUNK = 64 * 1024;
+var scope = external_exports.object({ sessionId: external_exports.string().min(1).max(512), uploadId: external_exports.string().uuid() }).strict();
+var openParams = scope.extend({ name: external_exports.string().min(1), totalBytes: external_exports.number().int().min(0).max(WORKSPACE_UPLOAD_BYTES) }).strict();
+var chunkParams = scope.extend({ offset: external_exports.number().int().min(0), data: external_exports.string().min(1).max(Math.ceil(WORKSPACE_UPLOAD_CHUNK / 3) * 4) }).strict();
+var WorkspaceUploadHost = class {
+  constructor(resolveRoot, ttlMs = 12e4) {
+    this.resolveRoot = resolveRoot;
+    this.ttlMs = ttlMs;
+    this.timer = setInterval(() => {
+      void this.serialize(() => this.expire()).catch(() => void 0);
+    }, Math.min(ttlMs, 3e4));
+    this.timer.unref();
+  }
+  uploads = /* @__PURE__ */ new Map();
+  completed = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  lifetime = new AbortController();
+  timer;
+  closed = false;
+  call(method, input3) {
+    return this.serialize(async () => {
+      if (this.closed) throw failure3("UPLOAD_CLOSED");
+      await this.expire();
+      try {
+        switch (method) {
+          case "workspace.upload.open":
+            return await this.begin(input3);
+          case "workspace.upload.chunk":
+            return await this.append(input3);
+          case "workspace.upload.commit":
+            return await this.commit(input3);
+          case "workspace.upload.abort": {
+            const p = scope.parse(input3);
+            const upload = this.uploads.get(p.uploadId);
+            if (upload && upload.sessionId !== p.sessionId) throw failure3("UPLOAD_NOT_FOUND");
+            if (upload) await this.discard(p.uploadId, upload);
+            return { aborted: true };
+          }
+          default:
+            throw failure3("METHOD_NOT_FOUND");
+        }
+      } catch (error) {
+        const p = scope.safeParse(input3 && typeof input3 === "object" ? { sessionId: input3.sessionId, uploadId: input3.uploadId } : input3);
+        const upload = p.success ? this.uploads.get(p.data.uploadId) : void 0;
+        if (p.success && upload?.sessionId === p.data.sessionId) await this.discard(p.data.uploadId, upload);
+        if (error instanceof external_exports.ZodError || error instanceof RpcError) throw error;
+        throw failure3("UPLOAD_FAILED");
+      }
+    });
+  }
+  closeAll() {
+    this.closed = true;
+    this.lifetime.abort();
+    clearInterval(this.timer);
+    return this.serialize(async () => {
+      await Promise.all([...this.uploads].map(([id5, upload]) => this.discard(id5, upload)));
+      this.completed.clear();
+    });
+  }
+  serialize(operation) {
+    const next = this.queue.then(operation);
+    this.queue = next.catch(() => void 0);
+    return next;
+  }
+  async begin(input3) {
+    const p = openParams.parse(input3);
+    if (!validName(p.name)) throw failure3("UPLOAD_INVALID_NAME");
+    if (this.uploads.has(p.uploadId) || this.completed.has(p.uploadId)) throw failure3("UPLOAD_ID_IN_USE");
+    if (this.uploads.size >= 2) throw failure3("UPLOAD_LIMIT");
+    const sourceRoot = await this.sessionRoot(p.sessionId);
+    this.assertLive();
+    if (!sourceRoot || !isAbsolute7(sourceRoot)) throw failure3("UPLOAD_WORKSPACE_UNAVAILABLE");
+    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 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);
+    await this.validateRoot(upload);
+    return { uploadId: p.uploadId, chunkBytes: WORKSPACE_UPLOAD_CHUNK };
+  }
+  async append(input3) {
+    const p = chunkParams.parse(input3);
+    const upload = this.requireUpload(p);
+    const data2 = Buffer.from(p.data, "base64");
+    if (!data2.length || data2.length > WORKSPACE_UPLOAD_CHUNK || data2.toString("base64") !== p.data || p.offset !== upload.received || upload.received + data2.length > upload.totalBytes) throw failure3("UPLOAD_INVALID_CHUNK");
+    await this.validateRoot(upload);
+    let written = 0;
+    while (written < data2.length) {
+      const result = await upload.handle.write(data2, written, data2.length - written, upload.received + written);
+      if (!result.bytesWritten) throw failure3("UPLOAD_FAILED");
+      written += result.bytesWritten;
+    }
+    this.assertLive();
+    upload.received += data2.length;
+    upload.touched = Date.now();
+    return { uploadId: p.uploadId, receivedBytes: upload.received };
+  }
+  async commit(input3) {
+    const p = scope.parse(input3);
+    const prior = this.completed.get(p.uploadId);
+    if (prior) {
+      if (prior.sessionId !== p.sessionId) throw failure3("UPLOAD_NOT_FOUND");
+      return prior.result;
+    }
+    const upload = this.requireUpload(p);
+    if (upload.received !== upload.totalBytes) throw failure3("UPLOAD_INCOMPLETE");
+    await this.validateRoot(upload);
+    await upload.handle.sync();
+    const original = await upload.handle.stat();
+    const temp = await lstat2(upload.temp);
+    if (!temp.isFile() || temp.dev !== original.dev || temp.ino !== original.ino || temp.size !== upload.totalBytes) throw failure3("UPLOAD_WORKSPACE_CHANGED");
+    const extension = extname(upload.name);
+    const stem = upload.name.slice(0, upload.name.length - extension.length);
+    for (let suffix = 0; suffix < 1e4; suffix++) {
+      await this.validateRoot(upload);
+      const name2 = suffix === 0 ? upload.name : `${stem} (${suffix})${extension}`;
+      try {
+        await link(upload.temp, join12(upload.root, name2));
+      } catch (error) {
+        if (error.code === "EEXIST") continue;
+        throw error;
+      }
+      const result = { name: name2, path: `./${name2}`, bytes: upload.totalBytes };
+      this.completed.set(p.uploadId, { sessionId: p.sessionId, result, touched: Date.now() });
+      if (this.completed.size > 64) this.completed.delete(this.completed.keys().next().value);
+      await this.discard(p.uploadId, upload);
+      return result;
+    }
+    throw failure3("UPLOAD_NAME_CONFLICT");
+  }
+  requireUpload(p) {
+    const upload = this.uploads.get(p.uploadId);
+    if (!upload || upload.sessionId !== p.sessionId) throw failure3("UPLOAD_NOT_FOUND");
+    return upload;
+  }
+  assertLive() {
+    if (this.closed) throw failure3("UPLOAD_CLOSED");
+  }
+  async sessionRoot(sessionId) {
+    const signal = AbortSignal.any([this.lifetime.signal, AbortSignal.timeout(15e3)]);
+    let onAbort;
+    try {
+      signal.throwIfAborted();
+      return await Promise.race([
+        this.resolveRoot(sessionId, signal),
+        new Promise((_, reject) => {
+          onAbort = () => reject(failure3(this.closed ? "UPLOAD_CLOSED" : "UPLOAD_TIMEOUT"));
+          signal.addEventListener("abort", onAbort, { once: true });
+          if (signal.aborted) onAbort();
+        })
+      ]);
+    } finally {
+      if (onAbort) signal.removeEventListener("abort", onAbort);
+    }
+  }
+  async validateRoot(upload) {
+    const current = await this.sessionRoot(upload.sessionId);
+    this.assertLive();
+    if (current !== upload.sourceRoot || await realpath6(current) !== upload.root || await realpath6(upload.root) !== upload.root) throw failure3("UPLOAD_WORKSPACE_CHANGED");
+    const directory = await stat6(upload.root);
+    if (!directory.isDirectory() || directory.dev !== upload.dev || directory.ino !== upload.ino) throw failure3("UPLOAD_WORKSPACE_CHANGED");
+  }
+  async discard(id5, upload) {
+    this.uploads.delete(id5);
+    const original = await upload.handle.stat().catch(() => void 0);
+    await upload.handle.close().catch(() => void 0);
+    try {
+      const root = await lstat2(upload.root);
+      const temp = await lstat2(upload.temp);
+      if (original && root.isDirectory() && root.dev === upload.dev && root.ino === upload.ino && temp.isFile() && temp.dev === original.dev && temp.ino === original.ino) await unlink(upload.temp);
+    } catch {
+    }
+  }
+  async expire() {
+    const cutoff = Date.now() - this.ttlMs;
+    await Promise.all([...this.uploads].filter(([, u]) => u.touched <= cutoff).map(([id5, u]) => this.discard(id5, u)));
+    for (const [id5, entry] of this.completed) if (entry.touched <= cutoff) this.completed.delete(id5);
+  }
+};
+function failure3(code) {
+  return new RpcError(code, "The workspace upload could not be completed.");
+}
+function validName(name2) {
+  return Buffer.byteLength(name2, "utf8") <= 220 && name2 !== "." && name2 !== ".." && !/[/\\\x00-\x1f\x7f<>:"|?*]/u.test(name2) && !/[. ]$/u.test(name2) && !/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/iu.test(name2) && !name2.startsWith(".dsh-upload-");
+}
+
+// src/workspace-upload-authority.ts
+function workspaceUploadRootResolver(gateway, supportsHarnessSessions, codex, acp) {
+  return async (sessionId, signal) => {
+    signal.throwIfAborted();
+    if (sessionId.startsWith("codex:")) {
+      const parsed = parseCodexSessionId(sessionId);
+      if (!parsed) throw unavailable2();
+      return codex(parsed.threadId);
+    }
+    if (/^(acp|cursor|pi|opencode|claude):/.test(sessionId)) return acp(sessionId);
+    if (!gateway?.supportsCarrier || !supportsHarnessSessions()) throw unavailable2();
+    const result = await gateway.dispatch("session/list", { args: { _request: {} } }, signal);
+    signal.throwIfAborted();
+    const value = result.ok ? result.value : void 0;
+    return value?.items?.find((item) => item.sessionId === sessionId)?.cwd;
+  };
+}
+function unavailable2() {
+  return new RpcError("UPLOAD_WORKSPACE_UNAVAILABLE", "The session workspace is unavailable.");
+}
+
+// src/service.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
 
 // src/connection-controller.ts
 var ConnectionController = class {
@@ -38098,7 +38623,11 @@ var apiMethods = /* @__PURE__ */ new Set([
   "agent.acp.transfer.commit",
   "agent.acp.transfer.read",
   "agent.acp.transfer.close",
-  "plugin.route.call"
+  "plugin.route.call",
+  "workspace.upload.open",
+  "workspace.upload.chunk",
+  "workspace.upload.commit",
+  "workspace.upload.abort"
 ]);
 var HOST_CAPABILITIES = [
   "harness.api.v1",
@@ -38106,13 +38635,14 @@ var HOST_CAPABILITIES = [
   "harness.remote.v1",
   "harness.remote.transfer.v1",
   "fileviewer.read.v1",
+  "workspace.upload.v1",
   "codex.appserver.v1",
   "codex.appserver.transfer.v1",
   "agent.acp.v1",
   "agent.acp.transfer.v1"
 ];
 var RpcRouter = class {
-  constructor(harnessApi, maxPending = 128, logger, fileViewer, harnessRemote, capabilities = () => HOST_CAPABILITIES, codex, acp, loopback, workspaceTypes, pluginRoute) {
+  constructor(harnessApi, maxPending = 128, logger, fileViewer, harnessRemote, capabilities = () => HOST_CAPABILITIES, codex, acp, loopback, workspaceTypes, pluginRoute, workspaceUpload) {
     this.harnessApi = harnessApi;
     this.maxPending = maxPending;
     this.logger = logger;
@@ -38124,6 +38654,7 @@ var RpcRouter = class {
     this.loopback = loopback;
     this.workspaceTypes = workspaceTypes;
     this.pluginRoute = pluginRoute;
+    this.workspaceUpload = workspaceUpload;
   }
   active = 0;
   async closePeerStreams() {
@@ -38132,7 +38663,8 @@ var RpcRouter = class {
       this.harnessApi?.closeAll(),
       this.harnessRemote?.closeAll(),
       this.codex?.closeAll(),
-      this.acp?.closeAll()
+      this.acp?.closeAll(),
+      this.workspaceUpload?.closeAll()
     ]);
   }
   async handle(message) {
@@ -38161,7 +38693,7 @@ var RpcRouter = class {
       return createRpcResponse(request.id, result);
     } catch (error) {
       const response = errorResponse2(request.id, error);
-      const failedEndpoint = typeof request.payload.params?.endpoint === "string" ? String(request.payload.params.endpoint) : void 0;
+      const failedEndpoint = !request.payload.method.startsWith("workspace.upload.") && typeof request.payload.params?.endpoint === "string" ? String(request.payload.params.endpoint) : void 0;
       this.logger?.warn("host rpc failed", {
         method: request.payload.method,
         ...failedEndpoint ? { endpoint: failedEndpoint } : {},
@@ -38272,6 +38804,13 @@ var RpcRouter = class {
         return this.requireAcp().readTransfer(params);
       case "agent.acp.transfer.close":
         return this.requireAcp().closeTransfer(params);
+      case "workspace.upload.open":
+      case "workspace.upload.chunk":
+      case "workspace.upload.commit":
+      case "workspace.upload.abort": {
+        if (!this.workspaceUpload) throw new RpcError("FEATURE_NOT_SUPPORTED", "Workspace upload is unavailable on this Host.");
+        return this.workspaceUpload.call(method, params);
+      }
       case "plugin.route.call":
         return this.requirePluginRoute().call(params);
       default:
@@ -39357,22 +39896,22 @@ function closeCode(code) {
 }
 
 // src/remote-directory-browser.ts
-import { readdir as readdir4, stat as stat6 } from "node:fs/promises";
+import { 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 isAbsolute7, parse, resolve as resolve5 } from "node:path";
+import { basename as basename5, dirname as dirname5, isAbsolute as isAbsolute8, parse, resolve as resolve5 } from "node:path";
 var MAX_ENTRIES = 500;
 async function listRemoteDirectory(path, signal) {
   signal?.throwIfAborted();
   const home = resolve5(homedir6());
   const target2 = path === void 0 || path.trim() === "" ? home : resolve5(path);
-  if (!isAbsolute7(target2)) throw new Error("The remote directory path must be absolute.");
+  if (!isAbsolute8(target2)) throw new Error("The remote directory path must be absolute.");
   const rows = await readdir4(target2, { withFileTypes: true });
   const directories = [];
   for (const row of rows) {
     signal?.throwIfAborted();
     const child = resolve5(target2, row.name);
     let directory = row.isDirectory();
-    if (!directory && row.isSymbolicLink()) directory = await stat6(child).then((value) => value.isDirectory()).catch(() => false);
+    if (!directory && row.isSymbolicLink()) directory = await stat7(child).then((value) => value.isDirectory()).catch(() => false);
     if (!directory) continue;
     directories.push({ name: row.name, path: child, hidden: platform2() !== "win32" && row.name.startsWith(".") });
   }
@@ -40584,7 +41123,7 @@ var HarnessRemoteBridge = class {
   }
   async pump(streamId, source, signal) {
     let reason = "completed";
-    let failure3;
+    let failure4;
     try {
       for await (const value of source) {
         if (signal.aborted) break;
@@ -40601,13 +41140,13 @@ var HarnessRemoteBridge = class {
       if (signal.aborted) reason = "cancelled";
     } catch (error) {
       reason = signal.aborted ? "cancelled" : "failed";
-      if (!signal.aborted) failure3 = this.gateway.failure(error);
+      if (!signal.aborted) failure4 = this.gateway.failure(error);
     } finally {
       this.streams.delete(streamId);
       await this.publish("harness.remote.stream.closed", {
         streamId,
         reason,
-        ...failure3 === void 0 ? {} : { failure: failure3 }
+        ...failure4 === void 0 ? {} : { failure: failure4 }
       }).catch(() => void 0);
     }
   }
@@ -40816,7 +41355,13 @@ var HostPluginRuntime = class {
         // Handles and their lifetime belong to this connection; only policy is shared.
         this.createLoopbackHost(),
         () => this.hostWorkspaceTypes(),
-        pluginRoute
+        pluginRoute,
+        new WorkspaceUploadHost(workspaceUploadRootResolver(
+          peerGateway,
+          () => harnessSessionGeneration(this.harnessVersion) === "v3",
+          (threadId) => this.codex.resolveThreadWorkspace(context.connectionId, threadId),
+          (sessionId) => this.acp.resolveUploadWorkspace(context.connectionId, sessionId)
+        ))
       );
     }, this.logger);
     if (config.serverUrl !== void 0) {
@@ -41117,7 +41662,7 @@ var HostPluginRuntime = class {
     let reportedVersion;
     let errorCode6;
     try {
-      const response = await this.apiProxy?.host.describe({ rpcId: randomUUID5(), payload: {} });
+      const response = await this.apiProxy?.host.describe({ rpcId: randomUUID6(), payload: {} });
       if (response === void 0) throw new Error("ApiProxy is unavailable");
       if (!response.result.ok) {
         errorCode6 = response.result.error.code;
@@ -41133,7 +41678,7 @@ var HostPluginRuntime = class {
     return void 0;
   }
   hostCapabilities() {
-    const capabilities = [];
+    const capabilities = ["workspace.upload.v1"];
     if (this.loopbackPorts.length > 0) capabilities.push("loopback.http-ws.v1");
     if (this.localGateway?.supportsCarrier === true) {
       capabilities.push(
@@ -41290,9 +41835,9 @@ function withSignal(pending, signal) {
 }
 
 // src/cli.ts
-import { stat as stat7 } from "node:fs/promises";
+import { stat as stat8 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 var QR_POLL_INTERVAL_MS = 2e3;
 var TERMINAL_QR_MARGIN = 4;
 async function runCli(args = process.argv.slice(2), dependencies = {}) {
@@ -41383,7 +41928,7 @@ async function status(args, runtime) {
     `Server: ${serverUrl}`,
     "Host control: enabled (dsh-TUI default)"
   ];
-  if (!await exists3(join12(directory, "device.json"))) {
+  if (!await exists3(join13(directory, "device.json"))) {
     lines.push("Device: not initialized", "Authorization: logged out", "Credential: unavailable");
     write(runtime.stdout, `${lines.join("\n")}
 
@@ -41428,7 +41973,7 @@ async function logout(args, runtime) {
   const serverUrl = selectedServer();
   const root = new IdentityStore({ env: runtime.env }).directory;
   const directory = serverStorageDirectory(root, serverUrl, "host");
-  if (!await exists3(join12(directory, "device.json"))) {
+  if (!await exists3(join13(directory, "device.json"))) {
     await new ServerCredentialStore(directory).clear();
     write(runtime.stdout, "This Host is already logged out.\n");
     return 0;
@@ -41554,7 +42099,7 @@ function terminalLink(url, target2) {
 }
 async function exists3(path) {
   try {
-    await stat7(path);
+    await stat8(path);
     return true;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
@@ -42273,18 +42818,18 @@ async function createSettingsBinding(ctx, settings, readConfig, entryId) {
       }
     };
   }
-  const scope = settings.register(pluginSettingsNamespace, Config, {
+  const scope2 = settings.register(pluginSettingsNamespace, Config, {
     base: readConfig(),
     applies: "restart",
     validate: (value) => {
       resolveConfig(value);
     }
   });
-  reportSettingsMigration(ctx, await migrateLegacySettings(settings, scope));
+  reportSettingsMigration(ctx, await migrateLegacySettings(settings, scope2));
   return {
-    get: () => scope.get(),
+    get: () => scope2.get(),
     replace: async (section) => {
-      await scope.replace(section);
+      await scope2.replace(section);
     }
   };
 }