@codexhost/cli-darwin-x64 0.10.1 → 0.11.0

package/app/plugins/cursor-cli/plugin.mjs

@@ -3229,8 +3229,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path9) {
-      let input = path9;
+    function removeDotSegments(path12) {
+      let input = path12;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3482,8 +3482,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path9, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path9 && path9 !== "/" ? path9 : void 0;
+        const [path12, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path12 && path12 !== "/" ? path12 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -13460,10 +13460,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj2, path9) {
-  if (!path9)
+function getElementAtPath(obj2, path12) {
+  if (!path12)
     return obj2;
-  return path9.reduce((acc, key) => acc?.[key], obj2);
+  return path12.reduce((acc, key) => acc?.[key], obj2);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -13872,11 +13872,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path12, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path12);
     return iss;
   });
 }
@@ -14023,16 +14023,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path9 = []) => {
+  const processError = (error52, path12 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path12, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -14059,17 +14059,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path9 = []) => {
+  const processError = (error52, path12 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path12, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -14101,8 +14101,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path9) {
+  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path12) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -26794,13 +26794,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path9 = ref.slice(1).split("/").filter(Boolean);
-  if (path9.length === 0) {
+  const path12 = ref.slice(1).split("/").filter(Boolean);
+  if (path12.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path9[0] === defsKey) {
-    const key = path9[1];
+  if (path12[0] === defsKey) {
+    const key = path12[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -27263,6 +27263,55 @@ var credentialImportsParamsSchema = external_exports.object({
   request: credentialImportsRequestSchema
 }).strict();
 
+// ../../shared-contracts/dist/harness-display-settings.js
+var harnessDisplayEntriesSchema = external_exports.array(external_exports.strictObject({
+  agent: external_exports.string().min(1).max(128),
+  section: external_exports.enum(["main", "more", "auto"])
+})).max(256).refine((entries) => new Set(entries.map((entry) => entry.agent)).size === entries.length, "Duplicate Harness IDs");
+var harnessDisplaySettingsSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema.nullable()
+});
+var harnessDisplayGetSchema = external_exports.strictObject({});
+var harnessDisplaySetSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema,
+  /** Import legacy Desktop preferences only if no shared settings exist yet. */
+  initializeOnly: external_exports.boolean().optional()
+});
+
+// ../../shared-contracts/dist/console.js
+var consoleAnnouncementSchema = external_exports.strictObject({
+  title: external_exports.string().trim().min(1).max(200),
+  type: external_exports.enum(["info", "warning", "danger"]),
+  body: external_exports.string().trim().min(1).max(16 * 1024)
+});
+var consoleOpenParamsSchema = external_exports.strictObject({});
+var consoleOpenResultSchema = external_exports.strictObject({
+  /** The console address. */
+  url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
+});
+var CONSOLE_HOST_METHODS = Object.freeze([
+  "codexhost/harness/plugins/list",
+  "codexhost/harness/display-settings/get",
+  "codexhost/harness/display-settings/set",
+  "codexhost/harness/inspect",
+  "codexhost/harness/launch-settings/get",
+  "codexhost/harness/launch-settings/set",
+  "codexhost/harness/web-ui/open",
+  "codexhost/harness/accounts/sources",
+  "codexhost/harness/accounts/list",
+  "codexhost/harness/accounts/inspect",
+  "codexhost/harness/credential-imports",
+  "codexhost/harness/session-import/sources",
+  "codexhost/harness/session-import/list",
+  "codexhost/harness/session-import/import",
+  "codexhost/account/list",
+  "codexhost/account/refresh",
+  "codexhost/account/usage/inspect",
+  "codexhost/update/check",
+  "codexhost/update/start",
+  "codexhost/update/status"
+]);
+
 // ../../shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
@@ -27316,6 +27365,12 @@ 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,
+  turnId: hostTurnIdSchema
+});
+
 // ../../shared-contracts/dist/thread-usage.js
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
@@ -27376,6 +27431,10 @@ var threadUsageSnapshotSchema = external_exports.object({
 var usagePercentSchema = external_exports.number().finite().min(0).max(100);
 var accountCreditsProductUsageSchema = external_exports.object({
   product: external_exports.string().min(1),
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   usagePercent: usagePercentSchema,
   resetsAt: external_exports.string().min(1).optional()
 }).strict();
@@ -27385,6 +27444,10 @@ var accountResetCreditsSchema = external_exports.object({
   expiresAt: external_exports.array(external_exports.string().min(1)).min(1).max(32).optional()
 }).strict();
 var accountCreditsSnapshotSchema = external_exports.object({
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   /** Native label when the primary limit is scoped to a model or product group. */
   label: external_exports.string().min(1).optional(),
   usedPercent: usagePercentSchema,
@@ -27404,12 +27467,27 @@ var threadUsageInspectionSchema = external_exports.object({
 }).strict();
 
 // ../../shared-contracts/dist/harness-accounts.js
-var harnessAccountSnapshotSchema = external_exports.object({
+var accountBalanceSnapshotSchema = external_exports.object({
+  amount: external_exports.number().finite().nonnegative(),
+  /** ISO 4217 code as reported by the Provider, for example `CNY`. */
+  currency: external_exports.string().trim().min(1).max(8),
+  /** Native label when the Harness exposes several Billing Sources. */
+  label: external_exports.string().trim().min(1).max(128).optional()
+}).strict();
+var harnessAccountSnapshotObject = external_exports.object({
   email: external_exports.string().trim().min(1).max(320).optional(),
   label: external_exports.string().trim().min(1).max(256).optional(),
   plan: external_exports.string().trim().min(1).max(128).optional(),
-  credits: accountCreditsSnapshotSchema
+  credits: accountCreditsSnapshotSchema.optional(),
+  balance: accountBalanceSnapshotSchema.optional()
 }).strict();
+function requireReportedQuota(schema) {
+  return schema.refine((value) => {
+    const reported = value;
+    return reported.credits !== void 0 || reported.balance !== void 0;
+  }, { message: "Account must report either credits or a balance" });
+}
+var harnessAccountSnapshotSchema = requireReportedQuota(harnessAccountSnapshotObject);
 var harnessAccountIdentityShape = {
   harnessId: harnessIdSchema,
   harnessName: external_exports.string().trim().min(1).max(128)
@@ -27420,11 +27498,13 @@ var harnessAccountSourceListResultSchema = external_exports.object({ sources: ex
 var harnessAccountInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema, refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountInspectResultSchema = external_exports.object({
   ...harnessAccountIdentityShape,
-  account: harnessAccountSnapshotSchema.nullable()
+  account: harnessAccountSnapshotSchema.nullable(),
+  /** Every Billing Source from one Harness; `account` remains the first for older clients. */
+  accounts: external_exports.array(harnessAccountSnapshotSchema).max(8).optional()
 }).strict();
 var harnessAccountListParamsSchema = external_exports.object({ refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountListResultSchema = external_exports.object({
-  accounts: external_exports.array(harnessAccountSnapshotSchema.extend(harnessAccountIdentityShape)).max(128)
+  accounts: external_exports.array(requireReportedQuota(harnessAccountSnapshotObject.extend(harnessAccountIdentityShape))).max(128)
 }).strict();
 
 // ../../shared-contracts/dist/json-value.js
@@ -27562,6 +27642,8 @@ var harnessModelSchema = external_exports.object({
   ref: harnessModelRefSchema,
   label: nonBlankTextSchema2.max(HARNESS_MODEL_LABEL_MAX_LENGTH),
   resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
+  /** Optional opaque selection for this same Model with priority processing enabled. */
+  fastModel: harnessModelRefSchema.optional(),
   supportedThinkingOptionIds: external_exports.array(harnessThinkingOptionIdSchema).optional()
 }).strict();
 var harnessThinkingOptionsSchema = external_exports.array(harnessThinkingOptionSchema).superRefine((options, context) => {
@@ -27594,6 +27676,16 @@ var harnessModelCatalogSchema = external_exports.object({
       });
     }
     refs.add(model.ref.id);
+    if (model.fastModel) {
+      if (refs.has(model.fastModel.id) || catalog.models.some((entry) => entry.ref.id === model.fastModel?.id)) {
+        context.addIssue({
+          code: "custom",
+          message: "Fast Model refs must be distinct and unique",
+          path: ["models", index, "fastModel"]
+        });
+      }
+      refs.add(model.fastModel.id);
+    }
     const supportedThinkingIds = /* @__PURE__ */ new Set();
     for (const [optionIndex, optionId] of (model.supportedThinkingOptionIds ?? []).entries()) {
       if (supportedThinkingIds.has(optionId)) {
@@ -27713,11 +27805,13 @@ var threadThinkingSelectParamsSchema = external_exports.object({
   thinkingOptionId: harnessThinkingOptionIdSchema
 }).strict();
 var threadInspectionParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema
+  threadId: hostThreadIdSchema,
+  includeReferenceCapability: external_exports.boolean().optional()
 }).strict();
 var codexThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("codex"),
-  locked: external_exports.literal(true)
+  locked: external_exports.literal(true),
+  supportsThreadReferences: external_exports.literal(true).optional()
 }).strict();
 var externalThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("external"),
@@ -27843,6 +27937,19 @@ var harnessLaunchSettingsSchema = external_exports.object({
   restartRequired: external_exports.boolean()
 }).strict();
 
+// ../../shared-contracts/dist/harness-installation.js
+var harnessInstallationParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema,
+  action: external_exports.enum(["check", "update"])
+}).strict();
+var harnessInstallationStateSchema = external_exports.object({
+  currentVersion: external_exports.string().min(1).max(128),
+  latestVersion: external_exports.string().min(1).max(128),
+  updateAvailable: external_exports.boolean(),
+  canUpdate: external_exports.boolean(),
+  message: external_exports.string().max(2048).optional()
+}).strict();
+
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
 var nonBlankTextSchema3 = external_exports.string().trim().min(1);
@@ -28480,9 +28587,778 @@ function cursorCommandPrompt(command, catalog) {
   return { ok: true, value: `${descriptor.invocation}${text2 ? ` ${text2}` : ""}` };
 }
 
+// ../../harness-discovery/dist/environment.js
+import fs from "node:fs";
+import path from "node:path";
+function targetPath(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+function environmentValue(environment, name) {
+  const lowered = name.toLowerCase();
+  for (const [key, value] of Object.entries(environment)) {
+    if (key.toLowerCase() === lowered)
+      return value;
+  }
+  return void 0;
+}
+function pathDelimiter(platform) {
+  return platform === "win32" ? ";" : ":";
+}
+function pathDirectories(environment, platform) {
+  return (environmentValue(environment, "PATH") ?? "").split(pathDelimiter(platform)).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter(Boolean);
+}
+function executableExtensions(command, platform, environment) {
+  if (platform !== "win32")
+    return [""];
+  if (targetPath(platform).extname(command) !== "")
+    return [""];
+  return (environmentValue(environment, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.trim()).filter(Boolean);
+}
+function isExecutableFile(filePath, platform) {
+  try {
+    fs.accessSync(filePath, platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function subdirectoryNames(directory) {
+  try {
+    return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function newestFirst(names) {
+  return [...names].sort((left, right) => right.localeCompare(left, void 0, { numeric: true }));
+}
+
+// ../../harness-discovery/dist/invocation.js
+import path2 from "node:path";
+function commandInvocation(command, arguments_, environment, platform = process.platform) {
+  const extension = path2.win32.extname(command).toLowerCase();
+  if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
+    return { command, arguments: [...arguments_], windowsVerbatimArguments: false };
+  }
+  const quote2 = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
+  const commandLine = [command, ...arguments_].map(quote2).join(" ");
+  return {
+    command: environmentValue(environment, "ComSpec") ?? "cmd.exe",
+    arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
+    windowsVerbatimArguments: true
+  };
+}
+
+// ../../harness-discovery/dist/node-runtime.js
+import path3 from "node:path";
+function withNodeRuntimeOnPath(environment, runtimeExecutable = process.execPath, platform = process.platform) {
+  const pathKey = Object.keys(environment).find((name) => name.toLowerCase() === "path") ?? "PATH";
+  const delimiter = platform === "win32" ? ";" : ":";
+  const runtimeDirectory = path3.dirname(runtimeExecutable);
+  const directories = (environment[pathKey] ?? "").split(delimiter).filter(Boolean);
+  const equal = platform === "win32" ? (value) => value.toLowerCase() : (value) => value;
+  if (!directories.some((directory) => equal(directory) === equal(runtimeDirectory))) {
+    directories.push(runtimeDirectory);
+  }
+  return { ...environment, [pathKey]: directories.join(delimiter) };
+}
+
+// ../../harness-discovery/dist/resolve.js
+import os from "node:os";
+
+// ../../harness-discovery/dist/version-managers.js
+function versionManagerBinaryDirectories(context) {
+  const { platform, environment, home } = context;
+  const list = context.subdirectories ?? subdirectoryNames;
+  const pathFlavor = targetPath(platform);
+  const value = (name) => environmentValue(environment, name);
+  const directories = [];
+  const versioned = (root, ...tail) => {
+    for (const version2 of newestFirst(list(root))) {
+      directories.push(pathFlavor.join(root, version2, ...tail));
+    }
+  };
+  if (platform === "win32") {
+    const appData = value("APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming");
+    const localAppData = value("LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local");
+    versioned(pathFlavor.join(appData, "nvm"));
+    versioned(value("FNM_DIR") ?? pathFlavor.join(appData, "fnm", "node-versions"), "installation");
+    directories.push(pathFlavor.join(localAppData, "Volta", "bin"));
+    directories.push(pathFlavor.join(home, ".bun", "bin"));
+    const pnpmHome2 = value("PNPM_HOME");
+    if (pnpmHome2)
+      directories.push(pnpmHome2);
+    directories.push(pathFlavor.join(localAppData, "pnpm"));
+    return directories;
+  }
+  versioned(pathFlavor.join(value("NVM_DIR") ?? pathFlavor.join(home, ".nvm"), "versions", "node"), "bin");
+  const fnmRoots = [
+    value("FNM_DIR"),
+    pathFlavor.join(home, ".local", "share", "fnm"),
+    pathFlavor.join(home, "Library", "Application Support", "fnm")
+  ].filter((root) => root !== void 0);
+  for (const root of fnmRoots) {
+    versioned(pathFlavor.join(root, "node-versions"), "installation", "bin");
+  }
+  const voltaHome = value("VOLTA_HOME") ?? pathFlavor.join(home, ".volta");
+  versioned(pathFlavor.join(voltaHome, "tools", "image", "node"), "bin");
+  directories.push(pathFlavor.join(voltaHome, "bin"));
+  const asdfHome = value("ASDF_DATA_DIR") ?? pathFlavor.join(home, ".asdf");
+  versioned(pathFlavor.join(asdfHome, "installs", "nodejs"), "bin");
+  directories.push(pathFlavor.join(asdfHome, "shims"));
+  const nodenvHome = value("NODENV_ROOT") ?? pathFlavor.join(home, ".nodenv");
+  versioned(pathFlavor.join(nodenvHome, "versions"), "bin");
+  directories.push(pathFlavor.join(nodenvHome, "shims"));
+  versioned(pathFlavor.join(value("N_PREFIX") ?? "/usr/local", "n", "versions", "node"), "bin");
+  directories.push(pathFlavor.join(home, ".bun", "bin"));
+  const pnpmHome = value("PNPM_HOME");
+  if (pnpmHome)
+    directories.push(pnpmHome);
+  directories.push(pathFlavor.join(home, "Library", "pnpm"));
+  directories.push(pathFlavor.join(home, ".local", "share", "pnpm"));
+  for (const prefix of ["/opt/homebrew/opt", "/usr/local/opt"]) {
+    for (const formula of newestFirst(list(prefix).filter((name) => name.startsWith("node@")))) {
+      directories.push(pathFlavor.join(prefix, formula, "bin"));
+    }
+  }
+  return directories;
+}
+
+// ../../harness-discovery/dist/resolve.js
+var VERSION_MANAGER_ROOTS = "<version-managers>";
+function installRootExtensions(platform) {
+  return platform === "win32" ? [".exe", ".cmd"] : [""];
+}
+function resolveHomeDirectory(input) {
+  return input.homeDirectory ?? environmentValue(input.environment, "HOME") ?? environmentValue(input.environment, "USERPROFILE") ?? os.homedir();
+}
+function templateVariables(environment, platform, home) {
+  const pathFlavor = targetPath(platform);
+  return {
+    HOME: home,
+    USERPROFILE: home,
+    APPDATA: environmentValue(environment, "APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming"),
+    LOCALAPPDATA: environmentValue(environment, "LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local")
+  };
+}
+function joinTemplate(platform, value) {
+  const pathFlavor = targetPath(platform);
+  const segments = value.split("/");
+  const head = segments[0] ?? "";
+  const tail = segments.slice(1);
+  if (head === "")
+    return pathFlavor.join(pathFlavor.sep, ...tail);
+  return tail.length === 0 ? head : pathFlavor.join(head, ...tail);
+}
+function expandInstallRoot(template, environment, platform, home) {
+  const variables = templateVariables(environment, platform, home);
+  let unresolved = false;
+  const substituted = template.replace(/^~(?=\/|$)/u, home).replace(/\$\{(\w+)\}/gu, (_match, name) => {
+    const value = variables[name] ?? environmentValue(environment, name);
+    if (value === void 0 || value === "") {
+      unresolved = true;
+      return "";
+    }
+    return value;
+  });
+  return unresolved ? void 0 : joinTemplate(platform, substituted);
+}
+function installRootDirectories(spec, input, dependencies, platform, home) {
+  const templates = (platform === "win32" ? spec.installRoots?.windows : spec.installRoots?.posix) ?? [];
+  const directories = [];
+  for (const template of templates) {
+    if (template === VERSION_MANAGER_ROOTS) {
+      directories.push(...versionManagerBinaryDirectories({
+        platform,
+        environment: input.environment,
+        home,
+        ...dependencies.subdirectories ? { subdirectories: dependencies.subdirectories } : {}
+      }));
+      continue;
+    }
+    const directory = expandInstallRoot(template, input.environment, platform, home);
+    if (directory !== void 0)
+      directories.push(directory);
+  }
+  return directories;
+}
+function harnessCandidates(spec, input, dependencies = {}) {
+  const platform = input.platform ?? process.platform;
+  const pathFlavor = targetPath(platform);
+  const configured = input.command ?? (spec.commandEnvironmentVariable ? environmentValue(input.environment, spec.commandEnvironmentVariable) : void 0);
+  const command = configured ?? spec.command;
+  if (pathFlavor.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
+    return [{ candidate: command, source: "configured" }];
+  }
+  const candidates = [];
+  const extensions = executableExtensions(command, platform, input.environment);
+  for (const directory of pathDirectories(input.environment, platform)) {
+    for (const extension of extensions) {
+      candidates.push({
+        candidate: pathFlavor.join(directory, command + extension),
+        source: "path"
+      });
+    }
+  }
+  if (configured !== void 0)
+    return candidates;
+  const home = resolveHomeDirectory(input);
+  for (const directory of installRootDirectories(spec, input, dependencies, platform, home)) {
+    for (const extension of installRootExtensions(platform)) {
+      candidates.push({
+        candidate: pathFlavor.join(directory, spec.command + extension),
+        source: "install-root"
+      });
+    }
+  }
+  return candidates;
+}
+function resolveHarnessExecutable(spec, input, dependencies = {}) {
+  const platform = input.platform ?? process.platform;
+  const isExecutable = dependencies.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
+  const runnable = spec.runnableCandidate ?? ((candidate) => candidate);
+  const context = { platform, isExecutable };
+  for (const { candidate, source } of harnessCandidates(spec, input, dependencies)) {
+    const executable = runnable(candidate, context);
+    if (executable !== void 0 && isExecutable(executable))
+      return { executable, source };
+  }
+  return void 0;
+}
+
+// ../../harness-discovery/dist/installation.js
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+function runInstallationCommand(command, args, environment, timeout = 3e4) {
+  const env = withNodeRuntimeOnPath(environment);
+  const invocation = /\.[cm]?js$/i.test(command) ? commandInvocation(process.execPath, [command, ...args], env) : commandInvocation(command, args, env);
+  return new Promise((resolve, reject) => {
+    const child = execFile(invocation.command, invocation.arguments, {
+      env,
+      cwd: env.HOME ?? env.USERPROFILE ?? homedir(),
+      encoding: "utf8",
+      timeout,
+      killSignal: "SIGKILL",
+      maxBuffer: 1024 * 1024,
+      windowsHide: true,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
+    }, (error51, stdout, stderr) => {
+      if (error51)
+        reject(new Error(error51.killed ? "Harness command timed out" : "Harness command failed; check the native installation and retry"));
+      else
+        resolve((stdout || stderr).trim());
+    });
+    child.stdin?.end();
+  });
+}
+function installationVersion(value) {
+  if (typeof value !== "string" || !/^v?\d+(?:\.\d+){1,3}(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(value.trim()))
+    throw new Error("Harness returned an invalid version");
+  return value.trim().replace(/^v/, "");
+}
+function createInstallationManager(options) {
+  let checking;
+  let updating;
+  const check2 = () => checking ??= options.check().finally(() => {
+    checking = void 0;
+  });
+  return (action) => {
+    if (updating)
+      return updating;
+    if (action === "check")
+      return check2();
+    updating = (async () => {
+      const before = await check2();
+      if (!before.updateAvailable)
+        return before;
+      if (!before.canUpdate)
+        throw new Error(before.message ?? "This installation cannot be updated automatically");
+      await options.update(before);
+      const after = await check2();
+      if (after.currentVersion === before.currentVersion)
+        throw new Error("The Harness version did not change; check the native updater and retry");
+      return after;
+    })().finally(() => {
+      updating = void 0;
+    });
+    return updating;
+  };
+}
+
+// dist/command.js
+import { existsSync, readdirSync } from "node:fs";
+import path4 from "node:path";
+var PINNED_VERSION_AGENT = /[/\\]cursor-agent[/\\]versions[/\\][^/\\]+[/\\]cursor-agent(?:\.exe)?$/iu;
+function cursorDiscoverySpec(skipPinnedVersions) {
+  return {
+    id: "cursor-cli",
+    command: "cursor-agent",
+    commandEnvironmentVariable: "CODEXHOST_CURSOR_COMMAND",
+    installRoots: {
+      posix: ["~/.local/bin", "/usr/local/bin", "/opt/homebrew/bin"],
+      windows: ["${LOCALAPPDATA}/cursor-agent"]
+    },
+    ...skipPinnedVersions ? {
+      runnableCandidate: (candidate) => PINNED_VERSION_AGENT.test(candidate) ? void 0 : candidate
+    } : {}
+  };
+}
+function resolveCursorExecutable(environment, command) {
+  const input = { environment, ...command ? { command } : {} };
+  const pinned = resolveHarnessExecutable(cursorDiscoverySpec(false), input);
+  if (!pinned)
+    throw new Error("Cursor CLI is not installed; install cursor-agent or set CODEXHOST_CURSOR_COMMAND");
+  const explicit = command?.trim() || environment.CODEXHOST_CURSOR_COMMAND?.trim();
+  if (explicit || !PINNED_VERSION_AGENT.test(pinned.executable))
+    return pinned;
+  return resolveHarnessExecutable(cursorDiscoverySpec(true), input) ?? pinned;
+}
+function cursorInvocation(environment, command, args) {
+  const resolution = resolveCursorExecutable(environment, command);
+  if (process.platform === "win32" && /\.(cmd|ps1)$/iu.test(resolution.executable)) {
+    const root = path4.dirname(resolution.executable);
+    const versions = path4.join(root, "versions");
+    if (existsSync(versions)) {
+      const version2 = readdirSync(versions).filter((name) => /^\d{4}\.\d{2}\.\d{2}-(?:\d{2}-\d{2}-\d{2}-)?[a-f0-9]+$/u.test(name)).sort().reverse().find((name) => existsSync(path4.join(versions, name, "node.exe")) && existsSync(path4.join(versions, name, "index.js")));
+      if (version2)
+        return {
+          command: path4.join(versions, version2, "node.exe"),
+          arguments: [path4.join(versions, version2, "index.js"), ...args],
+          windowsVerbatimArguments: false
+        };
+    }
+    throw new Error("Cursor Windows launcher has no supported native bundle; configure a native executable");
+  }
+  return commandInvocation(resolution.executable, args, environment);
+}
+
+// dist/installation.js
+function createCursorInstallation(environment) {
+  const run = (args, timeout) => {
+    const invocation = cursorInvocation(environment, void 0, args);
+    return runInstallationCommand(invocation.command, invocation.arguments, environment, timeout);
+  };
+  return createInstallationManager({
+    async check() {
+      const state = JSON.parse(await run(["about", "--format", "json"]));
+      if (state.latestStatus !== "up_to_date" && state.latestStatus !== "update_available")
+        throw new Error("Cursor update checks are disabled or unavailable");
+      return {
+        currentVersion: installationVersion(state.cliVersion),
+        latestVersion: installationVersion(state.latestVersion),
+        updateAvailable: state.latestStatus === "update_available",
+        canUpdate: true
+      };
+    },
+    async update() {
+      await run(["update"], 3e5);
+    }
+  });
+}
+
 // dist/adapter.js
+import path10 from "node:path";
+
+// dist/account-usage.js
+import { execFile as execFile2 } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path5 from "node:path";
+import { promisify } from "node:util";
+var execute = promisify(execFile2);
+var ENDPOINT = "https://api2.cursor.sh/aiserver.v1.DashboardService/";
+var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+var percent = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.min(100, value) : void 0;
+function projectCursorAccountUsage(usage, identity, plan) {
+  const data = record2(usage);
+  const buckets = record2(data.planUsage);
+  const usedPercent = percent(buckets.autoPercentUsed);
+  if (usedPercent === void 0)
+    return null;
+  const end = typeof data.billingCycleEnd === "string" || typeof data.billingCycleEnd === "number" ? Number(data.billingCycleEnd) : NaN;
+  const date5 = new Date(end);
+  const resetsAt = Number.isFinite(date5.getTime()) && end > 0 ? date5.toISOString() : void 0;
+  const apiPercent = percent(buckets.apiPercentUsed);
+  const email3 = record2(identity).email;
+  const planName = record2(record2(plan).planInfo).planName;
+  const result = harnessAccountSnapshotSchema.safeParse({
+    ...typeof email3 === "string" && email3.trim() ? { email: email3 } : {},
+    ...typeof planName === "string" && planName.trim() ? { plan: planName } : {},
+    credits: {
+      usedPercent,
+      label: "Auto · monthly",
+      periodType: "monthly",
+      ...resetsAt ? { resetsAt } : {},
+      ...apiPercent === void 0 ? {} : {
+        productUsage: [
+          {
+            product: "API · monthly",
+            usagePercent: apiPercent,
+            ...resetsAt ? { resetsAt } : {}
+          }
+        ]
+      }
+    }
+  });
+  return result.success ? result.data : null;
+}
+async function accessToken(environment) {
+  if (environment.CURSOR_API_KEY?.trim() || environment.AGENT_CLI_CREDENTIAL_STORE === "memory")
+    return void 0;
+  if (process.platform === "darwin" && environment.AGENT_CLI_CREDENTIAL_STORE !== "file") {
+    const result = await execute("/usr/bin/security", ["find-generic-password", "-s", "cursor-access-token", "-a", "cursor-user", "-w"], { timeout: 5e3, maxBuffer: 64 * 1024 });
+    return result.stdout.trim() || void 0;
+  }
+  const home = environment.HOME ?? environment.USERPROFILE ?? homedir2();
+  const authPath = process.platform === "darwin" ? path5.join(home, ".cursor", "auth.json") : process.platform === "win32" ? path5.join(environment.APPDATA ?? path5.join(home, "AppData", "Roaming"), "Cursor", "auth.json") : path5.join(environment.XDG_CONFIG_HOME ?? path5.join(home, ".config"), "cursor", "auth.json");
+  const auth = record2(JSON.parse(await readFile(authPath, "utf8")));
+  return typeof auth.accessToken === "string" && auth.accessToken.trim() ? auth.accessToken : void 0;
+}
+async function fetchCursorAccount(input = {}) {
+  try {
+    const environment = input.environment ?? process.env;
+    if (environment.CURSOR_API_KEY?.trim() || environment.AGENT_CLI_CREDENTIAL_STORE === "memory")
+      return null;
+    const token = await (input.readAccessToken ? input.readAccessToken() : accessToken(environment));
+    if (!token)
+      return null;
+    const signal = input.signal ? AbortSignal.any([input.signal, AbortSignal.timeout(1e4)]) : AbortSignal.timeout(1e4);
+    const request = async (method) => {
+      const response = await (input.fetch ?? fetch)(ENDPOINT + method, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          "Connect-Protocol-Version": "1"
+        },
+        body: "{}",
+        signal
+      });
+      return response.ok ? response.json() : null;
+    };
+    const [usage, identity, plan] = await Promise.all([
+      request("GetCurrentPeriodUsage"),
+      request("GetMe").catch(() => null),
+      request("GetPlanInfo").catch(() => null)
+    ]);
+    return projectCursorAccountUsage(usage, identity, plan);
+  } catch {
+    return null;
+  }
+}
+
+// dist/session-import.js
+import { lstat, opendir, readFile as readFile2, realpath, stat } from "node:fs/promises";
 import path7 from "node:path";
 
+// dist/native-history.js
+import { existsSync as existsSync2, readFileSync, realpathSync } from "node:fs";
+import os2 from "node:os";
+import path6 from "node:path";
+import { DatabaseSync } from "node:sqlite";
+function cursorConfigDirectory(environment) {
+  const home = environment.HOME ?? environment.USERPROFILE ?? os2.homedir();
+  return environment.CURSOR_CONFIG_DIR?.trim() ? path6.resolve(environment.CURSOR_CONFIG_DIR) : environment.XDG_CONFIG_HOME?.trim() ? path6.resolve(environment.XDG_CONFIG_HOME, "cursor") : path6.join(home, ".cursor");
+}
+function cursorSessionDirectory(sessionId, environment) {
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(sessionId))
+    throw new Error("Unsupported Cursor native session ID");
+  return path6.join(cursorConfigDirectory(environment), "acp-sessions", sessionId);
+}
+function cursorSameWorkspace(left, right) {
+  return path6.resolve(left) === path6.resolve(right) || existsSync2(left) && existsSync2(right) && realpathSync(left) === realpathSync(right);
+}
+function protobufBytes(data) {
+  if (data.length > 32 * 1024 * 1024)
+    throw new Error("Cursor native record is too large");
+  let offset = 0;
+  const varint = () => {
+    let result = 0;
+    for (let shift = 0; shift < 70; shift += 7) {
+      const value = data[offset++];
+      if (value === void 0)
+        throw new Error("Truncated Cursor native record");
+      result += (value & 127) * 2 ** shift;
+      if (!(value & 128))
+        return result;
+    }
+    throw new Error("Invalid Cursor native varint");
+  };
+  const fields = /* @__PURE__ */ new Map();
+  while (offset < data.length) {
+    const tag = varint();
+    const field = Math.floor(tag / 8), wire = tag % 8;
+    if (!Number.isSafeInteger(tag) || field === 0)
+      throw new Error("Invalid Cursor native field");
+    if (wire === 0) {
+      varint();
+      continue;
+    }
+    const length = wire === 2 ? varint() : wire === 1 ? 8 : wire === 5 ? 4 : -1;
+    if (!Number.isSafeInteger(length) || length < 0 || offset + length > data.length)
+      throw new Error("Unsupported Cursor native record");
+    if (wire === 2) {
+      const values = fields.get(field) ?? [];
+      values.push(Buffer.from(data.subarray(offset, offset + length)));
+      fields.set(field, values);
+    }
+    offset += length;
+  }
+  return fields;
+}
+function one(fields, field) {
+  const values = fields.get(field);
+  if (values?.length !== 1 || !values[0])
+    throw new Error("Cursor native history identity is missing or ambiguous");
+  return values[0];
+}
+function readCursorNativeHistory(sessionId, cwd, environment, allowMissing = false) {
+  const directory = cursorSessionDirectory(sessionId, environment);
+  const filename = path6.join(directory, "store.db");
+  if (allowMissing && !existsSync2(filename))
+    return { revision: void 0, turns: [] };
+  const info = JSON.parse(readFileSync(path6.join(directory, "meta.json"), "utf8"));
+  if (!info || typeof info !== "object" || !("cwd" in info) || typeof info.cwd !== "string" || !cursorSameWorkspace(info.cwd, cwd))
+    throw new Error("Cursor session workspace does not match");
+  const db = new DatabaseSync(filename, { readOnly: true });
+  try {
+    db.exec("BEGIN");
+    const row = db.prepare("SELECT value FROM meta WHERE key = ?").get("0");
+    if (!row && allowMissing)
+      return { revision: void 0, turns: [] };
+    if (typeof row?.value !== "string" || row.value.length > 1e6)
+      throw new Error("Unsupported Cursor native metadata");
+    const metadata = JSON.parse(Buffer.from(row.value, "hex").toString("utf8"));
+    if (metadata.agentId !== sessionId || typeof metadata.latestRootBlobId !== "string")
+      throw new Error("Cursor native session identity mismatch");
+    const get = (id) => {
+      if (!/^[0-9a-f]{64}$/u.test(id))
+        throw new Error("Invalid Cursor native blob reference");
+      const blob = db.prepare("SELECT data FROM blobs WHERE id = ?").get(id)?.data;
+      if (!(blob instanceof Uint8Array))
+        throw new Error("Cursor native history blob is missing");
+      return protobufBytes(blob);
+    };
+    const root = get(metadata.latestRootBlobId);
+    const result = [];
+    for (const ref of root.get(8) ?? []) {
+      if (ref.length !== 32)
+        throw new Error("Unsupported Cursor turn reference");
+      const container = get(ref.toString("hex"));
+      for (const record3 of container.get(1) ?? []) {
+        const turn = protobufBytes(record3);
+        const user = get(one(turn, 1).toString("hex"));
+        const id = one(user, 2).toString("utf8");
+        if (!/^[0-9a-f-]{36}$/iu.test(id) || result.some((existing) => existing.id === id))
+          throw new Error("Cursor native turn ID is invalid or duplicated");
+        const anchor = user.get(10)?.[0];
+        const rewindRoot = anchor?.length === 32 && db.prepare("SELECT 1 FROM blobs WHERE id = ?").get(anchor.toString("hex")) ? anchor.toString("hex") : void 0;
+        result.push({
+          id,
+          text: one(user, 1).toString("utf8"),
+          ...rewindRoot ? { rewindRoot } : {}
+        });
+      }
+    }
+    return { revision: metadata.latestRootBlobId, turns: result };
+  } finally {
+    db.close();
+  }
+}
+function readCursorNativeTurns(sessionId, cwd, environment, allowMissing = false) {
+  return readCursorNativeHistory(sessionId, cwd, environment, allowMissing).turns;
+}
+
+// dist/session-ref.js
+var cursorHarnessId = harnessIdSchema.parse("cursor-cli");
+var cursorSessionLocatorSchema = external_exports.strictObject({
+  executionPolicy: external_exports.enum(["default", "unattended-full-access"])
+});
+function cursorNativeSessionRef(nativeSessionId, executionPolicy) {
+  return nativeSessionRefSchema.parse({
+    harnessId: cursorHarnessId,
+    nativeSessionId,
+    locator: { executionPolicy },
+    formatVersion: 1
+  });
+}
+function cursorExecutionPolicy(ref) {
+  if (ref.harnessId !== cursorHarnessId || ref.formatVersion !== 1)
+    throw new Error("Invalid Cursor Native Session Ref");
+  if (ref.locator === void 0)
+    return "default";
+  const locator = cursorSessionLocatorSchema.safeParse(ref.locator);
+  if (!locator.success)
+    throw new Error("Invalid Cursor Native Session locator");
+  return locator.data.executionPolicy;
+}
+
+// dist/session-import.js
+var SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+var MAX_METADATA_BYTES = 1024 * 1024;
+var CursorSessionChangedError = class extends Error {
+};
+function errorCode(error51) {
+  return typeof error51 === "object" && error51 !== null && "code" in error51 && typeof error51.code === "string" ? error51.code : void 0;
+}
+async function optionalStat(file2) {
+  try {
+    return await lstat(file2);
+  } catch (error51) {
+    if (errorCode(error51) === "ENOENT")
+      return null;
+    throw error51;
+  }
+}
+function sameFile(left, right) {
+  return left === null || right === null ? left === right : left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+var CursorSessionImport = class {
+  #environment;
+  #abort = new AbortController();
+  #pending = /* @__PURE__ */ new Set();
+  constructor(environment) {
+    this.#environment = { ...environment };
+  }
+  listCandidates() {
+    return this.#read(async (signal) => {
+      const root = path7.join(cursorConfigDirectory(this.#environment), "acp-sessions");
+      const info = await optionalStat(root);
+      if (!info)
+        return [];
+      if (!info.isDirectory())
+        throw new Error("Cursor ACP store is not a directory");
+      const candidates = [];
+      const entries = await opendir(root);
+      for await (const entry of entries) {
+        signal.throwIfAborted();
+        if (!entry.isDirectory() || !SESSION_ID.test(entry.name))
+          continue;
+        try {
+          const candidate = await this.#candidate(entry.name, signal);
+          if (candidate)
+            candidates.push(candidate);
+        } catch (error51) {
+          if (!(error51 instanceof CursorSessionChangedError))
+            throw error51;
+        }
+      }
+      return candidates;
+    });
+  }
+  async resolveCandidate(nativeSessionId) {
+    if (!SESSION_ID.test(nativeSessionId))
+      return {
+        ok: false,
+        error: {
+          code: "invalidRequest",
+          message: "Invalid Cursor ACP Session ID",
+          retryable: false
+        }
+      };
+    const result = await this.#read((signal) => this.#candidate(nativeSessionId, signal));
+    if (!result.ok)
+      return result;
+    if (!result.value)
+      return {
+        ok: false,
+        error: {
+          code: "sessionNotFound",
+          message: "Cursor ACP Session is no longer importable",
+          retryable: false
+        }
+      };
+    return {
+      ok: true,
+      value: {
+        candidate: result.value,
+        // Native ACP stores do not attest to --force. Imported sessions must not
+        // acquire unattended privileges from UI defaults or a guessed locator.
+        nativeRef: cursorNativeSessionRef(nativeSessionId, "default")
+      }
+    };
+  }
+  async #candidate(id, signal) {
+    signal.throwIfAborted();
+    const root = path7.join(cursorConfigDirectory(this.#environment), "acp-sessions");
+    if (!(await optionalStat(root))?.isDirectory())
+      return null;
+    const directory = cursorSessionDirectory(id, this.#environment);
+    const files = [
+      directory,
+      path7.join(directory, "meta.json"),
+      path7.join(directory, "store.db"),
+      path7.join(directory, "store.db-wal")
+    ];
+    const before = await Promise.all(files.map(optionalStat));
+    const [folder, metadata, database, wal] = before;
+    if (!folder?.isDirectory() || !metadata?.isFile() || !database?.isFile() || wal && !wal.isFile() || metadata.size > MAX_METADATA_BYTES)
+      return null;
+    let cwd;
+    let title;
+    try {
+      const raw = JSON.parse(await readFile2(files[1], { encoding: "utf8", signal }));
+      if (!raw || typeof raw !== "object" || !("cwd" in raw) || typeof raw.cwd !== "string" || !path7.isAbsolute(raw.cwd) || raw.cwd.includes("\0"))
+        return null;
+      cwd = await realpath(raw.cwd);
+      if (!(await stat(cwd)).isDirectory())
+        return null;
+      signal.throwIfAborted();
+      const turns = readCursorNativeTurns(id, cwd, this.#environment);
+      if (!turns.length)
+        return null;
+      title = turns[0]?.text.replaceAll("\0", "").replace(/\s+/gu, " ").trim().slice(0, HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH) || null;
+    } catch (error51) {
+      signal.throwIfAborted();
+      if (["EACCES", "EPERM", "EIO", "EMFILE", "ENFILE"].includes(errorCode(error51) ?? ""))
+        throw error51;
+      return null;
+    }
+    signal.throwIfAborted();
+    const after = await Promise.all(files.map(optionalStat));
+    if (before.some((info, index) => !sameFile(info, after[index] ?? null)))
+      throw new CursorSessionChangedError("Cursor Session changed during discovery");
+    const parsed = harnessSessionImportCandidateSchema.safeParse({
+      nativeSessionId: id,
+      cwd,
+      title,
+      updatedAt: Math.floor(Math.max(database.mtimeMs, wal?.mtimeMs ?? 0)),
+      // A stable read does not establish that another Cursor process is idle.
+      running: null
+    });
+    return parsed.success ? parsed.data : null;
+  }
+  #read(operation) {
+    const signal = this.#abort.signal;
+    if (signal.aborted)
+      return Promise.resolve({
+        ok: false,
+        error: {
+          code: "invalidState",
+          message: "Cursor Session import is closed",
+          retryable: false
+        }
+      });
+    const request = operation(signal).then((value) => {
+      signal.throwIfAborted();
+      return { ok: true, value };
+    }).catch(() => ({
+      ok: false,
+      error: {
+        code: signal.aborted ? "invalidState" : "unavailable",
+        message: signal.aborted ? "Cursor Session import is closed" : "Cursor ACP sessions could not be read; close native clients, check storage access and retry",
+        retryable: !signal.aborted
+      }
+    })).finally(() => this.#pending.delete(request));
+    this.#pending.add(request);
+    return request;
+  }
+  async close() {
+    this.#abort.abort();
+    await Promise.allSettled(this.#pending);
+  }
+};
+
 // dist/thinking.js
 var choices = (option) => option.type === "select" ? option.options.flatMap((entry) => "value" in entry ? [entry] : entry.options) : [];
 function cursorThinking(options) {
@@ -28523,9 +29399,9 @@ function cursorThinkingState(info) {
 }
 
 // dist/fork-support.js
-import { existsSync } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 function cursorForkAvailable() {
-  return (process.platform === "darwin" || process.platform === "linux") && existsSync("/usr/bin/script");
+  return (process.platform === "darwin" || process.platform === "linux") && existsSync3("/usr/bin/script");
 }
 function cursorCheckpoint(sessionId, turnId) {
   return nativeCheckpointRefSchema.parse({
@@ -32826,10 +33702,10 @@ var ClientSideConnection = class {
 };
 
 // dist/delegation-bridge.js
-import { execFile } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
-import path from "node:path";
+import path8 from "node:path";
 
 // ../../../node_modules/zod/v3/helpers/util.js
 var util;
@@ -33190,8 +34066,8 @@ function getErrorMap2() {
 
 // ../../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path9, errorMaps, issueData } = params;
-  const fullPath = [...path9, ...issueData.path || []];
+  const { data, path: path12, errorMaps, issueData } = params;
+  const fullPath = [...path12, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -33306,11 +34182,11 @@ var errorUtil;
 
 // ../../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path9, key) {
+  constructor(parent, value, path12, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path9;
+    this._path = path12;
     this._key = key;
   }
   get path() {
@@ -36837,11 +37713,11 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
-function getDotPath(path9) {
-  if (path9.length === 0) {
+function getDotPath(path12) {
+  if (path12.length === 0) {
     return "object root";
   }
-  return path9.reduce((acc, seg, index) => {
+  return path12.reduce((acc, seg, index) => {
     if (index === 0) {
       return String(seg);
     }
@@ -44210,7 +45086,7 @@ async function createCursorDelegationBridge(cwd, environment, commandTimeoutMs =
   const runtimeToken = environment.CODEXHOST_RUNTIME_TOKEN;
   if (!cli || !environment.CODEXHOST_RUNTIME_ENDPOINT || !runtimeToken || !environment.CODEXHOST_THREAD_ID)
     return void 0;
-  if (!path.isAbsolute(cli))
+  if (!path8.isAbsolute(cli))
     throw new Error("Cursor delegation requires an absolute Host CLI path");
   const token = randomBytes(32).toString("base64url");
   const children = /* @__PURE__ */ new Set();
@@ -44225,7 +45101,7 @@ async function createCursorDelegationBridge(cwd, environment, commandTimeoutMs =
       });
       return;
     }
-    const child = execFile(cli, [...args, "--format", "compact"], {
+    const child = execFile3(cli, [...args, "--format", "compact"], {
       cwd,
       env: environment,
       windowsHide: true,
@@ -44365,265 +45241,6 @@ async function createCursorDelegationBridge(cwd, environment, commandTimeoutMs =
   };
 }
 
-// dist/command.js
-import { existsSync as existsSync2, readdirSync } from "node:fs";
-import path4 from "node:path";
-
-// ../../harness-discovery/dist/environment.js
-import fs from "node:fs";
-import path2 from "node:path";
-function targetPath(platform) {
-  return platform === "win32" ? path2.win32 : path2.posix;
-}
-function environmentValue(environment, name) {
-  const lowered = name.toLowerCase();
-  for (const [key, value] of Object.entries(environment)) {
-    if (key.toLowerCase() === lowered)
-      return value;
-  }
-  return void 0;
-}
-function pathDelimiter(platform) {
-  return platform === "win32" ? ";" : ":";
-}
-function pathDirectories(environment, platform) {
-  return (environmentValue(environment, "PATH") ?? "").split(pathDelimiter(platform)).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter(Boolean);
-}
-function executableExtensions(command, platform, environment) {
-  if (platform !== "win32")
-    return [""];
-  if (targetPath(platform).extname(command) !== "")
-    return [""];
-  return (environmentValue(environment, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.trim()).filter(Boolean);
-}
-function isExecutableFile(filePath, platform) {
-  try {
-    fs.accessSync(filePath, platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
-    return fs.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function subdirectoryNames(directory) {
-  try {
-    return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch {
-    return [];
-  }
-}
-function newestFirst(names) {
-  return [...names].sort((left, right) => right.localeCompare(left, void 0, { numeric: true }));
-}
-
-// ../../harness-discovery/dist/invocation.js
-import path3 from "node:path";
-function commandInvocation(command, arguments_, environment, platform = process.platform) {
-  const extension = path3.win32.extname(command).toLowerCase();
-  if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
-    return { command, arguments: [...arguments_], windowsVerbatimArguments: false };
-  }
-  const quote2 = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
-  const commandLine = [command, ...arguments_].map(quote2).join(" ");
-  return {
-    command: environmentValue(environment, "ComSpec") ?? "cmd.exe",
-    arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
-    windowsVerbatimArguments: true
-  };
-}
-
-// ../../harness-discovery/dist/resolve.js
-import os from "node:os";
-
-// ../../harness-discovery/dist/version-managers.js
-function versionManagerBinaryDirectories(context) {
-  const { platform, environment, home } = context;
-  const list = context.subdirectories ?? subdirectoryNames;
-  const pathFlavor = targetPath(platform);
-  const value = (name) => environmentValue(environment, name);
-  const directories = [];
-  const versioned = (root, ...tail) => {
-    for (const version2 of newestFirst(list(root))) {
-      directories.push(pathFlavor.join(root, version2, ...tail));
-    }
-  };
-  if (platform === "win32") {
-    const appData = value("APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming");
-    const localAppData = value("LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local");
-    versioned(pathFlavor.join(appData, "nvm"));
-    versioned(value("FNM_DIR") ?? pathFlavor.join(appData, "fnm", "node-versions"), "installation");
-    directories.push(pathFlavor.join(localAppData, "Volta", "bin"));
-    directories.push(pathFlavor.join(home, ".bun", "bin"));
-    const pnpmHome2 = value("PNPM_HOME");
-    if (pnpmHome2)
-      directories.push(pnpmHome2);
-    directories.push(pathFlavor.join(localAppData, "pnpm"));
-    return directories;
-  }
-  versioned(pathFlavor.join(value("NVM_DIR") ?? pathFlavor.join(home, ".nvm"), "versions", "node"), "bin");
-  const fnmRoots = [
-    value("FNM_DIR"),
-    pathFlavor.join(home, ".local", "share", "fnm"),
-    pathFlavor.join(home, "Library", "Application Support", "fnm")
-  ].filter((root) => root !== void 0);
-  for (const root of fnmRoots) {
-    versioned(pathFlavor.join(root, "node-versions"), "installation", "bin");
-  }
-  const voltaHome = value("VOLTA_HOME") ?? pathFlavor.join(home, ".volta");
-  versioned(pathFlavor.join(voltaHome, "tools", "image", "node"), "bin");
-  directories.push(pathFlavor.join(voltaHome, "bin"));
-  const asdfHome = value("ASDF_DATA_DIR") ?? pathFlavor.join(home, ".asdf");
-  versioned(pathFlavor.join(asdfHome, "installs", "nodejs"), "bin");
-  directories.push(pathFlavor.join(asdfHome, "shims"));
-  const nodenvHome = value("NODENV_ROOT") ?? pathFlavor.join(home, ".nodenv");
-  versioned(pathFlavor.join(nodenvHome, "versions"), "bin");
-  directories.push(pathFlavor.join(nodenvHome, "shims"));
-  versioned(pathFlavor.join(value("N_PREFIX") ?? "/usr/local", "n", "versions", "node"), "bin");
-  directories.push(pathFlavor.join(home, ".bun", "bin"));
-  const pnpmHome = value("PNPM_HOME");
-  if (pnpmHome)
-    directories.push(pnpmHome);
-  directories.push(pathFlavor.join(home, "Library", "pnpm"));
-  directories.push(pathFlavor.join(home, ".local", "share", "pnpm"));
-  for (const prefix of ["/opt/homebrew/opt", "/usr/local/opt"]) {
-    for (const formula of newestFirst(list(prefix).filter((name) => name.startsWith("node@")))) {
-      directories.push(pathFlavor.join(prefix, formula, "bin"));
-    }
-  }
-  return directories;
-}
-
-// ../../harness-discovery/dist/resolve.js
-var VERSION_MANAGER_ROOTS = "<version-managers>";
-function installRootExtensions(platform) {
-  return platform === "win32" ? [".exe", ".cmd"] : [""];
-}
-function resolveHomeDirectory(input) {
-  return input.homeDirectory ?? environmentValue(input.environment, "HOME") ?? environmentValue(input.environment, "USERPROFILE") ?? os.homedir();
-}
-function templateVariables(environment, platform, home) {
-  const pathFlavor = targetPath(platform);
-  return {
-    HOME: home,
-    USERPROFILE: home,
-    APPDATA: environmentValue(environment, "APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming"),
-    LOCALAPPDATA: environmentValue(environment, "LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local")
-  };
-}
-function joinTemplate(platform, value) {
-  const pathFlavor = targetPath(platform);
-  const segments = value.split("/");
-  const head = segments[0] ?? "";
-  const tail = segments.slice(1);
-  if (head === "")
-    return pathFlavor.join(pathFlavor.sep, ...tail);
-  return tail.length === 0 ? head : pathFlavor.join(head, ...tail);
-}
-function expandInstallRoot(template, environment, platform, home) {
-  const variables = templateVariables(environment, platform, home);
-  let unresolved = false;
-  const substituted = template.replace(/^~(?=\/|$)/u, home).replace(/\$\{(\w+)\}/gu, (_match, name) => {
-    const value = variables[name] ?? environmentValue(environment, name);
-    if (value === void 0 || value === "") {
-      unresolved = true;
-      return "";
-    }
-    return value;
-  });
-  return unresolved ? void 0 : joinTemplate(platform, substituted);
-}
-function installRootDirectories(spec, input, dependencies, platform, home) {
-  const templates = (platform === "win32" ? spec.installRoots?.windows : spec.installRoots?.posix) ?? [];
-  const directories = [];
-  for (const template of templates) {
-    if (template === VERSION_MANAGER_ROOTS) {
-      directories.push(...versionManagerBinaryDirectories({
-        platform,
-        environment: input.environment,
-        home,
-        ...dependencies.subdirectories ? { subdirectories: dependencies.subdirectories } : {}
-      }));
-      continue;
-    }
-    const directory = expandInstallRoot(template, input.environment, platform, home);
-    if (directory !== void 0)
-      directories.push(directory);
-  }
-  return directories;
-}
-function harnessCandidates(spec, input, dependencies = {}) {
-  const platform = input.platform ?? process.platform;
-  const pathFlavor = targetPath(platform);
-  const configured = input.command ?? (spec.commandEnvironmentVariable ? environmentValue(input.environment, spec.commandEnvironmentVariable) : void 0);
-  const command = configured ?? spec.command;
-  if (pathFlavor.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
-    return [{ candidate: command, source: "configured" }];
-  }
-  const candidates = [];
-  const extensions = executableExtensions(command, platform, input.environment);
-  for (const directory of pathDirectories(input.environment, platform)) {
-    for (const extension of extensions) {
-      candidates.push({
-        candidate: pathFlavor.join(directory, command + extension),
-        source: "path"
-      });
-    }
-  }
-  if (configured !== void 0)
-    return candidates;
-  const home = resolveHomeDirectory(input);
-  for (const directory of installRootDirectories(spec, input, dependencies, platform, home)) {
-    for (const extension of installRootExtensions(platform)) {
-      candidates.push({
-        candidate: pathFlavor.join(directory, spec.command + extension),
-        source: "install-root"
-      });
-    }
-  }
-  return candidates;
-}
-function resolveHarnessExecutable(spec, input, dependencies = {}) {
-  const platform = input.platform ?? process.platform;
-  const isExecutable = dependencies.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
-  const runnable = spec.runnableCandidate ?? ((candidate) => candidate);
-  const context = { platform, isExecutable };
-  for (const { candidate, source } of harnessCandidates(spec, input, dependencies)) {
-    const executable = runnable(candidate, context);
-    if (executable !== void 0 && isExecutable(executable))
-      return { executable, source };
-  }
-  return void 0;
-}
-
-// dist/command.js
-function cursorInvocation(environment, command, args = ["acp"]) {
-  const resolution = resolveHarnessExecutable({
-    id: "cursor-cli",
-    command: "cursor-agent",
-    commandEnvironmentVariable: "CODEXHOST_CURSOR_COMMAND",
-    installRoots: {
-      posix: ["~/.local/bin", "/usr/local/bin", "/opt/homebrew/bin"],
-      windows: ["${LOCALAPPDATA}/cursor-agent"]
-    }
-  }, { environment, ...command ? { command } : {} });
-  if (!resolution)
-    throw new Error("Cursor CLI is not installed; install cursor-agent or set CODEXHOST_CURSOR_COMMAND");
-  if (process.platform === "win32" && /\.(cmd|ps1)$/iu.test(resolution.executable)) {
-    const root = path4.dirname(resolution.executable);
-    const versions = path4.join(root, "versions");
-    if (existsSync2(versions)) {
-      const version2 = readdirSync(versions).filter((name) => /^\d{4}\.\d{2}\.\d{2}-(?:\d{2}-\d{2}-\d{2}-)?[a-f0-9]+$/u.test(name)).sort().reverse().find((name) => existsSync2(path4.join(versions, name, "node.exe")) && existsSync2(path4.join(versions, name, "index.js")));
-      if (version2)
-        return {
-          command: path4.join(versions, version2, "node.exe"),
-          arguments: [path4.join(versions, version2, "index.js"), ...args],
-          windowsVerbatimArguments: false
-        };
-    }
-    throw new Error("Cursor Windows launcher has no supported native bundle; configure a native executable");
-  }
-  return commandInvocation(resolution.executable, args, environment);
-}
-
 // dist/transport.js
 var CursorTransport = class {
   options;
@@ -44676,7 +45293,7 @@ var CursorTransport = class {
     return this.#preparation ??= this.#prepare();
   }
   async #prepare() {
-    const invocation = cursorInvocation(this.options.environment, this.options.command);
+    const invocation = cursorInvocation(this.options.environment, this.options.command, this.options.executionPolicy === "unattended-full-access" ? ["--force", "acp"] : ["acp"]);
     const child = spawn(invocation.command, invocation.arguments, {
       cwd: this.options.cwd,
       env: this.options.environment,
@@ -44857,124 +45474,6 @@ var CursorTransport = class {
   }
 };
 
-// dist/native-history.js
-import { existsSync as existsSync3, readFileSync, realpathSync } from "node:fs";
-import os2 from "node:os";
-import path5 from "node:path";
-import { DatabaseSync } from "node:sqlite";
-function cursorConfigDirectory(environment) {
-  const home = environment.HOME ?? environment.USERPROFILE ?? os2.homedir();
-  return environment.CURSOR_CONFIG_DIR?.trim() ? path5.resolve(environment.CURSOR_CONFIG_DIR) : environment.XDG_CONFIG_HOME?.trim() ? path5.resolve(environment.XDG_CONFIG_HOME, "cursor") : path5.join(home, ".cursor");
-}
-function cursorSessionDirectory(sessionId, environment) {
-  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(sessionId))
-    throw new Error("Unsupported Cursor native session ID");
-  return path5.join(cursorConfigDirectory(environment), "acp-sessions", sessionId);
-}
-function cursorSameWorkspace(left, right) {
-  return path5.resolve(left) === path5.resolve(right) || existsSync3(left) && existsSync3(right) && realpathSync(left) === realpathSync(right);
-}
-function protobufBytes(data) {
-  if (data.length > 32 * 1024 * 1024)
-    throw new Error("Cursor native record is too large");
-  let offset = 0;
-  const varint = () => {
-    let result = 0;
-    for (let shift = 0; shift < 70; shift += 7) {
-      const value = data[offset++];
-      if (value === void 0)
-        throw new Error("Truncated Cursor native record");
-      result += (value & 127) * 2 ** shift;
-      if (!(value & 128))
-        return result;
-    }
-    throw new Error("Invalid Cursor native varint");
-  };
-  const fields = /* @__PURE__ */ new Map();
-  while (offset < data.length) {
-    const tag = varint();
-    const field = Math.floor(tag / 8), wire = tag % 8;
-    if (!Number.isSafeInteger(tag) || field === 0)
-      throw new Error("Invalid Cursor native field");
-    if (wire === 0) {
-      varint();
-      continue;
-    }
-    const length = wire === 2 ? varint() : wire === 1 ? 8 : wire === 5 ? 4 : -1;
-    if (!Number.isSafeInteger(length) || length < 0 || offset + length > data.length)
-      throw new Error("Unsupported Cursor native record");
-    if (wire === 2) {
-      const values = fields.get(field) ?? [];
-      values.push(Buffer.from(data.subarray(offset, offset + length)));
-      fields.set(field, values);
-    }
-    offset += length;
-  }
-  return fields;
-}
-function one(fields, field) {
-  const values = fields.get(field);
-  if (values?.length !== 1 || !values[0])
-    throw new Error("Cursor native history identity is missing or ambiguous");
-  return values[0];
-}
-function readCursorNativeHistory(sessionId, cwd, environment, allowMissing = false) {
-  const directory = cursorSessionDirectory(sessionId, environment);
-  const filename = path5.join(directory, "store.db");
-  if (allowMissing && !existsSync3(filename))
-    return { revision: void 0, turns: [] };
-  const info = JSON.parse(readFileSync(path5.join(directory, "meta.json"), "utf8"));
-  if (!info || typeof info !== "object" || !("cwd" in info) || typeof info.cwd !== "string" || !cursorSameWorkspace(info.cwd, cwd))
-    throw new Error("Cursor session workspace does not match");
-  const db = new DatabaseSync(filename, { readOnly: true });
-  try {
-    db.exec("BEGIN");
-    const row = db.prepare("SELECT value FROM meta WHERE key = ?").get("0");
-    if (!row && allowMissing)
-      return { revision: void 0, turns: [] };
-    if (typeof row?.value !== "string" || row.value.length > 1e6)
-      throw new Error("Unsupported Cursor native metadata");
-    const metadata = JSON.parse(Buffer.from(row.value, "hex").toString("utf8"));
-    if (metadata.agentId !== sessionId || typeof metadata.latestRootBlobId !== "string")
-      throw new Error("Cursor native session identity mismatch");
-    const get = (id) => {
-      if (!/^[0-9a-f]{64}$/u.test(id))
-        throw new Error("Invalid Cursor native blob reference");
-      const blob = db.prepare("SELECT data FROM blobs WHERE id = ?").get(id)?.data;
-      if (!(blob instanceof Uint8Array))
-        throw new Error("Cursor native history blob is missing");
-      return protobufBytes(blob);
-    };
-    const root = get(metadata.latestRootBlobId);
-    const result = [];
-    for (const ref of root.get(8) ?? []) {
-      if (ref.length !== 32)
-        throw new Error("Unsupported Cursor turn reference");
-      const container = get(ref.toString("hex"));
-      for (const record2 of container.get(1) ?? []) {
-        const turn = protobufBytes(record2);
-        const user = get(one(turn, 1).toString("hex"));
-        const id = one(user, 2).toString("utf8");
-        if (!/^[0-9a-f-]{36}$/iu.test(id) || result.some((existing) => existing.id === id))
-          throw new Error("Cursor native turn ID is invalid or duplicated");
-        const anchor = user.get(10)?.[0];
-        const rewindRoot = anchor?.length === 32 && db.prepare("SELECT 1 FROM blobs WHERE id = ?").get(anchor.toString("hex")) ? anchor.toString("hex") : void 0;
-        result.push({
-          id,
-          text: one(user, 1).toString("utf8"),
-          ...rewindRoot ? { rewindRoot } : {}
-        });
-      }
-    }
-    return { revision: metadata.latestRootBlobId, turns: result };
-  } finally {
-    db.close();
-  }
-}
-function readCursorNativeTurns(sessionId, cwd, environment, allowMissing = false) {
-  return readCursorNativeHistory(sessionId, cwd, environment, allowMissing).turns;
-}
-
 // ../../../node_modules/diff/libesm/diff/base.js
 var Diff = class {
   diff(oldStr, newStr, options = {}) {
@@ -45075,16 +45574,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path9, added, removed, oldPosInc, options) {
-    const last = path9.lastComponent;
+  addToPath(path12, added, removed, oldPosInc, options) {
+    const last = path12.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path12.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path12.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -45602,6 +46101,42 @@ function cursorChildSnapshot(parentId, item, terminal, output) {
   };
 }
 
+// dist/stream-error.js
+var CLOSED_ERROR = /(?:^|\n\n)Error:\s*(?:(?:RetriableError|T):)?\s*WritableIterable is closed\s*$/u;
+var CLOSED_PREFIXES = [
+  "\n\nError: RetriableError: WritableIterable is closed",
+  "\n\nError: T: WritableIterable is closed",
+  "\n\nError: WritableIterable is closed",
+  "Error: RetriableError: WritableIterable is closed",
+  "Error: T: WritableIterable is closed",
+  "Error: WritableIterable is closed"
+];
+var LONGEST_PREFIX = Math.max(...CLOSED_PREFIXES.map((prefix) => prefix.length));
+function isCursorWritableIterableClosed(message) {
+  return /WritableIterable is closed/iu.test(message);
+}
+function takeCursorWritableIterableClosed(text2, atMessageStart = true) {
+  const match = text2.match(CLOSED_ERROR);
+  if (!match || match.index === void 0 || match.index === 0 && !text2.startsWith("\n\n") && !atMessageStart)
+    return { visible: text2, closed: false };
+  return { visible: text2.slice(0, match.index), closed: true };
+}
+function holdCursorWritableIterablePrefix(text2, atMessageStart = true) {
+  const taken = takeCursorWritableIterableClosed(text2, atMessageStart);
+  if (taken.closed)
+    return { emit: taken.visible, hold: text2.slice(taken.visible.length) };
+  for (let size = Math.min(text2.length, LONGEST_PREFIX); size > 0; size -= 1) {
+    const suffix = text2.slice(-size);
+    const start = text2.length - size;
+    if (!suffix.startsWith("\n") && !(start === 0 && atMessageStart) && text2.slice(Math.max(0, start - 2), start) !== "\n\n")
+      continue;
+    if (CLOSED_PREFIXES.some((candidate) => candidate.startsWith(suffix))) {
+      return { emit: text2.slice(0, -size), hold: suffix };
+    }
+  }
+  return { emit: text2, hold: "" };
+}
+
 // dist/projection.js
 var TOOL_OUTPUT_LIMIT = 1e5;
 function cursorFileChanges(content) {
@@ -45631,11 +46166,52 @@ var CursorTurnOutput = class {
   #text;
   #tools = /* @__PURE__ */ new Map();
   #finishedTools = /* @__PURE__ */ new Set();
+  #hold = "";
+  #writableIterableClosed = false;
+  #visibleAssistantText = false;
   constructor(turnId, emit, nativeTurnIndex = 0) {
     this.turnId = turnId;
     this.emit = emit;
     this.subagents = new CursorSubagents(turnId, emit, nativeTurnIndex);
   }
+  sawWritableIterableClosed() {
+    return this.#writableIterableClosed || takeCursorWritableIterableClosed(this.#hold).closed;
+  }
+  hasVisibleAssistantText() {
+    return this.#visibleAssistantText || takeCursorWritableIterableClosed(this.#hold).visible.trim().length > 0;
+  }
+  #flushHold() {
+    if (!this.#hold)
+      return;
+    const held = this.#hold;
+    this.#hold = "";
+    this.#appendText("agentMessage", held);
+  }
+  #appendText(type, text2) {
+    if (!text2)
+      return;
+    if (type === "agentMessage" && text2.trim())
+      this.#visibleAssistantText = true;
+    if (this.#text?.type !== type) {
+      this.#finishText();
+      const item = {
+        type,
+        itemId: hostItemIdSchema.parse(`cursor-${this.turnId}-${++this.#index}`),
+        text: ""
+      };
+      this.#text = item;
+      this.emit({ type: "item.started", turnId: this.turnId, item: { ...item } });
+    }
+    if (!this.#text)
+      return;
+    this.#text.text += text2;
+    this.emit({
+      type: "item.updated",
+      turnId: this.turnId,
+      itemId: this.#text.itemId,
+      update: { type: "text.append", text: text2 }
+    });
+  }
   #finishText(outcome = { status: "succeeded" }) {
     if (this.#text)
       this.emit({
@@ -45647,6 +46223,7 @@ var CursorTurnOutput = class {
   }
   update(notification) {
     if (this.subagents.update(notification)) {
+      this.#flushHold();
       this.#finishText();
       return;
     }
@@ -45655,26 +46232,17 @@ var CursorTurnOutput = class {
       if (update.content.type !== "text")
         return;
       const type = update.sessionUpdate === "agent_message_chunk" ? "agentMessage" : "reasoning";
-      if (this.#text?.type !== type) {
-        this.#finishText();
-        const item = {
-          type,
-          itemId: hostItemIdSchema.parse(`cursor-${this.turnId}-${++this.#index}`),
-          text: ""
-        };
-        this.#text = item;
-        this.emit({ type: "item.started", turnId: this.turnId, item: { ...item } });
-      }
-      if (!this.#text)
+      if (type === "reasoning") {
+        this.#flushHold();
+        this.#appendText(type, update.content.text);
         return;
-      this.#text.text += update.content.text;
-      this.emit({
-        type: "item.updated",
-        turnId: this.turnId,
-        itemId: this.#text.itemId,
-        update: { type: "text.append", text: update.content.text }
-      });
+      }
+      const combined = `${this.#hold}${update.content.text}`;
+      const { emit, hold } = holdCursorWritableIterablePrefix(combined, this.#text?.type !== "agentMessage" || this.#text.text.length === 0);
+      this.#hold = hold;
+      this.#appendText(type, emit);
     } else if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
+      this.#flushHold();
       this.#finishText();
       if (this.#finishedTools.has(update.toolCallId))
         return;
@@ -45743,6 +46311,11 @@ ${content.newText}`] : []).join("\n");
   }
   finish(outcome) {
     this.subagents.finish(outcome);
+    if (takeCursorWritableIterableClosed(this.#hold).closed) {
+      this.#writableIterableClosed = true;
+      this.#hold = "";
+    }
+    this.#flushHold();
     this.#finishText(outcome);
     for (const { item } of this.#tools.values())
       this.emit({
@@ -45822,9 +46395,11 @@ function cursorSnapshot(sessionId, native, replay, nativeSubagentId) {
 import { randomUUID } from "node:crypto";
 var CursorInteractions = class {
   emit;
+  refuseUnattendedApproval;
   #pending = /* @__PURE__ */ new Map();
-  constructor(emit) {
+  constructor(emit, refuseUnattendedApproval) {
     this.emit = emit;
+    this.refuseUnattendedApproval = refuseUnattendedApproval;
   }
   #ask(interaction) {
     return new Promise((resolve) => {
@@ -45833,6 +46408,10 @@ var CursorInteractions = class {
     });
   }
   async permission(turnId, request) {
+    if (this.refuseUnattendedApproval) {
+      await this.refuseUnattendedApproval();
+      return { outcome: { outcome: "cancelled" } };
+    }
     const response = await this.#ask({
       type: "approval",
       interactionId: hostInteractionIdSchema.parse(randomUUID()),
@@ -45850,6 +46429,10 @@ var CursorInteractions = class {
   async extension(turnId, method, params) {
     const interactionId = hostInteractionIdSchema.parse(randomUUID());
     if (method === "cursor/create_plan" && typeof params.plan === "string") {
+      if (this.refuseUnattendedApproval) {
+        await this.refuseUnattendedApproval();
+        return { outcome: { outcome: "cancelled" } };
+      }
       const response = await this.#ask({
         type: "approval",
         interactionId,
@@ -45955,10 +46538,10 @@ var CursorInteractions = class {
 
 // dist/fork.js
 import { createHash as createHash2 } from "node:crypto";
-import { copyFile, mkdir, mkdtemp, readdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, mkdtemp, readdir, readFile as readFile3, realpath as realpath2, rm, writeFile } from "node:fs/promises";
 import { readdirSync as readdirSync2 } from "node:fs";
 import os3 from "node:os";
-import path6 from "node:path";
+import path9 from "node:path";
 import { backup, DatabaseSync as DatabaseSync2 } from "node:sqlite";
 
 // dist/fork-terminal.js
@@ -46076,16 +46659,16 @@ async function runCursorForkTerminal(options, sessionId, signal, rewind) {
 
 // dist/fork.js
 async function copySnapshot(source, target) {
-  const db = new DatabaseSync2(path6.join(source, "store.db"), { readOnly: true });
+  const db = new DatabaseSync2(path9.join(source, "store.db"), { readOnly: true });
   try {
-    await backup(db, path6.join(target, "store.db"));
+    await backup(db, path9.join(target, "store.db"));
   } finally {
     db.close();
   }
-  await copyFile(path6.join(source, "meta.json"), path6.join(target, "meta.json"));
+  await copyFile(path9.join(source, "meta.json"), path9.join(target, "meta.json"));
 }
 function storeIdentity(directory, hashBlobs = true) {
-  const db = new DatabaseSync2(path6.join(directory, "store.db"), { readOnly: true });
+  const db = new DatabaseSync2(path9.join(directory, "store.db"), { readOnly: true });
   try {
     db.exec("BEGIN");
     const value = db.prepare("SELECT value FROM meta WHERE key = '0'").get()?.value;
@@ -46126,7 +46709,7 @@ async function forkCursorSession(source, checkpoint, options, signal) {
   if (rewindTurn && !rewindTurn.rewindRoot)
     throw new Error("Cursor target has no native rewind checkpoint");
   const original = storeIdentity(sourceDirectory);
-  const temporary = await mkdtemp(path6.join(os3.tmpdir(), "codexhost-cursor-fork-"));
+  const temporary = await mkdtemp(path9.join(os3.tmpdir(), "codexhost-cursor-fork-"));
   let target;
   let committed = false;
   const discard = async () => {
@@ -46135,12 +46718,12 @@ async function forkCursorSession(source, checkpoint, options, signal) {
   };
   try {
     signal.throwIfAborted();
-    const config2 = path6.join(temporary, "config");
+    const config2 = path9.join(temporary, "config");
     await mkdir(config2, { mode: 448 });
-    const nativeConfig = path6.join(cursorConfigDirectory(options.environment), "cli-config.json");
+    const nativeConfig = path9.join(cursorConfigDirectory(options.environment), "cli-config.json");
     let settings = {};
     try {
-      const data = JSON.parse(await readFile(nativeConfig, "utf8"));
+      const data = JSON.parse(await readFile3(nativeConfig, "utf8"));
       if (!data || typeof data !== "object" || Array.isArray(data))
         throw new Error("Invalid Cursor CLI configuration");
       settings = data;
@@ -46148,9 +46731,9 @@ async function forkCursorSession(source, checkpoint, options, signal) {
       if (!(error51 instanceof Error && "code" in error51 && error51.code === "ENOENT"))
         throw error51;
     }
-    await writeFile(path6.join(config2, "cli-config.json"), JSON.stringify({ ...settings, rewind: true }), { mode: 384 });
-    const chats = path6.join(config2, "chats", createHash2("md5").update(await realpath(options.cwd)).digest("hex"));
-    const copy = path6.join(chats, source.nativeSessionId);
+    await writeFile(path9.join(config2, "cli-config.json"), JSON.stringify({ ...settings, rewind: true }), { mode: 384 });
+    const chats = path9.join(config2, "chats", createHash2("md5").update(await realpath2(options.cwd)).digest("hex"));
+    const copy = path9.join(chats, source.nativeSessionId);
     await mkdir(copy, { recursive: true });
     await copySnapshot(sourceDirectory, copy);
     if (JSON.stringify(storeIdentity(copy)) !== JSON.stringify(original))
@@ -46160,14 +46743,14 @@ async function forkCursorSession(source, checkpoint, options, signal) {
       environment: {
         ...options.environment,
         CURSOR_CONFIG_DIR: config2,
-        CURSOR_DATA_DIR: path6.join(temporary, "data")
+        CURSOR_DATA_DIR: path9.join(temporary, "data")
       }
     }, source.nativeSessionId, signal, rewindTurn ? {
       steps: sourceTurns.slice(retained).filter((turn) => turn.rewindRoot).length,
       complete: () => {
         const targets = readdirSync2(chats).filter((id) => id !== source.nativeSessionId);
         const targetId = targets[0];
-        return targets.length === 1 && !!targetId && storeIdentity(path6.join(chats, targetId), false).root === rewindTurn.rewindRoot;
+        return targets.length === 1 && !!targetId && storeIdentity(path9.join(chats, targetId), false).root === rewindTurn.rewindRoot;
       }
     } : void 0);
     signal.throwIfAborted();
@@ -46176,7 +46759,7 @@ async function forkCursorSession(source, checkpoint, options, signal) {
       throw new Error("Cursor fork did not create one independent session");
     const sessionId = children[0].name;
     const destination = cursorSessionDirectory(sessionId, options.environment);
-    const nativeFork = path6.join(chats, sessionId);
+    const nativeFork = path9.join(chats, sessionId);
     const forked = storeIdentity(nativeFork);
     if (forked.agentId !== sessionId || forked.root !== (rewindTurn?.rewindRoot ?? original.root) || forked.blobs !== original.blobs)
       throw new Error("Cursor native fork changed conversation contents or identity");
@@ -46213,6 +46796,13 @@ async function forkCursorSession(source, checkpoint, options, signal) {
 // dist/adapter.js
 function cursorError(error51) {
   const message = sanitizeDiagnosticTail(error51 instanceof Error ? error51.message : "Cursor operation failed");
+  if (isCursorWritableIterableClosed(message)) {
+    return {
+      code: "nativeFailure",
+      message: "Cursor stream closed (WritableIterable)",
+      retryable: true
+    };
+  }
   const code = /not installed/iu.test(message) ? "notInstalled" : /auth|not logged in|login/iu.test(message) ? "authenticationRequired" : /exited|closed/iu.test(message) ? "processExited" : "protocolError";
   return { code, message, retryable: false };
 }
@@ -46231,14 +46821,19 @@ var CursorAdapter = class {
       try {
         cursorTaskAddress(nativeSubagentId);
         const session = [...this.#sessions].find((s) => s.transport.sessionId === parent.nativeSessionId);
-        if (session && path7.resolve(session.transport.options.cwd) !== path7.resolve(cwd))
+        if (session && path10.resolve(session.transport.options.cwd) !== path10.resolve(cwd))
           return rejected("invalidRequest", "Cursor parent workspace does not match");
         const active = session?.subagentSnapshot(nativeSubagentId);
         if (active)
           return { ok: true, value: active };
         const options = session?.transport.options ?? this.transportOptions(cwd);
         const before = readCursorNativeTurns(parent.nativeSessionId, cwd, options.environment);
-        replay = new CursorTransport({ ...options, delegation: false, loadModelCatalog: false });
+        replay = new CursorTransport({
+          ...options,
+          delegation: false,
+          executionPolicy: "default",
+          loadModelCatalog: false
+        });
         await replay.open(parent.nativeSessionId);
         const after = readCursorNativeTurns(parent.nativeSessionId, cwd, options.environment);
         if (JSON.stringify(before) !== JSON.stringify(after))
@@ -46259,12 +46854,19 @@ var CursorAdapter = class {
   #forks = /* @__PURE__ */ new Map();
   #inspections = /* @__PURE__ */ new Map();
   #closed = false;
+  sessionImport;
   constructor(options = {}) {
     this.options = options;
+    this.sessionImport = new CursorSessionImport(options.environment ?? process.env);
+  }
+  async inspectAccount() {
+    if (this.#closed)
+      return null;
+    return fetchCursorAccount({ environment: this.options.environment ?? process.env });
   }
   transportOptions(cwd, environment) {
     return {
-      cwd: path7.resolve(cwd),
+      cwd: path10.resolve(cwd),
       environment: { ...this.options.environment ?? process.env, ...environment },
       ...this.options.command ? { command: this.options.command } : {},
       ...this.options.timeoutMs ? { timeoutMs: this.options.timeoutMs } : {}
@@ -46276,7 +46878,7 @@ var CursorAdapter = class {
         status: "unavailable",
         error: { code: "unavailable", message: "Cursor adapter is closed", retryable: false }
       };
-    const cwd = path7.resolve(input.cwd ?? process.cwd());
+    const cwd = path10.resolve(input.cwd ?? process.cwd());
     const cached2 = this.#inspections.get(cwd);
     if (cached2 && (cached2.pending || !input.refresh))
       return cached2.result;
@@ -46323,11 +46925,19 @@ var CursorAdapter = class {
     return this.#openSession(input);
   }
   async #openSession(input, prepared) {
-    if (input.kind === "create" && input.executionPolicy === "unattended-full-access")
-      return rejected("unsupported", "Cursor ACP cannot confirm unattended full access under native team policy");
     if (input.kind === "resume" && input.nativeRef.harnessId !== this.harnessId)
       return rejected("invalidRequest", "Session belongs to another Harness");
-    const options = { ...this.transportOptions(input.cwd, input.environment), delegation: true };
+    let executionPolicy;
+    try {
+      executionPolicy = input.kind === "create" ? input.executionPolicy ?? "default" : cursorExecutionPolicy(input.nativeRef);
+    } catch {
+      return rejected("invalidRequest", "Invalid Cursor Native Session locator");
+    }
+    const options = {
+      ...this.transportOptions(input.cwd, input.environment),
+      delegation: true,
+      executionPolicy
+    };
     const transport = prepared ?? new CursorTransport(options);
     try {
       const before = input.kind === "resume" ? readCursorNativeHistory(input.nativeRef.nativeSessionId, options.cwd, options.environment) : void 0;
@@ -46380,11 +46990,13 @@ var CursorAdapter = class {
     const signal = controller.signal;
     if (!cursorForkAvailable())
       return rejected("unsupported", "Cursor Fork requires macOS/Linux with /usr/bin/script");
+    let executionPolicy;
     try {
       if (input.kind === "fork")
         validateCursorFork(input.sourceRef, input.checkpoint);
       else if (input.sourceRef.harnessId !== this.harnessId || input.sourceRef.formatVersion !== 1)
         return rejected("invalidRequest", "Invalid Cursor rollback source");
+      executionPolicy = cursorExecutionPolicy(input.sourceRef);
     } catch {
       return rejected("invalidRequest", "Invalid Cursor fork checkpoint");
     }
@@ -46417,7 +47029,7 @@ var CursorAdapter = class {
       const sameEnvironment = sourceEnvironment && [
         .../* @__PURE__ */ new Set([...Object.keys(sourceEnvironment), ...Object.keys(options.environment)])
       ].every((key) => sourceEnvironment[key] === options.environment[key]);
-      transport = new CursorTransport({ ...options, delegation: true }, sameEnvironment ? source?.info.nativeModels : void 0);
+      transport = new CursorTransport({ ...options, delegation: true, executionPolicy }, sameEnvironment ? source?.info.nativeModels : void 0);
       const abort = (error51) => {
         controller.abort(error51);
         throw error51;
@@ -46442,11 +47054,7 @@ var CursorAdapter = class {
         kind: "resume",
         cwd: input.cwd,
         environment: options.environment,
-        nativeRef: nativeSessionRefSchema.parse({
-          harnessId: this.harnessId,
-          nativeSessionId: derived.sessionId,
-          formatVersion: 1
-        }),
+        nativeRef: cursorNativeSessionRef(derived.sessionId, executionPolicy),
         ...model ? { model } : {},
         ...thinking ? { thinkingOptionId: thinking } : {},
         ...mode ? { permissionModeId: mode } : {}
@@ -46472,9 +47080,10 @@ var CursorAdapter = class {
   }
   async close() {
     this.#closed = true;
+    const importing = this.sessionImport.close();
     for (const controller of this.#forks.keys())
       controller.abort();
-    await Promise.allSettled(this.#forks.values());
+    await Promise.allSettled([importing, ...this.#forks.values()]);
     await Promise.allSettled([...this.#sessions].map((session) => session.close()));
     await Promise.allSettled([...this.#inspections.values()].map((inspection) => inspection.result));
   }
@@ -46506,9 +47115,11 @@ var CursorSession = class {
   initialState;
   #channel = new HarnessOutputChannel();
   outputs = this.#channel.outputs;
-  #interactions = new CursorInteractions((output) => this.#channel.emit(output));
+  #interactions;
+  #executionPolicy;
   #submitted = /* @__PURE__ */ new Set();
   #active;
+  #unattendedApproval = false;
   #configuring = false;
   #closed = false;
   #fresh;
@@ -46536,12 +47147,10 @@ var CursorSession = class {
     this.info = structuredClone(info);
     this.#fresh = created;
     this.#snapshot = loadedSnapshot;
+    this.#executionPolicy = transport.options.executionPolicy ?? "default";
+    this.#interactions = new CursorInteractions((output) => this.#channel.emit(output), this.#executionPolicy === "unattended-full-access" ? () => this.#refuseUnattendedApproval() : void 0);
     this.initialState = {
-      nativeRef: nativeSessionRefSchema.parse({
-        harnessId: "cursor-cli",
-        nativeSessionId: transport.sessionId,
-        formatVersion: 1
-      }),
+      nativeRef: cursorNativeSessionRef(transport.sessionId, this.#executionPolicy),
       effectiveModel: cursorConfiguredModelRef(cursorModels(info).current, info.configOptions),
       ...cursorThinkingState(info),
       effectivePermissionModeId: harnessPermissionModeIdSchema.parse(info.configOptions?.find((option) => option.id === "mode")?.currentValue ?? info.modes?.currentModeId ?? "agent")
@@ -46550,6 +47159,11 @@ var CursorSession = class {
   #native(allowMissing = false) {
     return readCursorNativeTurns(this.transport.sessionId, this.transport.options.cwd, this.transport.options.environment, allowMissing);
   }
+  /** Bound to unattended full access only; Cursor itself keeps enforcing its team policy. */
+  #refuseUnattendedApproval() {
+    this.#unattendedApproval = true;
+    return this.transport.cancel();
+  }
   async readSnapshot() {
     if (this.#closed)
       return rejected("invalidState", "Cursor session is closed");
@@ -46566,6 +47180,7 @@ var CursorSession = class {
         replay = new CursorTransport({
           ...this.transport.options,
           delegation: false,
+          executionPolicy: "default",
           loadModelCatalog: false
         });
         await replay.open(this.transport.sessionId);
@@ -46680,6 +47295,7 @@ var CursorSession = class {
     let fault;
     const output = new CursorTurnOutput(command.turnId, (event) => this.#channel.emit({ kind: "event", event }), before.length);
     this.#subagentOutput = output.subagents;
+    this.#unattendedApproval = false;
     this.#channel.emit({ kind: "event", event: { type: "turn.started", turnId: command.turnId } });
     let outcome = {
       status: "failed",
@@ -46695,7 +47311,15 @@ var CursorSession = class {
           output.subagents.extension(method, params);
         }
       });
-      outcome = this.#active?.cancelled || result.stopReason === "cancelled" ? { status: "cancelled" } : result.stopReason === "end_turn" ? { status: "succeeded" } : {
+      const streamClosed = output.sawWritableIterableClosed() && !output.hasVisibleAssistantText();
+      outcome = this.#active?.cancelled || result.stopReason === "cancelled" ? { status: "cancelled" } : streamClosed ? {
+        status: "failed",
+        error: {
+          code: "nativeFailure",
+          message: "Cursor stream closed (WritableIterable)",
+          retryable: true
+        }
+      } : result.stopReason === "end_turn" ? { status: "succeeded" } : {
         status: "failed",
         error: {
           code: "nativeFailure",
@@ -46707,6 +47331,15 @@ var CursorSession = class {
       fault = cursorError(error51);
       outcome = this.#active?.cancelled ? { status: "cancelled" } : { status: "failed", error: cursorError(error51) };
     }
+    if (!this.#active?.cancelled && this.#unattendedApproval)
+      outcome = {
+        status: "failed",
+        error: {
+          code: "nativeFailure",
+          message: "Cursor requested approval during unattended full access",
+          retryable: false
+        }
+      };
     try {
       const after = this.#native(this.#fresh);
       const added = after.filter((turn) => !before.some((old) => old.id === turn.id));
@@ -46770,7 +47403,7 @@ var CursorSession = class {
 
 // ../../harness-broker/dist/client.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { lstat, readFile as readFile2 } from "node:fs/promises";
+import { lstat as lstat2, readFile as readFile4 } from "node:fs/promises";
 import net, {} from "node:net";
 
 // ../../harness-broker/dist/protocol.js
@@ -46885,24 +47518,25 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 
 // ../../harness-broker/dist/paths.js
 import os4 from "node:os";
-import path8 from "node:path";
+import path11 from "node:path";
 var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
 var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
 function defaultHarnessBrokerDirectory(environment = process.env) {
   const home = environment.HOME || os4.homedir();
-  return path8.join(home, ".codexhost", "harness-broker");
+  return path11.join(home, ".codexhost", "harness-broker");
 }
 function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
   harnessPluginIdSchema.parse(harnessId);
   if (harnessId !== "claude-code")
-    return path8.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path8.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+    return path11.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path11.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
 
 // ../../harness-broker/dist/validation.js
 var cwdSchema = external_exports.string().min(1).max(16384);
 var brokerEnvironmentSchema = external_exports.object({
   CODEXHOST_CLI_PATH: external_exports.string().max(16384).optional(),
+  CODEXHOST_CLI_NODE_PATH: external_exports.string().max(16384).optional(),
   CODEXHOST_RUNTIME_ENDPOINT: external_exports.string().max(16384).optional(),
   CODEXHOST_RUNTIME_TOKEN: external_exports.string().max(16384).optional(),
   CODEXHOST_THREAD_ID: external_exports.string().max(256).optional()
@@ -47029,7 +47663,7 @@ var harnessErrorSchema = external_exports.object({
 var harnessSessionStateSchema = external_exports.custom((value) => {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
-  const record2 = value;
+  const record3 = value;
   const allowed = /* @__PURE__ */ new Set([
     "nativeRef",
     "effectiveModel",
@@ -47038,12 +47672,12 @@ var harnessSessionStateSchema = external_exports.custom((value) => {
     "availableThinkingOptions",
     "effectivePermissionModeId"
   ]);
-  if (Object.keys(record2).some((key) => !allowed.has(key)))
+  if (Object.keys(record3).some((key) => !allowed.has(key)))
     return false;
-  if (record2.nativeRef !== void 0 && !nativeSessionRefSchema.safeParse(record2.nativeRef).success) {
+  if (record3.nativeRef !== void 0 && !nativeSessionRefSchema.safeParse(record3.nativeRef).success) {
     return false;
   }
-  const { nativeRef: _nativeRef, ...configuration } = record2;
+  const { nativeRef: _nativeRef, ...configuration } = record3;
   void _nativeRef;
   return harnessConfigurationStateSchema.safeParse(configuration).success;
 });
@@ -47057,6 +47691,7 @@ var eventKeys = /* @__PURE__ */ new Map([
   ["item.started", /* @__PURE__ */ new Set(["type", "turnId", "item"])],
   ["item.updated", /* @__PURE__ */ new Set(["type", "turnId", "itemId", "update"])],
   ["item.completed", /* @__PURE__ */ new Set(["type", "turnId", "snapshot"])],
+  ["item.detached", /* @__PURE__ */ new Set(["type", "turnId", "itemId"])],
   ["interaction.closed", /* @__PURE__ */ new Set(["type", "interactionId", "turnId", "reason"])],
   ["turn.completed", /* @__PURE__ */ new Set(["type", "turnId", "nativeTurnRef", "outcome"])],
   ["session.faulted", /* @__PURE__ */ new Set(["type", "error"])]
@@ -47173,7 +47808,7 @@ function parseSessionMetadata(value) {
   };
 }
 async function readDescriptor(descriptorPath) {
-  const metadata = await lstat(descriptorPath);
+  const metadata = await lstat2(descriptorPath);
   if (metadata.isSymbolicLink())
     throw new Error("Aqua Harness broker descriptor must not be a symlink");
   if (!metadata.isFile())
@@ -47185,12 +47820,12 @@ async function readDescriptor(descriptorPath) {
       throw new Error("Aqua Harness broker descriptor belongs to another user");
     }
   }
-  const descriptor = harnessBrokerDescriptorSchema.parse(JSON.parse(await readFile2(descriptorPath, "utf8")));
+  const descriptor = harnessBrokerDescriptorSchema.parse(JSON.parse(await readFile4(descriptorPath, "utf8")));
   if (process.platform === "darwin" && Buffer.byteLength(descriptor.socketPath) > 103) {
     throw new Error("Aqua Harness broker socket path is too long for macOS");
   }
   if (process.platform !== "win32") {
-    const socket = await lstat(descriptor.socketPath);
+    const socket = await lstat2(descriptor.socketPath);
     if (socket.isSymbolicLink() || !socket.isSocket()) {
       throw new Error("Aqua Harness broker endpoint is not a Unix socket");
     }
@@ -47625,6 +48260,7 @@ var BrokeredHarnessAdapter = class {
       if (this.#forwardEnvironment && input.environment) {
         const allowed = [
           "CODEXHOST_CLI_PATH",
+          "CODEXHOST_CLI_NODE_PATH",
           "CODEXHOST_RUNTIME_ENDPOINT",
           "CODEXHOST_RUNTIME_TOKEN",
           "CODEXHOST_THREAD_ID"
@@ -47690,7 +48326,10 @@ function createHarnessAdapter(context) {
       liveCommandCatalog: true,
       environment: { ...context.environment }
     });
-  return new CursorAdapter({ environment: { ...context.environment } });
+  const environment = { ...context.environment };
+  return Object.assign(new CursorAdapter({ environment }), {
+    installation: createCursorInstallation(environment)
+  });
 }
 export {
   createHarnessAdapter