@codexhost/cli-linux-arm64 0.12.0 → 0.12.1

package/app/plugins/codebuddy/plugin.mjs

@@ -15071,6 +15071,20 @@ var harnessDisplaySetSchema = external_exports.strictObject({
   initializeOnly: external_exports.boolean().optional()
 });
 
+// ../../shared-contracts/dist/ids.js
+var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
+  message: "Identifier must not be empty or whitespace"
+});
+var harnessIdSchema = opaqueIdSchema.brand();
+var hostThreadIdSchema = opaqueIdSchema.brand();
+var hostTurnIdSchema = opaqueIdSchema.brand();
+var hostItemIdSchema = opaqueIdSchema.brand();
+var hostInteractionIdSchema = opaqueIdSchema.brand();
+
+// ../../shared-contracts/dist/thread-prewarm.js
+var threadPrewarmDiscardParamsSchema = external_exports.object({ threadId: hostThreadIdSchema });
+var threadPrewarmDiscardResultSchema = external_exports.object({ discarded: external_exports.boolean() });
+
 // ../../shared-contracts/dist/console.js
 var consoleAnnouncementSchema = external_exports.strictObject({
   title: external_exports.string().trim().min(1).max(200),
@@ -15083,6 +15097,9 @@ var consoleOpenResultSchema = external_exports.strictObject({
   url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
 });
 var CONSOLE_HOST_METHODS = Object.freeze([
+  "codexhost/console/remote-connections",
+  "codexhost/runtime/status",
+  "codexhost/remote/ssh-setup",
   "codexhost/harness/plugins/list",
   "codexhost/harness/display-settings/get",
   "codexhost/harness/display-settings/set",
@@ -15149,16 +15166,6 @@ var loadedSessionsSchema = external_exports.array(external_exports.strictObject(
   inactiveMs: external_exports.number().nonnegative()
 }));
 
-// ../../shared-contracts/dist/ids.js
-var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
-  message: "Identifier must not be empty or whitespace"
-});
-var harnessIdSchema = opaqueIdSchema.brand();
-var hostThreadIdSchema = opaqueIdSchema.brand();
-var hostTurnIdSchema = opaqueIdSchema.brand();
-var hostItemIdSchema = opaqueIdSchema.brand();
-var hostInteractionIdSchema = opaqueIdSchema.brand();
-
 // ../../shared-contracts/dist/manual-compaction.js
 var threadManualCompactionStartedSchema = external_exports.strictObject({
   threadId: hostThreadIdSchema,
@@ -16073,11 +16080,53 @@ var remoteSshSetupParamsSchema = external_exports.object({
   hostname: external_exports.string().min(1).max(1024).refine((value) => !value.startsWith("-") && !/\s/u.test(value)),
   port: external_exports.number().int().min(1).max(65535).nullable(),
   identity: external_exports.string().max(4096).nullable(),
-  action: external_exports.enum(["inspect", "install", "update", "repair"]),
+  action: external_exports.enum(["inspect", "install", "update", "repair", "uninstall"]),
+  uninstallPackage: external_exports.boolean().optional(),
   version: external_exports.string().regex(/^\d+\.\d+\.\d+$/u).nullable()
 }).strict();
 var remoteSshSetupResultSchema = external_exports.object({ state: external_exports.enum(["installed", "not-installed"]) }).strict();
 
+// ../../shared-contracts/dist/remote-connections.js
+var hostId = external_exports.string().min(1).max(1024);
+var codexSshConnectionSchema = external_exports.object({
+  hostId,
+  displayName: external_exports.string().min(1).max(1024),
+  source: external_exports.enum(["codex-managed", "discovered"]),
+  sshAlias: external_exports.string().max(1024).nullable(),
+  sshHost: external_exports.string().min(1).max(1024),
+  sshPort: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable(),
+  autoConnect: external_exports.boolean(),
+  connectionAnalyticsId: external_exports.string().max(1024).optional()
+});
+var codexSshDraftSchema = external_exports.strictObject({
+  displayName: external_exports.string().min(1).max(1024),
+  hostname: external_exports.string().min(1).max(1024),
+  sshPort: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable()
+});
+var remoteConnectionsRequestSchema = external_exports.discriminatedUnion("action", [
+  external_exports.strictObject({ action: external_exports.literal("list") }),
+  external_exports.strictObject({
+    action: external_exports.literal("save"),
+    draft: codexSshDraftSchema,
+    previous: codexSshConnectionSchema.nullable()
+  }),
+  external_exports.strictObject({ action: external_exports.literal("remove"), previous: codexSshConnectionSchema }),
+  external_exports.strictObject({ action: external_exports.literal("connect"), hostId, enabled: external_exports.boolean() }),
+  external_exports.strictObject({ action: external_exports.literal("state"), hostId }),
+  external_exports.strictObject({ action: external_exports.literal("runtime"), hostId }),
+  external_exports.strictObject({
+    action: external_exports.literal("update"),
+    hostId: hostId.refine((id) => id !== "local"),
+    version: remoteUpdateParamsSchema.shape.version
+  })
+]);
+var remoteConnectionsReplySchema = external_exports.union([
+  external_exports.strictObject({ result: jsonValueSchema }),
+  external_exports.strictObject({ error: external_exports.strictObject({ code: external_exports.number().int(), message: external_exports.string() }) })
+]);
+
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
@@ -16420,6 +16469,44 @@ async function bounded(operation, milliseconds, label, onTimeout) {
   }
 }
 
+// dist/command.js
+var codeBuddyDiscoverySpec = {
+  id: "codebuddy",
+  command: "codebuddy",
+  commandEnvironmentVariable: "CODEXHOST_CODEBUDDY_COMMAND",
+  installRoots: {
+    windows: ["${APPDATA}/npm", "~/.local/bin", VERSION_MANAGER_ROOTS],
+    posix: [
+      "~/.local/bin",
+      "~/.npm-global/bin",
+      VERSION_MANAGER_ROOTS,
+      "/opt/homebrew/bin",
+      "/usr/local/bin"
+    ]
+  }
+};
+function codeBuddyInvocation(environment, ephemeral, argumentsOverride) {
+  const resolved = resolveHarnessExecutable(codeBuddyDiscoverySpec, { environment });
+  if (!resolved)
+    throw new CodeBuddyError("notInstalled", "CLI is not installed; run codebuddy and sign in first");
+  const env = withNodeRuntimeOnPath(environment);
+  return {
+    ...commandInvocation(resolved.executable, argumentsOverride ?? [
+      "--acp",
+      ...ephemeral ? ["--no-session-persistence"] : [],
+      ...!ephemeral && [
+        "CODEXHOST_CLI_PATH",
+        "CODEXHOST_RUNTIME_ENDPOINT",
+        "CODEXHOST_RUNTIME_TOKEN",
+        "CODEXHOST_THREAD_ID"
+      ].every((key) => environment[key]) ? ["--append-system-prompt", CODEBUDDY_DELEGATION_INSTRUCTIONS] : []
+    ], env),
+    environment: env
+  };
+}
+var CODEBUDDY_DELEGATION_INSTRUCTIONS = `This Session runs inside codexhost.
+When the user requests cross-Harness agent delegation, use the executable at the CODEXHOST_CLI_PATH environment variable through your native shell tool. Start with its --help and harness list commands, then use delegate start and thread send/read/wait/cancel as documented by the CLI. Pass --format compact when reporting results. Keep the inherited CODEXHOST_RUNTIME_ENDPOINT, CODEXHOST_RUNTIME_TOKEN and CODEXHOST_THREAD_ID environment variables for all such calls; they identify this Runtime and parent Thread. Do not print or expose their values, replace the configured executable, or start delegation unless the user's request authorizes it. Native CodeBuddy Agent subagents remain available for CodeBuddy-only work.`;
+
 // dist/slash-commands.js
 var excluded = /* @__PURE__ */ new Set([
   "background",
@@ -20727,44 +20814,6 @@ var CodeBuddyCopyCleanup = class {
   }
 };
 
-// dist/command.js
-var codeBuddyDiscoverySpec = {
-  id: "codebuddy",
-  command: "codebuddy",
-  commandEnvironmentVariable: "CODEXHOST_CODEBUDDY_COMMAND",
-  installRoots: {
-    windows: ["${APPDATA}/npm", "~/.local/bin", VERSION_MANAGER_ROOTS],
-    posix: [
-      "~/.local/bin",
-      "~/.npm-global/bin",
-      VERSION_MANAGER_ROOTS,
-      "/opt/homebrew/bin",
-      "/usr/local/bin"
-    ]
-  }
-};
-function codeBuddyInvocation(environment, ephemeral, argumentsOverride) {
-  const resolved = resolveHarnessExecutable(codeBuddyDiscoverySpec, { environment });
-  if (!resolved)
-    throw new CodeBuddyError("notInstalled", "CLI is not installed; run codebuddy and sign in first");
-  const env = withNodeRuntimeOnPath(environment);
-  return {
-    ...commandInvocation(resolved.executable, argumentsOverride ?? [
-      "--acp",
-      ...ephemeral ? ["--no-session-persistence"] : [],
-      ...!ephemeral && [
-        "CODEXHOST_CLI_PATH",
-        "CODEXHOST_RUNTIME_ENDPOINT",
-        "CODEXHOST_RUNTIME_TOKEN",
-        "CODEXHOST_THREAD_ID"
-      ].every((key) => environment[key]) ? ["--append-system-prompt", CODEBUDDY_DELEGATION_INSTRUCTIONS] : []
-    ], env),
-    environment: env
-  };
-}
-var CODEBUDDY_DELEGATION_INSTRUCTIONS = `This Session runs inside codexhost.
-When the user requests cross-Harness agent delegation, use the executable at the CODEXHOST_CLI_PATH environment variable through your native shell tool. Start with its --help and harness list commands, then use delegate start and thread send/read/wait/cancel as documented by the CLI. Pass --format compact when reporting results. Keep the inherited CODEXHOST_RUNTIME_ENDPOINT, CODEXHOST_RUNTIME_TOKEN and CODEXHOST_THREAD_ID environment variables for all such calls; they identify this Runtime and parent Thread. Do not print or expose their values, replace the configured executable, or start delegation unless the user's request authorizes it. Native CodeBuddy Agent subagents remain available for CodeBuddy-only work.`;
-
 // dist/acp-client.js
 var CodeBuddyAcpClient = class {
   options;
@@ -24415,6 +24464,7 @@ function createCodeBuddyInstallation(environment) {
 }
 
 // ../../harness-broker/dist/client.js
+import { execFile as execFile4 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { lstat as lstat3, readFile as readFile5 } from "node:fs/promises";
 import net, {} from "node:net";
@@ -24424,9 +24474,12 @@ var HARNESS_BROKER_PROTOCOL_VERSION = 1;
 var HARNESS_BROKER_MAX_FRAME_BYTES = 8 * 1024 * 1024;
 var HARNESS_BROKER_MAX_PENDING_REQUESTS = 32;
 var HARNESS_BROKER_REQUEST_TIMEOUT_MS = 15e3;
+var HARNESS_BROKER_IDLE_TIMEOUT_MS = 60 * 60 * 1e3;
+var HARNESS_BROKER_RETIRING_ERROR_CODE = "brokerRetiring";
 var harnessBrokerMethodSchema = external_exports.enum([
   "adapter.inspect",
   "adapter.inspectAccount",
+  "adapter.credits",
   "adapter.open",
   "adapter.subagent.readSnapshot",
   "session.readSnapshot",
@@ -24544,6 +24597,14 @@ function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId
     return path9.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
   return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path9.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
+function harnessBrokerLaunchAgentLabel(harnessId = "claude-code") {
+  harnessPluginIdSchema.parse(harnessId);
+  return harnessId === "claude-code" ? "ai.bytepioneer.codexhost.native-harness-broker" : `ai.bytepioneer.codexhost.${harnessId}-broker`;
+}
+function harnessBrokerLaunchAgentPlistPath(environment = process.env, harnessId = "claude-code") {
+  const home = environment.HOME || os2.homedir();
+  return path9.join(home, "Library", "LaunchAgents", `${harnessBrokerLaunchAgentLabel(harnessId)}.plist`);
+}
 
 // ../../harness-broker/dist/validation.js
 var cwdSchema = external_exports.string().min(1).max(16384);
@@ -24849,10 +24910,55 @@ async function readDescriptor(descriptorPath) {
   try {
     process.kill(descriptor.ownerPid, 0);
   } catch {
-    throw new Error("Aqua Harness broker owner process is unavailable");
+    throw new BrokerNotRunningError("its owner process has exited");
   }
   return descriptor;
 }
+var BrokerNotRunningError = class extends Error {
+};
+var BrokerRetiringError = class extends Error {
+};
+var BrokerRequestNotDeliveredError = class extends Error {
+};
+var HarnessNotInstalledError = class extends Error {
+};
+var BROKER_NOT_RUNNING_CODES = /* @__PURE__ */ new Set(["ENOENT", "ECONNREFUSED"]);
+var BROKER_START_TIMEOUT_MS = 15e3;
+var BROKER_START_POLL_MS = 250;
+function classifyConnectFailure(error51) {
+  if (error51 instanceof BrokerNotRunningError)
+    return error51;
+  const code = error51?.code;
+  if (code && BROKER_NOT_RUNNING_CODES.has(code)) {
+    return new BrokerNotRunningError(code === "ENOENT" ? "its descriptor or socket is missing" : "its socket refused the connection");
+  }
+  return error51 instanceof Error ? error51 : new Error(String(error51));
+}
+function describeBrokerFailure(error51, harnessId) {
+  if (error51 instanceof BrokerNotRunningError) {
+    return `The ${harnessId} Aqua Harness broker on this Mac could not be started (${error51.message}). Keep the desktop user logged in, then repair the remote service or run on this Mac: codexhost broker install --harness ${harnessId}`;
+  }
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+function runLaunchctl(arguments_) {
+  return new Promise((resolve) => {
+    execFile4("/bin/launchctl", arguments_, { timeout: 1e4 }, (error51) => resolve(!error51));
+  });
+}
+async function startBrokerLaunchAgent(harnessId, environment) {
+  const uid = process.getuid?.();
+  if (uid === void 0)
+    return;
+  const target = `gui/${uid}/${harnessBrokerLaunchAgentLabel(harnessId)}`;
+  if (await runLaunchctl(["kickstart", target]))
+    return;
+  await runLaunchctl([
+    "bootstrap",
+    `gui/${uid}`,
+    harnessBrokerLaunchAgentPlistPath(environment, harnessId)
+  ]);
+  await runLaunchctl(["kickstart", target]);
+}
 var BrokerConnection = class _BrokerConnection {
   #onClose;
   onClose(callback) {
@@ -24876,21 +24982,31 @@ var BrokerConnection = class _BrokerConnection {
     socket.once("error", (error51) => this.#fail(error51));
   }
   static async connect(descriptorPath, harnessId) {
-    const descriptor = await readDescriptor(descriptorPath);
-    if (descriptor.harnessId !== harnessId)
-      throw new Error("Aqua broker belongs to another Harness");
-    const socket = net.createConnection(descriptor.socketPath);
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error("Timed out connecting to Aqua Harness broker")), HARNESS_BROKER_REQUEST_TIMEOUT_MS);
-      socket.once("connect", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-      socket.once("error", (error51) => {
-        clearTimeout(timeout);
-        reject(error51);
+    let descriptor;
+    let socket;
+    let connecting;
+    try {
+      descriptor = await readDescriptor(descriptorPath);
+      if (descriptor.harnessId !== harnessId)
+        throw new Error("Aqua broker belongs to another Harness");
+      connecting = net.createConnection(descriptor.socketPath);
+      const pending = connecting;
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Timed out connecting to Aqua Harness broker")), HARNESS_BROKER_REQUEST_TIMEOUT_MS);
+        pending.once("connect", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        pending.once("error", (error51) => {
+          clearTimeout(timeout);
+          reject(error51);
+        });
       });
-    });
+      socket = pending;
+    } catch (error51) {
+      connecting?.destroy();
+      throw classifyConnectFailure(error51);
+    }
     const connection = new _BrokerConnection(descriptor, socket);
     const hello = connection.#waitForHello();
     await writeBrokerFrame(socket, {
@@ -24943,15 +25059,24 @@ var BrokerConnection = class _BrokerConnection {
       }, HARNESS_BROKER_REQUEST_TIMEOUT_MS);
       this.#pending.set(id, { resolve, reject, timeout });
     });
-    await writeBrokerFrame(this.#socket, {
-      version: HARNESS_BROKER_PROTOCOL_VERSION,
-      generation: this.#descriptor.generation,
-      sequence: this.#inputSequence,
-      kind: "request",
-      id,
-      method,
-      params
-    });
+    try {
+      await writeBrokerFrame(this.#socket, {
+        version: HARNESS_BROKER_PROTOCOL_VERSION,
+        generation: this.#descriptor.generation,
+        sequence: this.#inputSequence,
+        kind: "request",
+        id,
+        method,
+        params
+      });
+    } catch (error51) {
+      const pending = this.#pending.get(id);
+      if (pending)
+        clearTimeout(pending.timeout);
+      this.#pending.delete(id);
+      response.catch(() => void 0);
+      throw new BrokerRequestNotDeliveredError(error51 instanceof Error ? error51.message : String(error51));
+    }
     return response;
   }
   close() {
@@ -24995,6 +25120,8 @@ var BrokerConnection = class _BrokerConnection {
     this.#pending.delete(frame.id);
     if (frame.ok)
       pending.resolve(frame.value);
+    else if (frame.error?.code === HARNESS_BROKER_RETIRING_ERROR_CODE)
+      pending.reject(new BrokerRetiringError(frame.error.message));
     else
       pending.reject(new Error(frame.error?.message ?? "Broker request failed"));
   }
@@ -25220,17 +25347,19 @@ var BrokeredHarnessAdapter = class {
   harnessId;
   #descriptorPath;
   #forwardEnvironment;
+  #isInstalled;
+  #startBroker;
+  #startTimeoutMs;
   #connection = null;
   #closed = false;
+  #credits = null;
+  #creditsRefresh = null;
   subagents = {
     readSnapshot: async (input) => {
       try {
-        return parseHarnessResult(await (await this.#connect()).request("adapter.subagent.readSnapshot", input));
+        return parseHarnessResult(await this.#request("adapter.subagent.readSnapshot", input));
       } catch (error51) {
-        return {
-          ok: false,
-          error: unavailable(error51 instanceof Error ? error51.message : String(error51))
-        };
+        return { ok: false, error: this.#error(error51) };
       }
     }
   };
@@ -25242,12 +25371,39 @@ var BrokeredHarnessAdapter = class {
     if (input.liveCommandCatalog)
       this.liveCommandCatalog = true;
     this.#descriptorPath = input.descriptorPath ?? defaultHarnessBrokerDescriptorPath(input.environment, this.harnessId);
+    this.#isInstalled = input.isInstalled;
+    const environment = input.environment ?? process.env;
+    this.#startBroker = input.startBroker === false ? void 0 : input.startBroker ?? (process.platform === "darwin" && !input.descriptorPath ? () => startBrokerLaunchAgent(this.harnessId, environment) : void 0);
+    this.#startTimeoutMs = input.startTimeoutMs ?? BROKER_START_TIMEOUT_MS;
+  }
+  credits() {
+    return this.#credits;
+  }
+  refreshCredits() {
+    if (this.#closed)
+      return Promise.resolve(null);
+    if (this.#creditsRefresh)
+      return this.#creditsRefresh;
+    this.#creditsRefresh = this.#readCredits().finally(() => {
+      this.#creditsRefresh = null;
+    });
+    return this.#creditsRefresh;
+  }
+  async #readCredits() {
+    try {
+      const value = await this.#request("adapter.credits", {}, true);
+      const credits = accountCreditsSnapshotSchema.nullable().parse(value);
+      if (!this.#closed)
+        this.#credits = credits;
+    } catch {
+    }
+    return this.#credits;
   }
   async inspectAccount() {
     if (this.#closed)
       return null;
     try {
-      const value = await (await this.#connect()).request("adapter.inspectAccount", {});
+      const value = await this.#request("adapter.inspectAccount", {}, true);
       return harnessAccountSnapshotSchema.nullable().parse(value);
     } catch {
       return null;
@@ -25257,33 +25413,46 @@ var BrokeredHarnessAdapter = class {
     if (this.#closed)
       return failedInspection("Aqua Harness broker adapter is closed");
     try {
-      return harnessInspectionSchema.parse(await (await this.#connect()).request("adapter.inspect", input));
+      return harnessInspectionSchema.parse(await this.#request("adapter.inspect", input, true));
     } catch (error51) {
       this.#connection = null;
-      return failedInspection(error51 instanceof Error ? error51.message : String(error51));
+      if (error51 instanceof HarnessNotInstalledError)
+        return { status: "notInstalled", error: this.#error(error51) };
+      return failedInspection(describeBrokerFailure(error51, this.harnessId));
     }
   }
   async open(input) {
     if (this.#closed)
       return { ok: false, error: unavailable("Aqua Harness broker adapter is closed", false) };
+    const safeInput = { ...input };
+    delete safeInput.environment;
+    if (this.#forwardEnvironment && input.environment) {
+      const allowed = [
+        "CODEXHOST_CLI_PATH",
+        "CODEXHOST_CLI_NODE_PATH",
+        "CODEXHOST_RUNTIME_ENDPOINT",
+        "CODEXHOST_RUNTIME_TOKEN",
+        "CODEXHOST_THREAD_ID"
+      ];
+      const environment = Object.fromEntries(Object.entries(input.environment).filter(([key, value]) => allowed.includes(key) && value !== void 0));
+      if (Object.keys(environment).length)
+        safeInput.environment = environment;
+    }
     let connection;
     try {
-      const safeInput = { ...input };
-      delete safeInput.environment;
-      if (this.#forwardEnvironment && input.environment) {
-        const allowed = [
-          "CODEXHOST_CLI_PATH",
-          "CODEXHOST_CLI_NODE_PATH",
-          "CODEXHOST_RUNTIME_ENDPOINT",
-          "CODEXHOST_RUNTIME_TOKEN",
-          "CODEXHOST_THREAD_ID"
-        ];
-        const environment = Object.fromEntries(Object.entries(input.environment).filter(([key, value]) => allowed.includes(key) && value !== void 0));
-        if (Object.keys(environment).length)
-          safeInput.environment = environment;
-      }
-      connection = await this.#connect();
-      const result = parseHarnessResult(await connection.request("adapter.open", safeInput));
+      let value;
+      for (let attempt = 0; ; attempt += 1) {
+        connection = await this.#connect();
+        try {
+          value = await connection.request("adapter.open", safeInput);
+          break;
+        } catch (error51) {
+          if (attempt > 0 || !(error51 instanceof BrokerRetiringError || error51 instanceof BrokerRequestNotDeliveredError))
+            throw error51;
+          this.#connection = null;
+        }
+      }
+      const result = parseHarnessResult(value);
       if (!result.ok)
         return result;
       const session = new BrokeredHarnessSession(connection, parseSessionMetadata(result.value), this.harnessId, safeInput, () => this.#connect(), () => {
@@ -25294,25 +25463,51 @@ var BrokeredHarnessAdapter = class {
     } catch (error51) {
       connection?.close();
       this.#connection = null;
-      return {
-        ok: false,
-        error: unavailable(error51 instanceof Error ? error51.message : String(error51))
-      };
+      return { ok: false, error: this.#error(error51) };
     }
   }
   async close() {
     this.#closed = true;
+    this.#credits = null;
     await Promise.allSettled([...this.#sessions].map((session) => session.close()));
     this.#sessions.clear();
     const connection = await this.#connection?.catch(() => null);
     await connection?.dispose();
     this.#connection = null;
   }
+  #error(error51) {
+    if (error51 instanceof HarnessNotInstalledError)
+      return {
+        code: "notInstalled",
+        message: error51.message,
+        retryable: false,
+        stage: "harnessBroker"
+      };
+    return unavailable(describeBrokerFailure(error51, this.harnessId));
+  }
+  /**
+   * Sends one adapter-level request. A broker that retired between requests refuses it
+   * unprocessed, so it is retried once on a fresh broker. Idempotent reads also retry
+   * once after a plain disconnect.
+   */
+  async #request(method, params, idempotent = false) {
+    for (let attempt = 0; ; attempt += 1) {
+      const connection = await this.#connect();
+      try {
+        return await connection.request(method, params);
+      } catch (error51) {
+        const retryable = error51 instanceof BrokerRetiringError || error51 instanceof BrokerRequestNotDeliveredError || idempotent && connection.closed;
+        if (attempt > 0 || !retryable)
+          throw error51;
+        this.#connection = null;
+      }
+    }
+  }
   #connect() {
     if (this.#closed)
       return Promise.reject(new Error("Aqua Harness broker adapter is closed"));
     if (!this.#connection) {
-      const pending = BrokerConnection.connect(this.#descriptorPath, this.harnessId).then((connection) => {
+      const pending = this.#establish().then((connection) => {
         connection.onClose(() => {
           if (this.#connection === pending)
             this.#connection = null;
@@ -25327,18 +25522,43 @@ var BrokeredHarnessAdapter = class {
     }
     return this.#connection;
   }
+  async #establish() {
+    try {
+      return await BrokerConnection.connect(this.#descriptorPath, this.harnessId);
+    } catch (error51) {
+      if (!(error51 instanceof BrokerNotRunningError) || !this.#startBroker)
+        throw error51;
+    }
+    if (this.#isInstalled && !this.#isInstalled()) {
+      throw new HarnessNotInstalledError(`${this.harnessId} is not installed on this Mac`);
+    }
+    const deadline = Date.now() + this.#startTimeoutMs;
+    for (; ; ) {
+      await this.#startBroker();
+      try {
+        return await BrokerConnection.connect(this.#descriptorPath, this.harnessId);
+      } catch (error51) {
+        if (!(error51 instanceof BrokerNotRunningError) || Date.now() >= deadline)
+          throw error51;
+      }
+      await new Promise((resolve) => setTimeout(resolve, BROKER_START_POLL_MS));
+    }
+  }
 };
 
 // dist/plugin.js
 function createHarnessAdapter(context) {
-  if (context.platform === "darwin" && context.managedRemoteHost)
+  if (context.platform === "darwin" && context.managedRemoteHost) {
+    const environment2 = { ...context.environment };
     return new BrokeredHarnessAdapter({
       harnessId: "codebuddy",
       forwardDelegationEnvironment: true,
       commandCatalog: CODEBUDDY_COMMAND_CATALOG,
       liveCommandCatalog: true,
-      environment: { ...context.environment }
+      environment: environment2,
+      isInstalled: () => resolveHarnessExecutable(codeBuddyDiscoverySpec, { environment: environment2 }) !== void 0
     });
+  }
   const environment = { ...context.environment };
   return Object.assign(new CodeBuddyAdapter({ environment }), {
     installation: createCodeBuddyInstallation(environment),