@codexhost/cli-darwin-x64 0.10.2 → 0.11.0

package/app/plugins/opencode/plugin.mjs

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // dist/opencode-adapter.js
 import { randomUUID } from "node:crypto";
 import fs4 from "node:fs";
-import path6 from "node:path";
+import path8 from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -776,10 +776,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path7) {
-  if (!path7)
+function getElementAtPath(obj, path12) {
+  if (!path12)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path12.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1188,11 +1188,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path7, issues) {
+function prefixIssues(path12, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path12);
     return iss;
   });
 }
@@ -1339,16 +1339,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path12 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path12, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1375,17 +1375,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path7 = []) => {
+  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 }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path12, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1417,8 +1417,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path7) {
+  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")
@@ -11788,29 +11788,29 @@ var formatMap = {
   // do not set
 };
 var stringProcessor = (schema, ctx, _json, _params) => {
-  const json2 = _json;
-  json2.type = "string";
+  const json3 = _json;
+  json3.type = "string";
   const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
   if (typeof minimum === "number")
-    json2.minLength = minimum;
+    json3.minLength = minimum;
   if (typeof maximum === "number")
-    json2.maxLength = maximum;
+    json3.maxLength = maximum;
   if (format) {
-    json2.format = formatMap[format] ?? format;
-    if (json2.format === "")
-      delete json2.format;
+    json3.format = formatMap[format] ?? format;
+    if (json3.format === "")
+      delete json3.format;
     if (format === "time") {
-      delete json2.format;
+      delete json3.format;
     }
   }
   if (contentEncoding)
-    json2.contentEncoding = contentEncoding;
+    json3.contentEncoding = contentEncoding;
   if (patterns && patterns.size > 0) {
     const regexes = [...patterns];
     if (regexes.length === 1)
-      json2.pattern = regexes[0].source;
+      json3.pattern = regexes[0].source;
     else if (regexes.length > 1) {
-      json2.allOf = [
+      json3.allOf = [
         ...regexes.map((regex) => ({
           ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
           pattern: regex.source
@@ -11820,40 +11820,40 @@ var stringProcessor = (schema, ctx, _json, _params) => {
   }
 };
 var numberProcessor = (schema, ctx, _json, _params) => {
-  const json2 = _json;
+  const json3 = _json;
   const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
   if (typeof format === "string" && format.includes("int"))
-    json2.type = "integer";
+    json3.type = "integer";
   else
-    json2.type = "number";
+    json3.type = "number";
   const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
   const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
   const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
   if (exMin) {
     if (legacy) {
-      json2.minimum = exclusiveMinimum;
-      json2.exclusiveMinimum = true;
+      json3.minimum = exclusiveMinimum;
+      json3.exclusiveMinimum = true;
     } else {
-      json2.exclusiveMinimum = exclusiveMinimum;
+      json3.exclusiveMinimum = exclusiveMinimum;
     }
   } else if (typeof minimum === "number") {
-    json2.minimum = minimum;
+    json3.minimum = minimum;
   }
   if (exMax) {
     if (legacy) {
-      json2.maximum = exclusiveMaximum;
-      json2.exclusiveMaximum = true;
+      json3.maximum = exclusiveMaximum;
+      json3.exclusiveMaximum = true;
     } else {
-      json2.exclusiveMaximum = exclusiveMaximum;
+      json3.exclusiveMaximum = exclusiveMaximum;
     }
   } else if (typeof maximum === "number") {
-    json2.maximum = maximum;
+    json3.maximum = maximum;
   }
   if (typeof multipleOf === "number")
-    json2.multipleOf = multipleOf;
+    json3.multipleOf = multipleOf;
 };
-var booleanProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var booleanProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
 var bigintProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
@@ -11865,13 +11865,13 @@ var symbolProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Symbols cannot be represented in JSON Schema");
   }
 };
-var nullProcessor = (_schema, ctx, json2, _params) => {
+var nullProcessor = (_schema, ctx, json3, _params) => {
   if (ctx.target === "openapi-3.0") {
-    json2.type = "string";
-    json2.nullable = true;
-    json2.enum = [null];
+    json3.type = "string";
+    json3.nullable = true;
+    json3.enum = [null];
   } else {
-    json2.type = "null";
+    json3.type = "null";
   }
 };
 var undefinedProcessor = (_schema, ctx, _json, _params) => {
@@ -11884,8 +11884,8 @@ var voidProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Void cannot be represented in JSON Schema");
   }
 };
-var neverProcessor = (_schema, _ctx, json2, _params) => {
-  json2.not = {};
+var neverProcessor = (_schema, _ctx, json3, _params) => {
+  json3.not = {};
 };
 var anyProcessor = (_schema, _ctx, _json, _params) => {
 };
@@ -11896,16 +11896,16 @@ var dateProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Date cannot be represented in JSON Schema");
   }
 };
-var enumProcessor = (schema, _ctx, json2, _params) => {
+var enumProcessor = (schema, _ctx, json3, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.every((v) => typeof v === "number"))
-    json2.type = "number";
+    json3.type = "number";
   if (values.every((v) => typeof v === "string"))
-    json2.type = "string";
-  json2.enum = values;
+    json3.type = "string";
+  json3.enum = values;
 };
-var literalProcessor = (schema, ctx, json2, _params) => {
+var literalProcessor = (schema, ctx, json3, _params) => {
   const def = schema._zod.def;
   const vals = [];
   for (const val of def.values) {
@@ -11927,22 +11927,22 @@ var literalProcessor = (schema, ctx, json2, _params) => {
   if (vals.length === 0) {
   } else if (vals.length === 1) {
     const val = vals[0];
-    json2.type = val === null ? "null" : typeof val;
+    json3.type = val === null ? "null" : typeof val;
     if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
-      json2.enum = [val];
+      json3.enum = [val];
     } else {
-      json2.const = val;
+      json3.const = val;
     }
   } else {
     if (vals.every((v) => typeof v === "number"))
-      json2.type = "number";
+      json3.type = "number";
     if (vals.every((v) => typeof v === "string"))
-      json2.type = "string";
+      json3.type = "string";
     if (vals.every((v) => typeof v === "boolean"))
-      json2.type = "boolean";
+      json3.type = "boolean";
     if (vals.every((v) => v === null))
-      json2.type = "null";
-    json2.enum = vals;
+      json3.type = "null";
+    json3.enum = vals;
   }
 };
 var nanProcessor = (_schema, ctx, _json, _params) => {
@@ -11950,16 +11950,16 @@ var nanProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("NaN cannot be represented in JSON Schema");
   }
 };
-var templateLiteralProcessor = (schema, _ctx, json2, _params) => {
-  const _json = json2;
+var templateLiteralProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   const pattern = schema._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor = (schema, _ctx, json2, _params) => {
-  const _json = json2;
+var fileProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   const file2 = {
     type: "string",
     format: "binary",
@@ -11982,8 +11982,8 @@ var fileProcessor = (schema, _ctx, json2, _params) => {
     Object.assign(_json, file2);
   }
 };
-var successProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var successProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
 var customProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
@@ -12011,27 +12011,27 @@ var setProcessor = (_schema, ctx, _json, _params) => {
   }
 };
 var arrayProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const { minimum, maximum } = schema._zod.bag;
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
-  json2.type = "array";
-  json2.items = process2(def.element, ctx, {
+    json3.maxItems = maximum;
+  json3.type = "array";
+  json3.items = process2(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
 };
 var objectProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "object";
-  json2.properties = {};
+  json3.type = "object";
+  json3.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json2.properties[key] = process2(shape[key], ctx, {
+    json3.properties[key] = process2(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -12046,21 +12046,21 @@ var objectProcessor = (schema, ctx, _json, params) => {
     }
   }));
   if (requiredKeys.size > 0) {
-    json2.required = Array.from(requiredKeys);
+    json3.required = Array.from(requiredKeys);
   }
   if (def.catchall?._zod.def.type === "never") {
-    json2.additionalProperties = false;
+    json3.additionalProperties = false;
   } else if (!def.catchall) {
     if (ctx.io === "output")
-      json2.additionalProperties = false;
+      json3.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = process2(def.catchall, ctx, {
+    json3.additionalProperties = process2(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
   }
 };
-var unionProcessor = (schema, ctx, json2, params) => {
+var unionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => process2(x, ctx, {
@@ -12068,12 +12068,12 @@ var unionProcessor = (schema, ctx, json2, params) => {
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
   if (isExclusive) {
-    json2.oneOf = options;
+    json3.oneOf = options;
   } else {
-    json2.anyOf = options;
+    json3.anyOf = options;
   }
 };
-var intersectionProcessor = (schema, ctx, json2, params) => {
+var intersectionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const a = process2(def.left, ctx, {
     ...params,
@@ -12088,12 +12088,12 @@ var intersectionProcessor = (schema, ctx, json2, params) => {
     ...isSimpleIntersection(a) ? a.allOf : [a],
     ...isSimpleIntersection(b) ? b.allOf : [b]
   ];
-  json2.allOf = allOf;
+  json3.allOf = allOf;
 };
 var tupleProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "array";
+  json3.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
   const prefixItems = def.items.map((x, i) => process2(x, ctx, {
@@ -12105,37 +12105,37 @@ var tupleProcessor = (schema, ctx, _json, params) => {
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
   if (ctx.target === "draft-2020-12") {
-    json2.prefixItems = prefixItems;
+    json3.prefixItems = prefixItems;
     if (rest) {
-      json2.items = rest;
+      json3.items = rest;
     }
   } else if (ctx.target === "openapi-3.0") {
-    json2.items = {
+    json3.items = {
       anyOf: prefixItems
     };
     if (rest) {
-      json2.items.anyOf.push(rest);
+      json3.items.anyOf.push(rest);
     }
-    json2.minItems = prefixItems.length;
+    json3.minItems = prefixItems.length;
     if (!rest) {
-      json2.maxItems = prefixItems.length;
+      json3.maxItems = prefixItems.length;
     }
   } else {
-    json2.items = prefixItems;
+    json3.items = prefixItems;
     if (rest) {
-      json2.additionalItems = rest;
+      json3.additionalItems = rest;
     }
   }
   const { minimum, maximum } = schema._zod.bag;
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
+    json3.maxItems = maximum;
 };
 var recordProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "object";
+  json3.type = "object";
   const keyType = def.keyType;
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
@@ -12144,18 +12144,18 @@ var recordProcessor = (schema, ctx, _json, params) => {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
-    json2.patternProperties = {};
+    json3.patternProperties = {};
     for (const pattern of patterns) {
-      json2.patternProperties[pattern.source] = valueSchema;
+      json3.patternProperties[pattern.source] = valueSchema;
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = process2(def.keyType, ctx, {
+      json3.propertyNames = process2(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json2.additionalProperties = process2(def.valueType, ctx, {
+    json3.additionalProperties = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -12164,19 +12164,19 @@ var recordProcessor = (schema, ctx, _json, params) => {
   if (keyValues) {
     const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
     if (validKeyValues.length > 0) {
-      json2.required = validKeyValues;
+      json3.required = validKeyValues;
     }
   }
 };
-var nullableProcessor = (schema, ctx, json2, params) => {
+var nullableProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const inner = process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
-    json2.nullable = true;
+    json3.nullable = true;
   } else {
-    json2.anyOf = [inner, { type: "null" }];
+    json3.anyOf = [inner, { type: "null" }];
   }
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
@@ -12185,22 +12185,22 @@ var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
-var defaultProcessor = (schema, ctx, json2, params) => {
+var defaultProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json2.default = JSON.parse(JSON.stringify(def.defaultValue));
+  json3.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var prefaultProcessor = (schema, ctx, json2, params) => {
+var prefaultProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
-    json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+    json3._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var catchProcessor = (schema, ctx, json2, params) => {
+var catchProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
@@ -12211,7 +12211,7 @@ var catchProcessor = (schema, ctx, json2, params) => {
   } catch {
     throw new Error("Dynamic catch values are not supported in JSON Schema");
   }
-  json2.default = catchValue;
+  json3.default = catchValue;
 };
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -12221,12 +12221,12 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
-var readonlyProcessor = (schema, ctx, json2, params) => {
+var readonlyProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json2.readOnly = true;
+  json3.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -12870,7 +12870,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
   $ZodString.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => stringProcessor(inst, ctx, json3, params);
   const bag = inst._zod.bag;
   inst.format = bag.format ?? null;
   inst.minLength = bag.minimum ?? null;
@@ -13141,7 +13141,7 @@ function hash(alg, params) {
 var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
   $ZodNumber.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => numberProcessor(inst, ctx, json3, params);
   _installLazyMethods(inst, "ZodNumber", {
     gt(value, params) {
       return this.check(_gt(value, params));
@@ -13221,7 +13221,7 @@ function uint32(params) {
 var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => booleanProcessor(inst, ctx, json3, params);
 });
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
@@ -13229,7 +13229,7 @@ function boolean2(params) {
 var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
   $ZodBigInt.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => bigintProcessor(inst, ctx, json3, params);
   inst.gte = (value, params) => inst.check(_gte(value, params));
   inst.min = (value, params) => inst.check(_gte(value, params));
   inst.gt = (value, params) => inst.check(_gt(value, params));
@@ -13264,7 +13264,7 @@ function uint64(params) {
 var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
   $ZodSymbol.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => symbolProcessor(inst, ctx, json3, params);
 });
 function symbol(params) {
   return _symbol(ZodSymbol, params);
@@ -13272,7 +13272,7 @@ function symbol(params) {
 var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
   $ZodUndefined.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => undefinedProcessor(inst, ctx, json3, params);
 });
 function _undefined3(params) {
   return _undefined2(ZodUndefined, params);
@@ -13280,7 +13280,7 @@ function _undefined3(params) {
 var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
   $ZodNull.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullProcessor(inst, ctx, json3, params);
 });
 function _null3(params) {
   return _null2(ZodNull, params);
@@ -13288,7 +13288,7 @@ function _null3(params) {
 var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
   $ZodAny.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => anyProcessor(inst, ctx, json3, params);
 });
 function any() {
   return _any(ZodAny);
@@ -13296,7 +13296,7 @@ function any() {
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unknownProcessor(inst, ctx, json3, params);
 });
 function unknown() {
   return _unknown(ZodUnknown);
@@ -13304,7 +13304,7 @@ function unknown() {
 var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
   $ZodNever.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => neverProcessor(inst, ctx, json3, params);
 });
 function never(params) {
   return _never(ZodNever, params);
@@ -13312,7 +13312,7 @@ function never(params) {
 var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
   $ZodVoid.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => voidProcessor(inst, ctx, json3, params);
 });
 function _void2(params) {
   return _void(ZodVoid, params);
@@ -13320,7 +13320,7 @@ function _void2(params) {
 var ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
   $ZodDate.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => dateProcessor(inst, ctx, json3, params);
   inst.min = (value, params) => inst.check(_gte(value, params));
   inst.max = (value, params) => inst.check(_lte(value, params));
   const c = inst._zod.bag;
@@ -13333,7 +13333,7 @@ function date3(params) {
 var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => arrayProcessor(inst, ctx, json3, params);
   inst.element = def.element;
   _installLazyMethods(inst, "ZodArray", {
     min(n, params) {
@@ -13363,7 +13363,7 @@ function keyof(schema) {
 var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => objectProcessor(inst, ctx, json3, params);
   util_exports.defineLazy(inst, "shape", () => {
     return def.shape;
   });
@@ -13436,7 +13436,7 @@ function looseObject(shape, params) {
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function union(options, params) {
@@ -13449,7 +13449,7 @@ function union(options, params) {
 var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
   ZodUnion.init(inst, def);
   $ZodXor.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function xor(options, params) {
@@ -13475,7 +13475,7 @@ function discriminatedUnion(discriminator, options, params) {
 var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
   $ZodIntersection.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => intersectionProcessor(inst, ctx, json3, params);
 });
 function intersection(left, right) {
   return new ZodIntersection({
@@ -13487,7 +13487,7 @@ function intersection(left, right) {
 var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
   $ZodTuple.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => tupleProcessor(inst, ctx, json3, params);
   inst.rest = (rest) => inst.clone({
     ...inst._zod.def,
     rest
@@ -13507,7 +13507,7 @@ function tuple(items, _paramsOrRest, _params) {
 var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   $ZodRecord.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => recordProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
@@ -13549,7 +13549,7 @@ function looseRecord(keyType, valueType, params) {
 var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
   $ZodMap.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => mapProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
   inst.min = (...args) => inst.check(_minSize(...args));
@@ -13568,7 +13568,7 @@ function map(keyType, valueType, params) {
 var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
   $ZodSet.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => setProcessor(inst, ctx, json3, params);
   inst.min = (...args) => inst.check(_minSize(...args));
   inst.nonempty = (params) => inst.check(_minSize(1, params));
   inst.max = (...args) => inst.check(_maxSize(...args));
@@ -13584,7 +13584,7 @@ function set(valueType, params) {
 var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => enumProcessor(inst, ctx, json3, params);
   inst.enum = def.entries;
   inst.options = Object.values(def.entries);
   const keys = new Set(Object.keys(def.entries));
@@ -13637,7 +13637,7 @@ function nativeEnum(entries, params) {
 var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
   $ZodLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => literalProcessor(inst, ctx, json3, params);
   inst.values = new Set(def.values);
   Object.defineProperty(inst, "value", {
     get() {
@@ -13658,7 +13658,7 @@ function literal(value, params) {
 var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   $ZodFile.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => fileProcessor(inst, ctx, json3, params);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
   inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
@@ -13669,7 +13669,7 @@ function file(params) {
 var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => transformProcessor(inst, ctx, json3, params);
   inst._zod.parse = (payload, _ctx) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
@@ -13709,7 +13709,7 @@ function transform(fn) {
 var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
   $ZodOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -13721,7 +13721,7 @@ function optional(innerType) {
 var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
   $ZodExactOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function exactOptional(innerType) {
@@ -13733,7 +13733,7 @@ function exactOptional(innerType) {
 var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullableProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -13748,7 +13748,7 @@ function nullish2(innerType) {
 var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
   $ZodDefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => defaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeDefault = inst.unwrap;
 });
@@ -13764,7 +13764,7 @@ function _default2(innerType, defaultValue) {
 var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
   $ZodPrefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => prefaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -13779,7 +13779,7 @@ function prefault(innerType, defaultValue) {
 var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
   $ZodNonOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nonoptionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -13792,7 +13792,7 @@ function nonoptional(innerType, params) {
 var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
   $ZodSuccess.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => successProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function success(innerType) {
@@ -13804,7 +13804,7 @@ function success(innerType) {
 var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
   $ZodCatch.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => catchProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeCatch = inst.unwrap;
 });
@@ -13818,7 +13818,7 @@ function _catch2(innerType, catchValue) {
 var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
   $ZodNaN.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nanProcessor(inst, ctx, json3, params);
 });
 function nan(params) {
   return _nan(ZodNaN, params);
@@ -13826,7 +13826,7 @@ function nan(params) {
 var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   $ZodPipe.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => pipeProcessor(inst, ctx, json3, params);
   inst.in = def.in;
   inst.out = def.out;
 });
@@ -13868,7 +13868,7 @@ var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) =>
 var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
   $ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => readonlyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -13880,7 +13880,7 @@ function readonly(innerType) {
 var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
   $ZodTemplateLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => templateLiteralProcessor(inst, ctx, json3, params);
 });
 function templateLiteral(parts, params) {
   return new ZodTemplateLiteral({
@@ -13892,7 +13892,7 @@ function templateLiteral(parts, params) {
 var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
   $ZodLazy.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => lazyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.getter();
 });
 function lazy(getter) {
@@ -13904,7 +13904,7 @@ function lazy(getter) {
 var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
   $ZodPromise.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => promiseProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function promise(innerType) {
@@ -13916,7 +13916,7 @@ function promise(innerType) {
 var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
   $ZodFunction.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => functionProcessor(inst, ctx, json3, params);
 });
 function _function(params) {
   return new ZodFunction({
@@ -13928,7 +13928,7 @@ function _function(params) {
 var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => customProcessor(inst, ctx, json3, params);
 });
 function check(fn) {
   const ch = new $ZodCheck({
@@ -14110,13 +14110,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path7 = ref.slice(1).split("/").filter(Boolean);
-  if (path7.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 (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path12[0] === defsKey) {
+    const key = path12[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14579,6 +14579,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;
 
@@ -14632,6 +14681,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();
@@ -14692,6 +14747,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();
@@ -14701,6 +14760,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,
@@ -14720,12 +14783,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)
@@ -14736,11 +14814,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
@@ -14878,6 +14958,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) => {
@@ -14910,6 +14992,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)) {
@@ -15029,11 +15121,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"),
@@ -15159,6 +15253,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);
@@ -15497,8 +15604,8 @@ function validateHostQuestionResponse(interaction, response) {
     if (!question.multiple && answers.length > 1) {
       return invalidRequest2("Single-choice Question accepts at most one answer");
     }
-    const declared = new Set(question.options.map(({ value }) => value));
-    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
+    const declared2 = new Set(question.options.map(({ value }) => value));
+    if (!question.allowOther && answers.some((answer) => !declared2.has(answer))) {
       return invalidRequest2("Question Response contains an undeclared choice");
     }
   }
@@ -16077,8 +16184,9 @@ var OpenCodeTransportError = class extends Error {
 import { randomBytes } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
 import fs2 from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import path4 from "node:path";
+import { createServer } from "node:net";
+import { homedir as homedir2, tmpdir } from "node:os";
+import path6 from "node:path";
 
 // ../../../node_modules/@opencode-ai/sdk/dist/v2/gen/core/serverSentEvents.gen.js
 var createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url: url2, ...options }) => {
@@ -16304,7 +16412,7 @@ var serializeObjectParam = ({ allowReserved, explode, name, style, value, valueO
 
 // ../../../node_modules/@opencode-ai/sdk/dist/v2/gen/core/utils.gen.js
 var PATH_PARAM_RE = /\{[^{}]+\}/g;
-var defaultPathSerializer = ({ path: path7, url: _url2 }) => {
+var defaultPathSerializer = ({ path: path12, url: _url2 }) => {
   let url2 = _url2;
   const matches = _url2.match(PATH_PARAM_RE);
   if (matches) {
@@ -16323,7 +16431,7 @@ var defaultPathSerializer = ({ path: path7, url: _url2 }) => {
         name = name.substring(1);
         style = "matrix";
       }
-      const value = path7[name];
+      const value = path12[name];
       if (value === void 0 || value === null) {
         continue;
       }
@@ -16354,11 +16462,11 @@ var defaultPathSerializer = ({ path: path7, url: _url2 }) => {
   }
   return url2;
 };
-var getUrl = ({ baseUrl, path: path7, query, querySerializer, url: _url2 }) => {
+var getUrl = ({ baseUrl, path: path12, query, querySerializer, url: _url2 }) => {
   const pathUrl = _url2.startsWith("/") ? _url2 : `/${_url2}`;
   let url2 = (baseUrl ?? "") + pathUrl;
-  if (path7) {
-    url2 = defaultPathSerializer({ path: path7, url: url2 });
+  if (path12) {
+    url2 = defaultPathSerializer({ path: path12, url: url2 });
   }
   let search = query ? querySerializer(query) : "";
   if (search.startsWith("?")) {
@@ -21481,7 +21589,7 @@ function createOpencodeClient(config2) {
 }
 
 // dist/command.js
-import path3 from "node:path";
+import path5 from "node:path";
 
 // ../../harness-discovery/dist/environment.js
 import fs from "node:fs";
@@ -21545,6 +21653,20 @@ function commandInvocation(command, arguments_, environment, platform = process.
   };
 }
 
+// ../../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";
 
@@ -21708,6 +21830,195 @@ function resolveHarnessExecutable(spec, input, dependencies = {}) {
   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 versionFromOutput(output) {
+  return installationVersion(output.match(/\b\d+(?:\.\d+){1,3}(?:-[\w.-]+)?(?:\+[\w.-]+)?\b/)?.[0]);
+}
+function newerInstallationVersion(current, latest) {
+  const a = installationVersion(current).replace(/\+.*/, "");
+  const b = installationVersion(latest).replace(/\+.*/, "");
+  const coreA = a.replace(/-.*/, "").split(".").map(BigInt);
+  const coreB = b.replace(/-.*/, "").split(".").map(BigInt);
+  for (let i = 0; i < Math.max(coreA.length, coreB.length); i++) {
+    if ((coreA[i] ?? 0n) !== (coreB[i] ?? 0n))
+      return (coreB[i] ?? 0n) > (coreA[i] ?? 0n);
+  }
+  const preA = a.includes("-") ? a.slice(a.indexOf("-") + 1).split(".") : [];
+  const preB = b.includes("-") ? b.slice(b.indexOf("-") + 1).split(".") : [];
+  if (!preA.length || !preB.length)
+    return !!preA.length && !preB.length;
+  for (let i = 0; i < Math.max(preA.length, preB.length); i++) {
+    const x = preA[i];
+    const y = preB[i];
+    if (x === y)
+      continue;
+    if (x === void 0 || y === void 0)
+      return x === void 0;
+    const numericX = /^\d+$/.test(x);
+    const numericY = /^\d+$/.test(y);
+    if (numericX && numericY) {
+      if (BigInt(x) === BigInt(y))
+        continue;
+      return BigInt(y) > BigInt(x);
+    }
+    if (numericX !== numericY)
+      return numericX;
+    return y > x;
+  }
+  return false;
+}
+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;
+  };
+}
+async function fetchInstallationText(url2) {
+  const request = async () => {
+    const response = await fetch(url2, { signal: AbortSignal.timeout(15e3) });
+    if (!response.ok)
+      throw new Error("Could not check the latest Harness version");
+    return response.text();
+  };
+  try {
+    return await request();
+  } catch (error51) {
+    if (error51 instanceof DOMException && (error51.name === "AbortError" || error51.name === "TimeoutError"))
+      throw error51;
+    return request();
+  }
+}
+
+// ../../harness-discovery/dist/npm-installation.js
+import { readFile, realpath } from "node:fs/promises";
+import path4 from "node:path";
+function referencesNpmBin(shim, name, bin) {
+  if (bin.includes(".."))
+    return false;
+  const target = `node_modules/${name}/${bin.replace(/^\.\//, "")}`.toLowerCase();
+  const text = shim.replaceAll("\\", "/").toLowerCase();
+  return text.includes(`%dp0%/${target}"`) || text.includes(`%~dp0/${target}"`);
+}
+async function npmInstallation(command, packages, environment) {
+  let selected = await realpath(command);
+  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(selected)) {
+    const shim = (await readFile(selected, "utf8")).replaceAll("\\", "/");
+    const root = path4.dirname(selected);
+    for (const name of packages) {
+      const directory2 = path4.join(root, "node_modules", ...name.split("/"));
+      const metadata = await readFile(path4.join(directory2, "package.json"), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+      const bins = typeof metadata?.bin === "string" ? [metadata.bin] : Object.values(metadata?.bin ?? {});
+      const bin = bins.find((entry) => referencesNpmBin(shim, name, entry));
+      if (bin) {
+        selected = await realpath(path4.join(directory2, bin));
+        break;
+      }
+    }
+  }
+  let directory = path4.dirname(selected);
+  for (let depth = 0; depth < 8; depth++) {
+    const metadata = await readFile(path4.join(directory, "package.json"), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+    if (metadata?.name && packages.includes(metadata.name)) {
+      const name = metadata.name;
+      const currentVersion = installationVersion(metadata.version);
+      const segments = name.split("/");
+      let modules = directory;
+      for (let index = 0; index < segments.length; index++)
+        modules = path4.dirname(modules);
+      const prefix = process.platform === "win32" ? path4.dirname(modules) : path4.dirname(path4.dirname(modules));
+      const globalRoot = process.platform === "win32" ? path4.join(prefix, "node_modules") : path4.join(prefix, "lib", "node_modules");
+      const env = withNodeRuntimeOnPath(environment);
+      const npm = resolveHarnessExecutable({ id: "npm", command: "npm", installRoots: { posix: [], windows: [] } }, { environment: env });
+      let globalInstall = modules === globalRoot;
+      if (process.platform === "win32") {
+        const project = (await Promise.all(["package.json", "package-lock.json", "npm-shrinkwrap.json"].map((file2) => readFile(path4.join(prefix, file2), "utf8").then(() => true, (error51) => error51.code !== "ENOENT")))).some(Boolean);
+        const bins = typeof metadata.bin === "string" ? { [name.split("/").at(-1) ?? name]: metadata.bin } : metadata.bin ?? {};
+        const launchers = await Promise.all(Object.entries(bins).map(async ([bin, entry]) => {
+          if (path4.basename(bin) !== bin || entry.includes(".."))
+            return false;
+          const target = await realpath(path4.join(directory, entry)).catch(() => "");
+          if (target.toLowerCase() !== selected.toLowerCase())
+            return false;
+          const shim = await readFile(path4.join(prefix, `${bin}.cmd`), "utf8").catch(() => "");
+          return referencesNpmBin(shim, name, entry);
+        }));
+        globalInstall = globalInstall && !project && launchers.some(Boolean);
+      }
+      const canUpdate = globalInstall && !!npm;
+      return {
+        prefix,
+        currentVersion,
+        canUpdate,
+        latest: async () => {
+          const data = JSON.parse(await fetchInstallationText(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`));
+          return installationVersion(data.version);
+        },
+        update: async (version2) => {
+          if (!canUpdate || !npm)
+            throw new Error("Use the original package manager to update this installation");
+          await runInstallationCommand(npm.executable, ["install", "--global", "--prefix", prefix, `${name}@${installationVersion(version2)}`], env, 3e5);
+        }
+      };
+    }
+    const parent = path4.dirname(directory);
+    if (parent === directory)
+      break;
+    directory = parent;
+  }
+  return null;
+}
+
 // dist/command.js
 var OpenCodeExecutableError = class extends Error {
   code = "OPENCODE_NOT_FOUND";
@@ -21742,16 +22053,34 @@ function resolveOpenCodeExecutable(input = {}, dependencies = {}) {
   }, dependencies);
   if (!resolution)
     throw new OpenCodeExecutableError();
-  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path3.resolve(resolution.executable);
+  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path5.resolve(resolution.executable);
 }
-function openCodeServerInvocation(executable, environment, platform = process.platform) {
-  return commandInvocation(executable, ["serve", "--hostname=127.0.0.1", "--port=0"], environment, platform);
+function openCodeServerInvocation(executable, environment, platform = process.platform, port = 0) {
+  return commandInvocation(executable, ["serve", "--hostname=127.0.0.1", `--port=${port}`], environment, platform);
 }
 
 // dist/server-connection.js
 var DEFAULT_STARTUP_TIMEOUT_MS = 2e4;
 var DEFAULT_CLOSE_TIMEOUT_MS = 3e3;
+var STARTUP_ATTEMPTS = 3;
 var SERVER_USERNAME = "codexhost";
+function freeLoopbackPort() {
+  return new Promise((resolve, reject) => {
+    const probe = createServer();
+    probe.unref();
+    probe.once("error", reject);
+    probe.listen({ host: "127.0.0.1", port: 0 }, () => {
+      const address = probe.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      probe.close(() => {
+        if (port)
+          resolve(port);
+        else
+          reject(new Error("Failed to assign an OpenCode Server loopback port"));
+      });
+    });
+  });
+}
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -21819,9 +22148,9 @@ function signalProcessTree(child, signal) {
   }
 }
 function safeOpenCodeServerCwd(environment) {
-  const candidates = [environment.USERPROFILE, environment.HOME, homedir(), tmpdir()];
+  const candidates = [environment.USERPROFILE, environment.HOME, homedir2(), tmpdir()];
   for (const candidate of candidates) {
-    if (!candidate || !path4.isAbsolute(candidate))
+    if (!candidate || !path6.isAbsolute(candidate))
       continue;
     try {
       if (!fs2.statSync(candidate).isDirectory())
@@ -21873,7 +22202,8 @@ var OpenCodeServerConnection = class {
       ...spawnOptions,
       windowsVerbatimArguments: spawnOptions.windowsVerbatimArguments
     }),
-    sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds))
+    sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+    assignPort: freeLoopbackPort
   }) {
     this.#options = options;
     this.#environment = options.environment ?? process.env;
@@ -21929,11 +22259,26 @@ var OpenCodeServerConnection = class {
       OPENCODE_SERVER_USERNAME: SERVER_USERNAME,
       OPENCODE_SERVER_PASSWORD: password
     };
-    const invocation = openCodeServerInvocation(executable, environment);
     const serverCwd = (this.#dependencies.resolveServerCwd ?? safeOpenCodeServerCwd)(environment);
     if (!serverCwd) {
       throw new OpenCodeTransportError("unavailable", "OpenCode Server requires a writable startup directory");
     }
+    let lastError;
+    for (let attempt = 0; attempt < STARTUP_ATTEMPTS; attempt += 1) {
+      try {
+        return await this.#startAttempt(executable, environment, serverCwd, password);
+      } catch (error51) {
+        lastError = error51;
+        if (!(error51 instanceof OpenCodeTransportError) || error51.code !== "processExited") {
+          throw classifySdkError(error51, "Server startup");
+        }
+      }
+    }
+    throw classifySdkError(lastError, "Server startup");
+  }
+  async #startAttempt(executable, environment, serverCwd, password) {
+    const port = await (this.#dependencies.assignPort ?? freeLoopbackPort)();
+    const invocation = openCodeServerInvocation(executable, environment, process.platform, port);
     let child;
     try {
       child = this.#dependencies.spawn(invocation.command, invocation.arguments, {
@@ -21994,7 +22339,7 @@ var OpenCodeServerConnection = class {
       return { baseUrl, authorization };
     } catch (error51) {
       await this.#stopChild(child).catch(() => void 0);
-      throw classifySdkError(error51, "Server startup");
+      throw error51;
     }
   }
   async #stopChild(child) {
@@ -22254,7 +22599,7 @@ var SdkOpenCodeTransport = class {
 
 // dist/file-change-verification.js
 import fs3 from "node:fs";
-import path5 from "node:path";
+import path7 from "node:path";
 function missingPath(error51) {
   if (!error51 || typeof error51 !== "object")
     return false;
@@ -22266,33 +22611,33 @@ function hasDotPathSegment(value) {
   return segments.some((segment) => segment === "." || segment === "..");
 }
 function canonicalDirectoryPath(value) {
-  let candidate = path5.resolve(value);
+  let candidate = path7.resolve(value);
   const missingSegments = [];
   for (; ; ) {
     try {
-      return path5.join(fs3.realpathSync.native(candidate), ...missingSegments);
+      return path7.join(fs3.realpathSync.native(candidate), ...missingSegments);
     } catch (error51) {
       if (!missingPath(error51))
         return void 0;
-      const parent = path5.dirname(candidate);
+      const parent = path7.dirname(candidate);
       if (parent === candidate)
         return void 0;
-      missingSegments.unshift(path5.basename(candidate));
+      missingSegments.unshift(path7.basename(candidate));
       candidate = parent;
     }
   }
 }
 function canonicalFilePath(value) {
-  const absolute = path5.resolve(value);
-  const parent = canonicalDirectoryPath(path5.dirname(absolute));
-  return parent ? path5.join(parent, path5.basename(absolute)) : void 0;
+  const absolute = path7.resolve(value);
+  const parent = canonicalDirectoryPath(path7.dirname(absolute));
+  return parent ? path7.join(parent, path7.basename(absolute)) : void 0;
 }
 function pathIsWithin(root, candidate, allowRoot) {
-  const relative = path5.relative(root, candidate);
-  return allowRoot && relative === "" || relative !== "" && relative !== ".." && !relative.startsWith(`..${path5.sep}`) && !path5.isAbsolute(relative);
+  const relative = path7.relative(root, candidate);
+  return allowRoot && relative === "" || relative !== "" && relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
 }
 function verifiedOpenCodeWorktree(sessionDirectory, paths) {
-  if (!paths || typeof paths !== "object" || typeof sessionDirectory !== "string" || typeof paths.directory !== "string" || typeof paths.worktree !== "string" || hasDotPathSegment(sessionDirectory) || hasDotPathSegment(paths.directory) || hasDotPathSegment(paths.worktree) || !path5.isAbsolute(sessionDirectory) || !path5.isAbsolute(paths.directory) || !path5.isAbsolute(paths.worktree)) {
+  if (!paths || typeof paths !== "object" || typeof sessionDirectory !== "string" || typeof paths.directory !== "string" || typeof paths.worktree !== "string" || hasDotPathSegment(sessionDirectory) || hasDotPathSegment(paths.directory) || hasDotPathSegment(paths.worktree) || !path7.isAbsolute(sessionDirectory) || !path7.isAbsolute(paths.directory) || !path7.isAbsolute(paths.worktree)) {
     return void 0;
   }
   const session = canonicalDirectoryPath(sessionDirectory);
@@ -22304,10 +22649,10 @@ function verifiedOpenCodeWorktree(sessionDirectory, paths) {
   return worktree;
 }
 function openCodeFileIdentity(file2, worktree) {
-  if (typeof file2 !== "string" || typeof worktree !== "string" || hasDotPathSegment(file2) || hasDotPathSegment(worktree) || !path5.isAbsolute(worktree) || !file2 || file2.includes("\0") || file2.includes("\n") || file2.includes("\r")) {
+  if (typeof file2 !== "string" || typeof worktree !== "string" || hasDotPathSegment(file2) || hasDotPathSegment(worktree) || !path7.isAbsolute(worktree) || !file2 || file2.includes("\0") || file2.includes("\n") || file2.includes("\r")) {
     return void 0;
   }
-  const candidate = canonicalFilePath(path5.isAbsolute(file2) ? file2 : path5.resolve(worktree, file2));
+  const candidate = canonicalFilePath(path7.isAbsolute(file2) ? file2 : path7.resolve(worktree, file2));
   return candidate && pathIsWithin(worktree, candidate, false) ? candidate : void 0;
 }
 
@@ -22489,6 +22834,11 @@ function semanticHistory(snapshot) {
     items: turn.items.map(({ item, outcome }) => {
       const { itemId: _itemId, ...content } = item;
       void _itemId;
+      if (content.type === "fileChange") {
+        const { sourceItemIds: _sourceItemIds, ...change } = content;
+        void _sourceItemIds;
+        return { item: change, outcome };
+      }
       return { item: content, outcome };
     }),
     outcome: turn.outcome,
@@ -22597,7 +22947,7 @@ function sameCwd(left, right) {
     try {
       return fs4.realpathSync.native(value);
     } catch {
-      return path6.resolve(value);
+      return path8.resolve(value);
     }
   };
   return canonical(left) === canonical(right);
@@ -23946,14 +24296,3058 @@ var OpenCodeAdapter = class {
   }
 };
 
-// dist/plugin.js
-var OPENCODE_COMMAND_ENV = "CODEXHOST_OPENCODE_COMMAND";
-function createHarnessAdapter(context) {
-  const environment = { ...context.environment };
-  return new OpenCodeAdapter({
-    ...environment[OPENCODE_COMMAND_ENV] ? { command: environment[OPENCODE_COMMAND_ENV] } : {},
+// dist/version.js
+import { execFile as execFile2 } from "node:child_process";
+import { promisify } from "node:util";
+function openCodeMajor(version2) {
+  const match = /^(?:opencode\s+)?v?([12])\.\d+\.\d+(?:[-+][\w.-]+)?$/u.exec(version2.trim());
+  if (!match)
+    throw new Error(`Unsupported OpenCode version: ${version2.trim().slice(0, 100)}`);
+  return match[1] === "1" ? 1 : 2;
+}
+async function detectOpenCode(options) {
+  const environment = options.environment ?? process.env;
+  const executable = resolveOpenCodeExecutable({
+    ...options.command ? { command: options.command } : {},
     environment
   });
+  const invocation = commandInvocation(executable, ["--version"], environment);
+  const { stdout } = await promisify(execFile2)(invocation.command, invocation.arguments, {
+    env: environment,
+    timeout: options.startupTimeoutMs ?? 2e4,
+    maxBuffer: 16384,
+    windowsHide: true,
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments
+  });
+  return { executable, major: openCodeMajor(stdout) };
+}
+
+// dist/v2/adapter.js
+import fs6 from "node:fs";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
+
+// dist/v2/state.js
+import fs5 from "node:fs";
+import path9 from "node:path";
+var harnessId = harnessIdSchema.parse("opencode");
+function failure(message, code = "nativeFailure") {
+  return {
+    code,
+    message,
+    retryable: ["nativeFailure", "unavailable", "sessionBusy"].includes(code)
+  };
+}
+function errorResult(error51) {
+  return {
+    ok: false,
+    error: failure(error51 instanceof Error ? error51.message : String(error51))
+  };
+}
+function sameDirectory(left, right) {
+  const canonical = (value) => {
+    try {
+      return fs5.realpathSync(value);
+    } catch {
+      return path9.resolve(value);
+    }
+  };
+  return canonical(left) === canonical(right);
+}
+function v2Ref(session, executionPolicy) {
+  return nativeSessionRefSchema.parse({
+    harnessId,
+    nativeSessionId: session.id,
+    formatVersion: 1,
+    locator: { protocol: 2, directory: session.location.directory, executionPolicy }
+  });
+}
+function v2Locator(ref) {
+  nativeSessionRefSchema.parse(ref);
+  const locator = ref.locator;
+  if (ref.harnessId !== harnessId || !locator || typeof locator !== "object" || Array.isArray(locator) || locator.protocol !== 2 || typeof locator.directory !== "string" || !locator.directory || locator.executionPolicy !== "default" && locator.executionPolicy !== "unattended-full-access") {
+    throw new Error("This Session requires an OpenCode v2 Native Ref; v1 histories are not migrated by codexhost");
+  }
+  return { directory: locator.directory, executionPolicy: locator.executionPolicy };
+}
+function v2Catalog(models, defaultModel) {
+  const enabled = models.filter((model) => model.enabled);
+  const variants = [...new Set(enabled.flatMap((model) => model.variants.map((v) => v.id)))].sort();
+  const ref = (model) => encodeOpenCodeModelRef({ providerID: model.providerID, modelID: model.id });
+  return harnessModelCatalogSchema.parse({
+    models: enabled.map((model) => ({
+      ref: ref(model),
+      label: `${model.providerID} / ${model.name}`,
+      resolvedModelLabel: `${model.providerID}/${model.id}`,
+      supportedThinkingOptionIds: [
+        encodeOpenCodeVariant(void 0),
+        ...model.variants.map((v) => encodeOpenCodeVariant(v.id))
+      ]
+    })),
+    ...defaultModel && enabled.some((m) => ref(m).id === ref(defaultModel).id) ? { defaultModel: ref(defaultModel) } : {},
+    thinkingOptions: [void 0, ...variants].map((v) => ({
+      id: encodeOpenCodeVariant(v),
+      label: v ?? "Default"
+    })),
+    defaultThinkingOptionId: encodeOpenCodeVariant(void 0)
+  });
+}
+function v2Permissions(current = [], mode) {
+  const selected = decodeOpenCodePermissionModeId(mode);
+  const rules = current.filter((rule) => !(rule.action === "*" && rule.resource === "*" && ["allow", "ask"].includes(rule.effect)));
+  return selected === "default" ? rules : [...rules, { action: "*", resource: "*", effect: selected }];
+}
+function v2State(session, catalog, policy) {
+  const model = session.model ? encodeOpenCodeModelRef({ providerID: session.model.providerID, modelID: session.model.id }) : void 0;
+  const entry = catalog.models.find((candidate) => candidate.ref.id === model?.id);
+  const mode = session.permissions?.findLast((rule) => rule.action === "*" && rule.resource === "*");
+  return {
+    nativeRef: v2Ref(session, policy),
+    ...model ? { effectiveModel: model } : {},
+    ...entry ? {
+      resolvedModelLabel: entry.resolvedModelLabel ?? entry.label,
+      availableThinkingOptions: catalog.thinkingOptions.filter((v) => entry.supportedThinkingOptionIds?.includes(v.id)),
+      effectiveThinkingOptionId: encodeOpenCodeVariant(session.model?.variant)
+    } : {},
+    effectivePermissionModeId: decodeMode(mode?.effect)
+  };
+}
+function decodeMode(effect) {
+  return effect === "allow" || effect === "ask" ? harnessPermissionModeIdSchema.parse(effect) : harnessPermissionModeIdSchema.parse("default");
+}
+function v2Usage(session) {
+  const tokens = session.tokens;
+  return parseHostUsage({
+    inputTokens: tokens.input,
+    outputTokens: tokens.output,
+    reasoningOutputTokens: tokens.reasoning,
+    cachedInputTokens: tokens.cache.read,
+    cacheWriteInputTokens: tokens.cache.write,
+    totalCostUsd: session.cost
+  });
+}
+
+// dist/v2/catalog.js
+async function readCatalog(client2, cwd, timeoutMs) {
+  const location = { directory: cwd };
+  const deadline = Date.now() + timeoutMs;
+  const required2 = ["opencode.config.provider", "opencode.config.agent", "opencode.config.policy"];
+  while (true) {
+    const { data: plugins } = await client2.plugin.list({ location });
+    const config2 = required2.map((id) => plugins.find((plugin) => plugin.id === id));
+    const failed = config2.find((plugin) => plugin?.state.status === "failed");
+    if (failed?.state.status === "failed")
+      throw new Error(`OpenCode configuration failed: ${failed.state.error}`);
+    if (config2.every((plugin) => plugin?.state.status === "active"))
+      break;
+    if (Date.now() >= deadline)
+      throw new Error("OpenCode v2 configuration plugins did not become ready");
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  const [models, selected] = await Promise.all([
+    client2.model.list({ location }),
+    client2.model.default({ location })
+  ]);
+  return v2Catalog(models.data, selected.data);
+}
+
+// dist/v2/connection.js
+import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+
+// ../../../node_modules/@opencode/client/dist/chunks/service-timing-9rqn6x4v.js
+var __defProp2 = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// ../../../node_modules/@opencode/client/dist/chunks/service-timing-frbwqjmf.js
+var exports_shared_events = {};
+__export2(exports_shared_events, {
+  SharedEvents: () => exports_shared_events,
+  make: () => make7
+});
+function make7(connect) {
+  let current;
+  const capacity = 4096;
+  function stop(connection) {
+    connection.connected = void 0;
+    connection.controller.abort();
+    if (current === connection)
+      current = void 0;
+  }
+  async function run(connection) {
+    let iterator;
+    let completion = {};
+    try {
+      if (connection.controller.signal.aborted)
+        return;
+      iterator = connect(connection.controller.signal, () => {
+        connection.subscribers.forEach((subscriber) => subscriber.activity?.());
+      })[Symbol.asyncIterator]();
+      while (!connection.controller.signal.aborted) {
+        const item = await iterator.next();
+        if (item.done || connection.controller.signal.aborted)
+          break;
+        if (item.value.type === "server.connected")
+          connection.connected = item.value;
+        connection.subscribers.forEach((subscriber) => subscriber.push(item.value));
+      }
+    } catch (error51) {
+      completion = { error: error51 };
+    } finally {
+      stop(connection);
+      try {
+        await iterator?.return?.();
+      } catch (error51) {
+        if (!("error" in completion))
+          completion = { error: error51 };
+      }
+      connection.subscribers.forEach((subscriber) => subscriber.finish(completion));
+    }
+  }
+  return {
+    subscribe(options) {
+      return {
+        [Symbol.asyncIterator]() {
+          const pending = [];
+          const queued = [];
+          let started = false;
+          let completion;
+          let connection;
+          function finish(result, discard = true) {
+            completion = result;
+            if (discard)
+              queued.length = 0;
+            options?.signal?.removeEventListener("abort", abort);
+            if (connection?.subscribers.delete(subscriber) && !connection.subscribers.size)
+              stop(connection);
+            pending.splice(0).forEach((request) => {
+              if ("error" in result)
+                request.reject(result.error);
+              else
+                request.resolve({ done: true, value: void 0 });
+            });
+          }
+          function abort() {
+            finish({});
+          }
+          const subscriber = {
+            activity: options?.onActivity,
+            finish(result) {
+              finish(result, false);
+            },
+            push(value) {
+              if (completion)
+                return;
+              const request = pending.shift();
+              if (request) {
+                request.resolve({ done: false, value });
+                return;
+              }
+              if (queued.length === capacity) {
+                finish({ error: new Error(`Event subscriber exceeded its ${capacity}-event capacity`) });
+                return;
+              }
+              queued.push(value);
+            }
+          };
+          function start() {
+            if (completion)
+              return;
+            const fresh = !current;
+            connection = current ?? {
+              controller: new AbortController(),
+              subscribers: /* @__PURE__ */ new Set()
+            };
+            current = connection;
+            connection.subscribers.add(subscriber);
+            if (connection.connected)
+              subscriber.push(connection.connected);
+            if (fresh)
+              run(connection);
+          }
+          return {
+            next() {
+              const value = queued.shift();
+              if (value)
+                return Promise.resolve({ done: false, value });
+              if (completion) {
+                if ("error" in completion)
+                  return Promise.reject(completion.error);
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              if (options?.signal?.aborted) {
+                abort();
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              const request = Promise.withResolvers();
+              pending.push(request);
+              if (!started) {
+                started = true;
+                options?.signal?.addEventListener("abort", abort, { once: true });
+                start();
+              }
+              return request.promise;
+            },
+            return() {
+              finish({});
+              return Promise.resolve({ done: true, value: void 0 });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+
+// ../../../node_modules/@opencode/client/dist/chunks/service-timing-nwcpakzx.js
+var ClientError3 = class extends Error {
+  reason;
+  name = "ClientError";
+  constructor(reason, options) {
+    const detail = options?.detail ?? (options?.cause instanceof Error ? options.cause.message : void 0);
+    super(detail ? `${reason}: ${detail}` : reason, options);
+    this.reason = reason;
+  }
+};
+
+// ../../../node_modules/@opencode/client/dist/chunks/service-timing-bpdjd9xk.js
+var exports_client4 = {};
+__export2(exports_client4, {
+  make: () => make6
+});
+var maxSseEventBytes = 16 * 1024 * 1024;
+function make6(options) {
+  const fetch2 = options.fetch ?? globalThis.fetch;
+  const prepare = (descriptor, requestOptions) => {
+    const baseUrl = new URL(options.baseUrl);
+    if (!baseUrl.pathname.endsWith("/"))
+      baseUrl.pathname += "/";
+    const url2 = new URL(descriptor.path.slice(1), baseUrl);
+    for (const [key, value] of Object.entries(descriptor.query ?? {}))
+      appendQuery(url2.searchParams, key, value);
+    const headers = new Headers(options.headers);
+    for (const [key, value] of Object.entries(descriptor.headers ?? {})) {
+      if (value !== void 0 && value !== null)
+        headers.set(key, String(value));
+    }
+    for (const [key, value] of new Headers(requestOptions?.headers))
+      headers.set(key, value);
+    if (descriptor.body !== void 0 && !headers.has("content-type"))
+      headers.set("content-type", descriptor.binaryBody ? "application/octet-stream" : "application/json");
+    return {
+      url: url2,
+      init: {
+        method: descriptor.method,
+        signal: requestOptions?.signal,
+        headers,
+        body: descriptor.body === void 0 ? void 0 : descriptor.binaryBody ? descriptor.body : JSON.stringify(descriptor.body)
+      }
+    };
+  };
+  const execute = async (descriptor, requestOptions) => {
+    try {
+      const prepared = prepare(descriptor, requestOptions);
+      return await fetch2(prepared.url, prepared.init);
+    } catch (cause) {
+      throw new ClientError3("Transport", { cause });
+    }
+  };
+  const responseError = async (response, descriptor) => {
+    if (descriptor.declaredStatuses.includes(response.status))
+      throw declared(await json2(response));
+    try {
+      await response.body?.cancel();
+    } catch {
+    }
+    throw new ClientError3("UnexpectedStatus", { cause: { status: response.status }, detail: String(response.status) });
+  };
+  const request = async (descriptor, requestOptions) => {
+    const response = await execute(descriptor, requestOptions);
+    if (response.status !== descriptor.successStatus)
+      return responseError(response, descriptor);
+    if (descriptor.binary)
+      return new Uint8Array(await response.arrayBuffer());
+    if (descriptor.empty) {
+      try {
+        await response.body?.cancel();
+      } catch {
+      }
+      return;
+    }
+    return await json2(response);
+  };
+  const sse = (descriptor, requestOptions) => ({
+    async *[Symbol.asyncIterator]() {
+      const response = await execute(descriptor, requestOptions);
+      if (response.status !== descriptor.successStatus)
+        await responseError(response, descriptor);
+      if (!isContentType(response, "text/event-stream")) {
+        try {
+          await response.body?.cancel();
+        } catch {
+        }
+        throw new ClientError3("UnsupportedContentType", { detail: response.headers.get("content-type") });
+      }
+      if (response.body === null)
+        throw new ClientError3("MalformedResponse");
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          let next;
+          try {
+            next = await reader.read();
+          } catch (cause) {
+            throw new ClientError3("Transport", { cause });
+          }
+          if (!next.done)
+            requestOptions?.onActivity?.();
+          buffer += decoder.decode(next.value, { stream: !next.done });
+          if (buffer.length > maxSseEventBytes)
+            throw new ClientError3("SseEventTooLarge");
+          const trailingCarriageReturn = !next.done && buffer.endsWith("\r");
+          if (trailingCarriageReturn)
+            buffer = buffer.slice(0, -1);
+          buffer = buffer.replaceAll(`\r
+`, `
+`).replaceAll("\r", `
+`);
+          if (trailingCarriageReturn)
+            buffer += "\r";
+          if (next.done && buffer !== "")
+            buffer += `
+
+`;
+          let boundary = buffer.indexOf(`
+
+`);
+          while (boundary >= 0) {
+            const block = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            const data = block.split(`
+`).flatMap((line) => line.startsWith("data:") ? [line.slice(5).trimStart()] : []).join(`
+`);
+            if (data !== "") {
+              try {
+                yield JSON.parse(data);
+              } catch (cause) {
+                throw new ClientError3("MalformedResponse", { cause });
+              }
+            }
+            boundary = buffer.indexOf(`
+
+`);
+          }
+          if (next.done)
+            return;
+        }
+      } finally {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        reader.releaseLock();
+      }
+    }
+  });
+  return {
+    server: {
+      info: (requestOptions) => request({ method: "GET", path: `/api/info`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions)
+    },
+    location: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/location`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      reload: (requestOptions) => request({
+        method: "POST",
+        path: `/api/location/reload`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 503],
+        empty: true
+      }, requestOptions)
+    },
+    agent: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/agent`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/agent/${encodeURIComponent(input.agentID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    plugin: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/plugin`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      check: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/plugin/check`,
+        query: { location: input?.["location"] },
+        body: { target: input?.["target"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/plugin/update`,
+        query: { location: input["location"] },
+        body: { targets: input["targets"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 503],
+        empty: true
+      }, requestOptions)
+    },
+    session: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session`,
+        query: {
+          limit: input?.["limit"],
+          order: input?.["order"],
+          search: input?.["search"],
+          parentID: input?.["parentID"],
+          directory: input?.["directory"],
+          project: input?.["project"],
+          subpath: input?.["subpath"],
+          cursor: input?.["cursor"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      stats: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/experimental/session/stats`,
+        query: {
+          from: input?.["from"],
+          to: input?.["to"],
+          project: input?.["project"],
+          timezone: input?.["timezone"],
+          tools: input?.["tools"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session`,
+        body: {
+          id: input?.["id"],
+          title: input?.["title"],
+          agent: input?.["agent"],
+          model: input?.["model"],
+          location: input?.["location"],
+          metadata: input?.["metadata"],
+          permissions: input?.["permissions"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      import: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/session/import`,
+        body: { info: input["info"], messages: input["messages"], location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      export: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/export`,
+        query: { sanitize: input["sanitize"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      active: (requestOptions) => request({
+        method: "GET",
+        path: `/api/session/active`,
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      fork: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/fork`,
+        body: { before: input["before"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      switchAgent: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/agent`,
+        body: { agent: input["agent"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      switchModel: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/model`,
+        body: { model: input["model"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+        body: { title: input["title"], metadata: input["metadata"], permissions: input["permissions"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      move: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/move`,
+        body: { directory: input["directory"], delivery: input["delivery"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      prompt: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/prompt`,
+        body: {
+          id: input["id"],
+          text: input["text"],
+          files: input["files"],
+          agents: input["agents"],
+          skills: input["skills"],
+          metadata: input["metadata"],
+          delivery: input["delivery"],
+          resume: input["resume"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      command: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/command`,
+        body: {
+          name: input["name"],
+          text: input["text"],
+          files: input["files"],
+          agents: input["agents"],
+          skills: input["skills"],
+          delivery: input["delivery"]
+        },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: true
+      }, requestOptions),
+      skill: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/skill`,
+        body: { id: input["id"], resume: input["resume"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      synthetic: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/synthetic`,
+        body: {
+          id: input["id"],
+          text: input["text"],
+          description: input["description"],
+          metadata: input["metadata"],
+          delivery: input["delivery"],
+          resume: input["resume"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      shell: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/shell`,
+        body: { id: input["id"], command: input["command"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      compact: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
+        body: { id: input["id"], delivery: input["delivery"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      wait: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/wait`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: true
+      }, requestOptions),
+      revert: {
+        stage: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/stage`,
+          body: { messageID: input["messageID"], files: input["files"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 409, 500],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        clear: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/revert`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409, 500],
+          empty: true
+        }, requestOptions),
+        commit: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions)
+      },
+      context: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/context`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      diff: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/diff`,
+        query: { from: input["from"], to: input["to"], context: input["context"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      inbox: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox/${encodeURIComponent(input.inboxID)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions),
+        update: (input, requestOptions) => request({
+          method: "PATCH",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox/${encodeURIComponent(input.inboxID)}`,
+          body: { delivery: input["delivery"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions)
+      },
+      instructions: {
+        entry: {
+          list: (input, requestOptions) => request({
+            method: "GET",
+            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/instructions/entries`,
+            successStatus: 200,
+            declaredStatuses: [400, 401, 404],
+            empty: false
+          }, requestOptions).then((value) => value.data),
+          put: (input, requestOptions) => request({
+            method: "PUT",
+            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
+            body: { value: input["value"] },
+            successStatus: 204,
+            declaredStatuses: [400, 401, 404, 413],
+            empty: true
+          }, requestOptions),
+          remove: (input, requestOptions) => request({
+            method: "DELETE",
+            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
+            successStatus: 204,
+            declaredStatuses: [400, 401, 404],
+            empty: true
+          }, requestOptions)
+        }
+      },
+      generate: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/generate`,
+        body: { prompt: input["prompt"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      log: (input, requestOptions) => sse({
+        method: "GET",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/log`,
+        query: { after: input["after"], follow: input["follow"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      interrupt: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
+        query: { resume: input["resume"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      background: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/background`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      message: {
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data)
+      },
+      form: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        create: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
+          body: { id: input["id"], title: input["title"], metadata: input["metadata"], fields: input["fields"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        reply: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/reply`,
+          body: { answer: input["answer"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions)
+      },
+      environment: (input, requestOptions) => request({
+        method: "PUT",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/environment`,
+        body: { variables: input["variables"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      view: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/view`,
+        body: { idle: input["idle"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    message: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
+        query: { limit: input["limit"], order: input["order"], cursor: input["cursor"], type: input["type"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions)
+    },
+    model: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/model`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions),
+      default: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/model/default`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions)
+    },
+    generate: {
+      text: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/generate`,
+        body: { prompt: input["prompt"], model: input["model"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions).then((value) => value.data)
+    },
+    provider: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/provider`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/provider/${encodeURIComponent(input.providerID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions)
+    },
+    integration: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/integration`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/integration/${encodeURIComponent(input.integrationID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      wellknown: {
+        add: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/integration/wellknown`,
+          query: { location: input["location"] },
+          body: { url: input["url"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401],
+          empty: true
+        }, requestOptions)
+      },
+      connect: {
+        key: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
+          query: { location: input["location"] },
+          body: { key: input["key"], answer: input["answer"], label: input["label"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      oauth: {
+        connect: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth`,
+          query: { location: input["location"] },
+          body: { methodID: input["methodID"], answer: input["answer"], label: input["label"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions),
+        status: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        complete: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}/complete`,
+          query: { location: input["location"] },
+          body: { code: input["code"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401],
+          empty: true
+        }, requestOptions)
+      },
+      command: {
+        connect: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command`,
+          query: { location: input["location"] },
+          body: { methodID: input["methodID"], label: input["label"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        status: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401],
+          empty: true
+        }, requestOptions)
+      }
+    },
+    mcp: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/mcp`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      add: (input, requestOptions) => request({
+        method: "PUT",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}`,
+        query: { location: input["location"] },
+        body: { config: input["config"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      connect: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}/connect`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      disconnect: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}/disconnect`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      resource: {
+        catalog: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/mcp/resource`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    credential: {
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+        body: { label: input["label"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions),
+      activate: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/credential/${encodeURIComponent(input.credentialID)}/activate`,
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions)
+    },
+    project: {
+      list: (requestOptions) => request({ method: "GET", path: `/api/project`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/project/${encodeURIComponent(input.projectID)}`,
+        body: {
+          canonical: input["canonical"],
+          name: input["name"],
+          icon: input["icon"],
+          commands: input["commands"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    form: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/form`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions)
+    },
+    permission: {
+      request: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/request`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions)
+      },
+      saved: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/saved`,
+          query: { projectID: input?.["projectID"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        remove: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401],
+          empty: true
+        }, requestOptions)
+      },
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+        body: {
+          id: input["id"],
+          action: input["action"],
+          resources: input["resources"],
+          save: input["save"],
+          metadata: input["metadata"],
+          source: input["source"],
+          agent: input["agent"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      reply: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}/reply`,
+        body: { decision: input["decision"], message: input["message"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    file: {
+      read: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/fs/read/${encodePath(input.path)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false,
+        binary: true
+      }, requestOptions),
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/fs/list`,
+        query: { location: input?.["location"], path: input?.["path"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      find: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/fs/find`,
+        query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      write: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/fs/write`,
+        query: { location: input["location"], path: input["path"] },
+        body: input["payload"],
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false,
+        binaryBody: true
+      }, requestOptions)
+    },
+    command: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/command`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions)
+    },
+    skill: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/skill`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions)
+    },
+    rpc: {
+      call: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/rpc/${encodeURIComponent(input.rpcID)}/${encodeURIComponent(input.method)}`,
+        query: { location: input["location"] },
+        body: { input: input["input"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 500],
+        empty: false
+      }, requestOptions)
+    },
+    event: {
+      subscribe: (requestOptions) => sse({ method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions)
+    },
+    pty: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/pty`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/pty`,
+        query: { location: input?.["location"] },
+        body: {
+          command: input?.["command"],
+          args: input?.["args"],
+          cwd: input?.["cwd"],
+          title: input?.["title"],
+          env: input?.["env"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PUT",
+        path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+        query: { location: input["location"] },
+        body: { title: input["title"], size: input["size"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      connect: {
+        token: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/pty/${encodeURIComponent(input.ptyID)}/connect-token`,
+          query: { location: input["location"] },
+          headers: { "x-opencode-ticket": input["x-opencode-ticket"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    experimental: {
+      persistentPty: {
+        read: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal/read`,
+          query: { lines: input["lines"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        create: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal`,
+          body: {
+            command: input["command"],
+            args: input["args"],
+            cwd: input["cwd"],
+            title: input["title"],
+            env: input["env"],
+            size: input["size"]
+          },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        shutdown: (requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/persistent-pty/shutdown`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 503],
+          empty: true
+        }, requestOptions),
+        handoff: (requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/persistent-pty/handoff`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions),
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        update: (input, requestOptions) => request({
+          method: "PUT",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+          body: { attachmentID: input["attachmentID"], size: input["size"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        snapshot: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/snapshot`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        remove: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: true
+        }, requestOptions),
+        connectToken: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/connect-token`,
+          headers: { "x-opencode-ticket": input["x-opencode-ticket"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data)
+      }
+    },
+    shell: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/shell`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/shell`,
+        query: { location: input["location"] },
+        body: {
+          command: input["command"],
+          cwd: input["cwd"],
+          timeout: input["timeout"],
+          metadata: input["metadata"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/shell/${encodeURIComponent(input.id)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      output: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/shell/${encodeURIComponent(input.id)}/output`,
+        query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/shell/${encodeURIComponent(input.id)}`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions)
+    },
+    reference: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/reference`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions)
+    },
+    worktree: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/worktree`,
+        query: { projectID: input["projectID"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/worktree`,
+        body: {
+          projectID: input["projectID"],
+          from: input["from"],
+          branch: input["branch"],
+          directory: input["directory"],
+          name: input["name"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/worktree`,
+        body: { projectID: input["projectID"], directory: input["directory"], force: input["force"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      refresh: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/worktree/refresh`,
+        body: { projectID: input["projectID"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    vcs: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      base: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/base`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions),
+      status: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/status`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      branch: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/vcs/branch`,
+          query: { location: input?.["location"], search: input?.["search"], limit: input?.["limit"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions)
+      },
+      diff: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/diff`,
+        query: { location: input["location"], mode: input["mode"], base: input["base"], context: input["context"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions)
+    },
+    debug: {
+      location: {
+        list: (requestOptions) => request({
+          method: "GET",
+          path: `/api/debug/location`,
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions),
+        evict: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/debug/location`,
+          query: { location: input?.["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401],
+          empty: true
+        }, requestOptions)
+      }
+    },
+    migration: {
+      v1: {
+        status: (requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/migration/v1`,
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    websearch: {
+      providers: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/websearch/provider`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions),
+      query: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/websearch`,
+        query: { location: input["location"] },
+        body: { query: input["query"], providerID: input["providerID"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions)
+    },
+    config: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/config`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      shells: (requestOptions) => request({ method: "GET", path: `/api/config/shell`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/experimental/config`,
+        body: { shell: input["shell"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions)
+    }
+  };
+}
+function encodePath(value) {
+  return value.split("/").map(encodeURIComponent).join("/");
+}
+function appendQuery(params, key, value) {
+  if (value === void 0)
+    return;
+  if (value === null) {
+    params.append(key, "null");
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      appendQuery(params, key, item);
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [child, item] of Object.entries(value))
+      appendQuery(params, `${key}[${child}]`, item);
+    return;
+  }
+  params.append(key, String(value));
+}
+async function json2(response) {
+  if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
+    try {
+      await response.body?.cancel();
+    } catch {
+    }
+    throw new ClientError3("UnsupportedContentType", { detail: response.headers.get("content-type") });
+  }
+  let text;
+  try {
+    text = await response.text();
+  } catch (cause) {
+    throw new ClientError3("Transport", { cause });
+  }
+  if (text === "")
+    throw new ClientError3("MalformedResponse");
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    throw new ClientError3("MalformedResponse", { cause });
+  }
+}
+function declared(body) {
+  const error51 = Object.assign(new Error(body.message ?? body.data?.message), body);
+  if (body._tag)
+    error51.name = body._tag;
+  return error51;
+}
+function isContentType(response, expected) {
+  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected;
+}
+
+// ../../../node_modules/@opencode/client/dist/chunks/service-timing-4tveyqeh.js
+var isRpcError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "RpcError";
+var isRpcInternalError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "RpcInternalError";
+
+// ../../../node_modules/@opencode/client/dist/chunks/service-timing-1tbj6z39.js
+function makeRpc2(raw, events) {
+  return (definition) => {
+    const subscribe = (name, options) => {
+      if (!Object.hasOwn(definition.events, name))
+        throw new Error(`Unknown RPC event: ${definition.id}.${name}`);
+      const type = eventType(definition, name);
+      return {
+        [Symbol.asyncIterator]() {
+          const controller = new AbortController();
+          const signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const iterator = (async function* () {
+            try {
+              for await (const published of events.subscribe({ signal })) {
+                if (signal.aborted)
+                  return;
+                if (published.type !== type)
+                  continue;
+                yield published;
+              }
+            } catch (error51) {
+              if (!signal.aborted)
+                throw error51;
+            } finally {
+              controller.abort();
+            }
+          })();
+          return {
+            next: () => iterator.next(),
+            return: () => {
+              controller.abort();
+              return iterator.return();
+            }
+          };
+        }
+      };
+    };
+    return Object.assign(Object.fromEntries(Object.keys(definition.methods).map((name) => [
+      name,
+      async (input, options) => {
+        try {
+          const result = await raw.rpc.call({
+            rpcID: definition.id,
+            method: name,
+            input,
+            location: options?.location
+          }, { signal: options?.signal, headers: options?.headers });
+          return result.output;
+        } catch (error51) {
+          if (!isRpcError2(error51) && !isRpcInternalError2(error51))
+            throw error51;
+          throw error51.data === void 0 ? { type: error51.type, message: error51.message } : { type: error51.type, message: error51.message, data: error51.data };
+        }
+      }
+    ])), {
+      events: {
+        subscribe,
+        on: (name, handler, options) => {
+          const controller = new AbortController();
+          const signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const source = subscribe(name, { signal });
+          (async () => {
+            for await (const event of source)
+              await handler(event);
+          })().catch((error51) => console.error(error51));
+          return () => controller.abort();
+        }
+      }
+    });
+  };
+}
+function eventType(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+
+// ../../../node_modules/@opencode/client/dist/chunks/service-timing-2twkm0vy.js
+var exports_client3 = {};
+__export2(exports_client3, {
+  OpenCode: () => exports_client3,
+  make: () => make5
+});
+function make5(options) {
+  const raw = make6(options);
+  const events = make7((signal, onActivity) => raw.event.subscribe({ signal, onActivity }));
+  return {
+    ...raw,
+    rpc: Object.assign(makeRpc2(raw, events), raw.rpc),
+    event: events
+  };
+}
+
+// dist/v2/connection.js
+var V2Connection = class {
+  options;
+  cwd;
+  #child;
+  #starting;
+  #closing;
+  #abort = new AbortController();
+  #stderr = "";
+  constructor(options, cwd) {
+    this.options = options;
+    this.cwd = cwd;
+  }
+  get stderrTail() {
+    return this.#stderr;
+  }
+  client() {
+    if (this.#closing)
+      return Promise.reject(new Error("OpenCode v2 connection is closed"));
+    return this.#starting ??= this.#start();
+  }
+  async #start() {
+    const password = randomBytes2(32).toString("base64url");
+    const env = {
+      ...this.options.environment ?? process.env,
+      OPENCODE_PASSWORD: password,
+      OPENCODE_SERVER_PASSWORD: password
+    };
+    const executable = resolveOpenCodeExecutable({
+      ...this.options.command ? { command: this.options.command } : {},
+      environment: env
+    });
+    const invocation = openCodeServerInvocation(executable, env);
+    const child = spawn2(invocation.command, invocation.arguments, {
+      env,
+      cwd: this.cwd,
+      stdio: "pipe",
+      detached: process.platform !== "win32",
+      windowsHide: true,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
+    });
+    this.#child = child;
+    child.stderr.on("data", (chunk) => {
+      this.#stderr = sanitizeDiagnosticTail(this.#stderr + chunk.toString());
+    });
+    try {
+      const baseUrl = await new Promise((resolve, reject) => {
+        let output = "";
+        const timer = setTimeout(() => finish(new Error("OpenCode v2 server startup timed out")), this.options.startupTimeoutMs ?? 2e4);
+        const abort = () => finish(new Error("OpenCode v2 connection closed during startup"));
+        const finish = (error51, url2) => {
+          clearTimeout(timer);
+          this.#abort.signal.removeEventListener("abort", abort);
+          if (error51)
+            reject(error51);
+          else if (url2)
+            resolve(url2);
+        };
+        this.#abort.signal.addEventListener("abort", abort, { once: true });
+        child.once("error", (error51) => finish(error51));
+        child.once("exit", (code, signal) => finish(new Error(`OpenCode v2 server exited (${signal ?? code})`)));
+        child.stdout.on("data", (chunk) => {
+          output += chunk.toString();
+          const lines = output.split(/\r?\n/u);
+          output = (lines.pop() ?? "").slice(-8192);
+          for (const line of lines) {
+            const url2 = /^server listening on (http:\/\/127\.0\.0\.1:\d+)\s*$/u.exec(line)?.[1];
+            if (url2)
+              finish(void 0, url2);
+          }
+        });
+      });
+      const client2 = exports_client3.make({
+        baseUrl,
+        headers: {
+          Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`
+        },
+        fetch: (request, init) => {
+          const signal = AbortSignal.any([
+            this.#abort.signal,
+            ...init?.signal ? [init.signal] : [],
+            // Event streams keep their caller-owned lifetime; ordinary requests are bounded.
+            ...(request instanceof Request ? request.url : String(request)).includes("/event") ? [] : [AbortSignal.timeout(this.options.commandTimeoutMs ?? 2e4)]
+          ]);
+          return fetch(request, { ...init, signal });
+        }
+      });
+      const info = await client2.server.info();
+      if (!/^2\./u.test(info.version))
+        throw new Error(`Expected OpenCode v2 server, received ${info.version}`);
+      return client2;
+    } catch (error51) {
+      await this.#stop();
+      throw error51;
+    }
+  }
+  close() {
+    return this.#closing ??= (async () => {
+      this.#abort.abort();
+      await this.#stop();
+      await this.#starting?.catch(() => void 0);
+    })();
+  }
+  async #stop() {
+    const child = this.#child;
+    if (!child?.pid)
+      return;
+    const pid = child.pid;
+    const kill = (signal) => {
+      try {
+        if (process.platform === "win32")
+          spawnSync2("taskkill.exe", ["/pid", String(child.pid), "/t", "/f"], {
+            windowsHide: true,
+            stdio: "ignore"
+          });
+        else
+          process.kill(-pid, signal);
+      } catch {
+      }
+    };
+    if (child.exitCode === null && child.signalCode === null) {
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          kill("SIGKILL");
+          resolve();
+        }, this.options.closeTimeoutMs ?? 3e3);
+        child.once("exit", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+        kill("SIGTERM");
+      });
+    }
+    if (this.#child === child)
+      this.#child = void 0;
+  }
+};
+
+// dist/v2/history.js
+import path10 from "node:path";
+async function readMessages(client2, sessionID) {
+  const messages = [];
+  let cursor;
+  const seen = /* @__PURE__ */ new Set();
+  do {
+    const page = await client2.message.list({
+      sessionID,
+      ...cursor ? { cursor } : { order: "asc", limit: 100 }
+    });
+    messages.push(...page.data);
+    cursor = page.cursor.next ?? void 0;
+    if (cursor && seen.has(cursor))
+      throw new Error("OpenCode v2 transcript pagination did not advance");
+    if (cursor)
+      seen.add(cursor);
+  } while (cursor);
+  return messages;
+}
+var contentId = (messageID, index) => hostItemIdSchema.parse(`${messageID}:${index}`);
+function assistantItems2(message, limit) {
+  return message.content.map((part, index) => {
+    const itemId2 = contentId(message.id, index);
+    if (part.type === "text" || part.type === "reasoning") {
+      return {
+        item: {
+          type: part.type === "text" ? "agentMessage" : "reasoning",
+          itemId: itemId2,
+          text: part.text
+        },
+        outcome: message.error ? { status: "failed", error: failure(message.error.message) } : { status: "succeeded" }
+      };
+    }
+    const state = part.state;
+    const text = "content" in state ? state.content?.map((p) => p.type === "text" ? p.text : `[File: ${p.uri}]`).join("\n") : void 0;
+    return {
+      item: {
+        type: "toolExecution",
+        itemId: itemId2,
+        toolName: part.name,
+        namespace: "opencode",
+        arguments: typeof state.input === "string" ? state.input : state.input,
+        ...text ? {
+          output: {
+            content: [{ type: "text", text: text.slice(0, limit) }],
+            ...text.length > limit ? { truncated: true } : {}
+          }
+        } : {}
+      },
+      outcome: state.status === "error" ? { status: "failed", error: failure(state.error.message) } : state.status === "completed" ? { status: "succeeded" } : { status: "cancelled", reason: "Native Tool did not complete" }
+    };
+  });
+}
+function projectHistory(session, messages, limit) {
+  if (session.revert)
+    throw new Error("Clear the staged OpenCode v2 revert before using this Session in codexhost");
+  const turns = [];
+  let turn;
+  for (const message of messages) {
+    if (message.type === "user" && turn) {
+      turn.input.push({ type: "text", text: message.text });
+    } else if (message.type === "user" || message.type === "compaction" && message.reason === "manual" && !turn) {
+      turn = {
+        nativeTurnRef: nativeTurnRefSchema.parse({
+          harnessId,
+          nativeSessionId: session.id,
+          nativeTurnKey: message.id,
+          formatVersion: 1
+        }),
+        input: message.type === "user" ? [{ type: "text", text: message.text }] : [],
+        items: [],
+        outcome: { status: "unknown", reason: "OpenCode execution has no durable terminal" },
+        startedAtMs: message.time.created
+      };
+      turns.push(turn);
+    }
+    if (!turn)
+      continue;
+    if (message.type === "assistant") {
+      turn.items.push(...assistantItems2(message, limit));
+      turn.model = encodeOpenCodeModelRef({
+        providerID: message.model.providerID,
+        modelID: message.model.id
+      });
+    } else if (message.type === "compaction") {
+      turn.items.push({
+        item: { type: "contextCompaction", itemId: hostItemIdSchema.parse(message.id) },
+        outcome: message.status === "failed" ? { status: "failed", error: failure(message.error.message) } : message.status === "completed" ? { status: "succeeded" } : { status: "cancelled", reason: "Compaction is incomplete" }
+      });
+    } else if (message.type === "shell") {
+      turn.items.push({
+        item: {
+          type: "commandExecution",
+          itemId: hostItemIdSchema.parse(message.id),
+          command: message.command,
+          ...message.output ? {
+            output: message.output.output.slice(0, limit),
+            outputTruncated: message.output.truncated || message.output.output.length > limit
+          } : {},
+          ...typeof message.exit === "number" ? { exitCode: message.exit } : {}
+        },
+        outcome: message.status === "killed" ? { status: "cancelled" } : message.exit === 0 ? { status: "succeeded" } : {
+          status: "failed",
+          error: failure(`Shell ${message.status}, exit ${message.exit ?? "unknown"}`)
+        }
+      });
+    } else if (message.type === "idle") {
+      turn.outcome = message.outcome === "interrupted" ? { status: "cancelled" } : message.outcome === "failed" ? { status: "failed", error: failure("OpenCode v2 execution failed") } : { status: "succeeded" };
+      turn.completedAtMs = message.time.created;
+      turn.checkpoint = nativeCheckpointRefSchema.parse({
+        harnessId,
+        nativeSessionId: session.id,
+        checkpointId: message.id,
+        locator: { protocol: 2, userMessageID: turn.nativeTurnRef.nativeTurnKey },
+        formatVersion: 1
+      });
+      turn = void 0;
+    }
+  }
+  return { turns };
+}
+function fileChanges(session, turn, diffs) {
+  if (!diffs.length)
+    return void 0;
+  const changes = diffs.map((diff) => {
+    const absolute = path10.resolve(session.location.directory, diff.file);
+    const relative = path10.relative(session.location.directory, absolute);
+    if (relative.startsWith(`..${path10.sep}`) || relative === ".." || path10.isAbsolute(relative))
+      throw new Error("OpenCode v2 diff escaped the Session directory");
+    return {
+      path: absolute,
+      kind: diff.status === "added" ? "add" : diff.status === "deleted" ? "delete" : "update",
+      unifiedDiff: diff.patch
+    };
+  });
+  return {
+    item: {
+      type: "fileChange",
+      itemId: hostItemIdSchema.parse(`${turn.nativeTurnRef.nativeTurnKey}:diff`),
+      changes
+    },
+    outcome: { status: "succeeded" }
+  };
+}
+async function readHistory(client2, session, limit) {
+  const messages = await readMessages(client2, session.id);
+  const snapshot = projectHistory(session, messages, limit);
+  for (const turn of snapshot.turns) {
+    if (!turn.checkpoint)
+      continue;
+    const first = messages.findIndex((m) => m.id === turn.nativeTurnRef.nativeTurnKey);
+    const last = messages.findIndex((m) => m.id === turn.checkpoint?.checkpointId);
+    if (!messages.slice(first, last).some((m) => m.type === "assistant" && m.snapshot?.files?.length))
+      continue;
+    const diffs = await client2.session.diff({
+      sessionID: session.id,
+      from: turn.nativeTurnRef.nativeTurnKey
+    });
+    const item = fileChanges(session, turn, diffs);
+    if (item)
+      turn.items.push(item);
+  }
+  return { messages, snapshot };
+}
+function terminalItemOutcome(outcome) {
+  return outcome.status === "unknown" ? { status: "failed", error: failure(outcome.reason, "protocolError") } : outcome;
+}
+
+// dist/v2/interactions.js
+function permissionInteraction(request, turnId) {
+  return {
+    request,
+    interaction: {
+      type: "approval",
+      interactionId: hostInteractionIdSchema.parse(`oc2-permission:${request.id}`),
+      turnId,
+      title: request.action,
+      description: request.message ?? request.resources.join("\n"),
+      subject: { type: "nativeAction" },
+      actions: [
+        { id: "once", label: "Allow once", effect: "allowOnce" },
+        { id: "reject", label: "Deny", effect: "deny" }
+      ]
+    }
+  };
+}
+function formInteraction(form, turnId) {
+  const questions = form.fields.map((field) => {
+    if (field.type === "external" || field.hidden || field.when?.length) {
+      throw new Error("OpenCode v2 external, hidden or conditional form fields require its native UI");
+    }
+    const base = {
+      id: field.key,
+      prompt: [field.title, field.description].filter(Boolean).join("\n") || field.key,
+      optional: !field.required
+    };
+    if (field.type === "boolean")
+      return {
+        ...base,
+        type: "choice",
+        multiple: false,
+        allowOther: false,
+        options: [
+          { value: "true", label: "Yes" },
+          { value: "false", label: "No" }
+        ]
+      };
+    if (field.type === "multiselect" || field.type === "string" && field.options?.length) {
+      return {
+        ...base,
+        type: "choice",
+        multiple: field.type === "multiselect",
+        allowOther: field.custom ?? false,
+        options: field.options ?? []
+      };
+    }
+    return {
+      ...base,
+      type: "text",
+      multiline: field.type === "string",
+      secret: false,
+      ...field.type === "string" && field.placeholder ? { placeholder: field.placeholder } : {},
+      ...field.default !== void 0 ? { prefill: String(field.default) } : {}
+    };
+  });
+  return {
+    form,
+    interaction: {
+      type: "question",
+      interactionId: hostInteractionIdSchema.parse(`oc2-form:${form.id}`),
+      turnId,
+      title: form.title,
+      questions
+    }
+  };
+}
+async function replyInteraction(client2, pending, command) {
+  if (pending.interaction.type === "approval" && pending.request) {
+    if (command.response.type !== "approval")
+      throw new Error("Expected OpenCode approval decision");
+    const validation2 = validateHostApprovalResponse(pending.interaction, command.response);
+    if (validation2)
+      throw new Error(validation2.message);
+    if (command.response.type !== "approval" || !["once", "reject"].includes(command.response.actionId))
+      throw new Error("Invalid OpenCode approval decision");
+    await client2.permission.reply({
+      sessionID: pending.request.sessionID,
+      requestID: pending.request.id,
+      decision: command.response.actionId === "once" ? "once" : "reject"
+    });
+    return;
+  }
+  if (pending.interaction.type !== "question" || !pending.form)
+    throw new Error("Invalid OpenCode interaction");
+  if (command.response.type !== "question")
+    throw new Error("Expected OpenCode form answer");
+  const validation = validateHostQuestionResponse(pending.interaction, command.response);
+  if (validation)
+    throw new Error(validation.message);
+  const form = pending.form;
+  if (command.response.cancelled) {
+    await client2.session.form.cancel({ sessionID: form.sessionID, formID: form.id });
+    return;
+  }
+  const answer = {};
+  for (const field of form.fields) {
+    const values = command.response.answers[field.key] ?? [];
+    if (!values.length)
+      continue;
+    const value = values[0];
+    if (value === void 0)
+      continue;
+    if (field.type === "multiselect")
+      answer[field.key] = values;
+    else if (field.type === "boolean")
+      answer[field.key] = value === "true";
+    else if (field.type === "number" || field.type === "integer") {
+      const number4 = Number(value);
+      if (!value.trim() || !Number.isFinite(number4) || field.type === "integer" && !Number.isInteger(number4))
+        throw new Error(`Invalid number for ${field.key}`);
+      answer[field.key] = number4;
+    } else
+      answer[field.key] = value;
+  }
+  await client2.session.form.reply({ sessionID: form.sessionID, formID: form.id, answer });
+}
+
+// dist/v2/session.js
+function v2Capabilities(catalog) {
+  return {
+    configuration: {
+      selectModel: catalog.models.length > 0,
+      selectThinkingOption: catalog.thinkingOptions.length > 1,
+      selectPermissionMode: true,
+      permissionModeScope: "live"
+    },
+    history: { fork: true, forkAcrossCwd: false, rollbackLastTurn: true }
+  };
+}
+var V2Session = class {
+  client;
+  connection;
+  info;
+  catalog;
+  policy;
+  limit;
+  onClosed;
+  harnessId = harnessId;
+  capabilities;
+  initialState;
+  initialUsage;
+  commands;
+  #channel = new HarnessOutputChannel();
+  outputs = this.#channel.outputs;
+  #abort = new AbortController();
+  #active;
+  #closed = false;
+  #closePromise;
+  #pump;
+  #reconciling;
+  #timer;
+  #configuring = false;
+  constructor(client2, connection, info, catalog, policy, limit, onClosed) {
+    this.client = client2;
+    this.connection = connection;
+    this.info = info;
+    this.catalog = catalog;
+    this.policy = policy;
+    this.limit = limit;
+    this.onClosed = onClosed;
+    this.initialState = v2State(info, catalog, policy);
+    this.initialUsage = v2Usage(info);
+    this.capabilities = v2Capabilities(catalog);
+    this.commands = {
+      list: async () => ({ ok: true, value: openCodeCommandCatalog }),
+      execute: async (command) => {
+        if (command.commandId !== "opencode.compact" || Object.keys(command.arguments ?? {}).length)
+          return { ok: false, error: failure("Unsupported OpenCode command", "unsupported") };
+        return this.#start({ type: "turn.start", turnId: command.turnId, input: [] }, true);
+      }
+    };
+  }
+  async start() {
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("OpenCode v2 event subscription timed out")), this.connection.options.startupTimeoutMs ?? 2e4);
+      this.#pump = (async () => {
+        try {
+          for await (const event of this.client.event.subscribe({ signal: this.#abort.signal })) {
+            if (this.#abort.signal.aborted)
+              break;
+            if (event.type === "server.connected") {
+              clearTimeout(timer);
+              resolve();
+            }
+            this.#onEvent(event);
+          }
+          if (!this.#abort.signal.aborted)
+            throw new Error("OpenCode v2 event stream disconnected");
+        } catch (error51) {
+          clearTimeout(timer);
+          reject(error51);
+          if (!this.#closed)
+            await this.#fault(failure(error51 instanceof Error ? error51.message : String(error51), "processExited"));
+        }
+      })();
+    });
+    this.#timer = setInterval(() => {
+      void this.#refresh();
+    }, 400);
+  }
+  async readSnapshot() {
+    if (this.#closed)
+      return { ok: false, error: failure("OpenCode Session is closed", "invalidState") };
+    if (this.#active || this.#configuring)
+      return { ok: false, error: failure("OpenCode Session is busy", "sessionBusy") };
+    try {
+      this.info = await this.client.session.get({ sessionID: this.info.id });
+      const { snapshot } = await readHistory(this.client, this.info, this.limit);
+      return {
+        ok: true,
+        value: { ...snapshot, state: v2State(this.info, this.catalog, this.policy) }
+      };
+    } catch (error51) {
+      return errorResult(error51);
+    }
+  }
+  async execute(command) {
+    if (this.#closed)
+      return { ok: false, error: failure("OpenCode Session is closed", "invalidState") };
+    if (command.type === "turn.start")
+      return this.#start(command, false);
+    if (command.type === "turn.cancel") {
+      const active = this.#active;
+      if (!active?.admitted || active.turnId !== command.turnId)
+        return { ok: false, error: failure("No matching OpenCode Turn", "invalidState") };
+      try {
+        await this.client.session.interrupt({ sessionID: this.info.id, resume: false });
+        await this.#refresh();
+        return { ok: true, value: { cancellationRequested: true } };
+      } catch (error51) {
+        return errorResult(error51);
+      }
+    }
+    if (command.type === "interaction.respond") {
+      const active = this.#active;
+      const pending = active?.interactions.get(command.interactionId);
+      if (!active || !pending || active.replying.has(command.interactionId))
+        return {
+          ok: false,
+          error: failure("OpenCode interaction is no longer pending", "invalidState")
+        };
+      active.replying.add(command.interactionId);
+      try {
+        await replyInteraction(this.client, pending, command);
+        this.#closeInteraction(active, command.interactionId, command.response.type === "question" && command.response.cancelled ? "cancelled" : "responded");
+        return { ok: true, value: { accepted: true } };
+      } catch (error51) {
+        return errorResult(error51);
+      } finally {
+        active.replying.delete(command.interactionId);
+      }
+    }
+    if (this.#active || this.#configuring)
+      return { ok: false, error: failure("OpenCode Session is busy", "sessionBusy") };
+    this.#configuring = true;
+    try {
+      if ((await this.client.session.active())[this.info.id])
+        throw new Error("OpenCode Session is running");
+      if (command.type === "permissionMode.select") {
+        await this.client.session.update({
+          sessionID: this.info.id,
+          permissions: v2Permissions(this.info.permissions, command.permissionModeId)
+        });
+      } else {
+        let model = this.info.model;
+        if (command.type === "model.select") {
+          if (!this.catalog.models.some((m) => m.ref.id === command.model.id))
+            throw new Error("OpenCode Model is not available");
+          const decoded = decodeOpenCodeModelRef(command.model);
+          model = { providerID: decoded.providerID, id: decoded.modelID };
+        } else {
+          if (!model)
+            throw new Error("Select a Model before a Thinking option");
+          const state = v2State(this.info, this.catalog, this.policy);
+          if (!state.availableThinkingOptions?.some((v) => v.id === command.thinkingOptionId))
+            throw new Error("Thinking option is unavailable for this Model");
+          const variant = decodeOpenCodeVariant(command.thinkingOptionId);
+          model = { providerID: model.providerID, id: model.id, ...variant ? { variant } : {} };
+        }
+        await this.client.session.switchModel({ sessionID: this.info.id, model });
+      }
+      this.info = await this.client.session.get({ sessionID: this.info.id });
+      this.#emit({
+        type: "session.state.changed",
+        state: v2State(this.info, this.catalog, this.policy)
+      });
+      return { ok: true, value: { completed: true } };
+    } catch (error51) {
+      return errorResult(error51);
+    } finally {
+      this.#configuring = false;
+    }
+  }
+  async #start(command, compact) {
+    if (this.#closed || this.#active || this.#configuring)
+      return {
+        ok: false,
+        error: failure("OpenCode Session is closed or busy", this.#closed ? "invalidState" : "sessionBusy")
+      };
+    if (!compact && !command.input.some((p) => p.text.trim()))
+      return { ok: false, error: failure("OpenCode requires text input", "invalidRequest") };
+    let resolve;
+    const done = new Promise((r) => {
+      resolve = r;
+    });
+    const active = {
+      turnId: command.turnId,
+      compact,
+      admitted: false,
+      baseline: /* @__PURE__ */ new Set(),
+      live: /* @__PURE__ */ new Map(),
+      assistants: /* @__PURE__ */ new Set(),
+      transient: /* @__PURE__ */ new Map(),
+      interactions: /* @__PURE__ */ new Map(),
+      replying: /* @__PURE__ */ new Set(),
+      settledInteractions: /* @__PURE__ */ new Set(),
+      done,
+      resolve
+    };
+    this.#active = active;
+    let attempted = false;
+    try {
+      if ((await this.client.session.active())[this.info.id])
+        throw new Error("OpenCode Session is already running");
+      this.info = await this.client.session.get({ sessionID: this.info.id });
+      const before = await readHistory(this.client, this.info, this.limit);
+      if (before.snapshot.turns.some((turn) => turn.outcome.status === "unknown"))
+        throw new Error("OpenCode history contains an incomplete execution");
+      active.baseline = new Set(before.snapshot.turns.map((t) => t.nativeTurnRef.nativeTurnKey));
+      attempted = true;
+      if (compact)
+        await this.client.session.compact({ sessionID: this.info.id });
+      else
+        await this.client.session.prompt({
+          sessionID: this.info.id,
+          text: command.input.map((p) => p.text).join("\n"),
+          delivery: "queue",
+          metadata: { "codexhost.turnId": active.turnId }
+        });
+      if (this.#closed) {
+        await this.client.session.interrupt({ sessionID: this.info.id, resume: false });
+        throw new Error("OpenCode Session closed during admission");
+      }
+      active.admitted = true;
+      this.#emit({ type: "turn.started", turnId: active.turnId });
+      for (const item of active.transient.values())
+        this.#projectItem(active, { item, outcome: { status: "succeeded" } }, false);
+      void this.#refresh();
+      return { ok: true, value: { turnId: active.turnId } };
+    } catch (error51) {
+      if (attempted)
+        await this.client.session.interrupt({ sessionID: this.info.id, resume: false }).catch((interruptError) => this.#fault(errorResult(interruptError).error));
+      if (this.#active === active)
+        this.#active = void 0;
+      active.resolve();
+      return errorResult(error51);
+    }
+  }
+  #onEvent(event) {
+    const active = this.#active;
+    if (!active || !("data" in event) || !("sessionID" in event.data) || event.data.sessionID !== this.info.id)
+      return;
+    if (event.type === "session.step.started")
+      active.assistants.add(event.data.assistantMessageID);
+    if ((event.type === "session.text.delta" || event.type === "session.reasoning.delta") && active.assistants.has(event.data.assistantMessageID)) {
+      const itemId2 = contentId(event.data.assistantMessageID, event.data.ordinal);
+      const type = event.type === "session.text.delta" ? "agentMessage" : "reasoning";
+      const previous = active.transient.get(itemId2);
+      const item = {
+        type,
+        itemId: itemId2,
+        text: (previous?.text ?? "") + event.data.delta
+      };
+      active.transient.set(itemId2, item);
+      if (active.admitted)
+        this.#projectItem(active, { item, outcome: { status: "succeeded" } }, false);
+    }
+    if (!event.type.endsWith(".delta"))
+      void this.#refresh();
+  }
+  #refresh() {
+    if (this.#closed || !this.#active?.admitted)
+      return Promise.resolve();
+    return this.#reconciling ??= this.#reconcile().catch(async (error51) => {
+      await this.#fault(failure(error51 instanceof Error ? error51.message : String(error51), "protocolError"));
+    }).finally(() => {
+      this.#reconciling = void 0;
+    });
+  }
+  async #reconcile() {
+    const active = this.#active;
+    if (!active?.admitted)
+      return;
+    const info = await this.client.session.get({ sessionID: this.info.id });
+    const { snapshot, messages } = await readHistory(this.client, info, this.limit);
+    if (this.#active !== active || this.#closed)
+      return;
+    this.info = info;
+    const turns = snapshot.turns.filter((t) => !active.baseline.has(t.nativeTurnRef.nativeTurnKey));
+    if (turns.length > 1)
+      throw new Error("Concurrent native prompts cannot be assigned to one Host Turn");
+    const turn = turns[0];
+    if (turn) {
+      const prompt = messages.find((message) => message.id === turn.nativeTurnRef.nativeTurnKey);
+      if (active.compact ? turn.input.length !== 0 : prompt?.type !== "user" || prompt.metadata?.["codexhost.turnId"] !== active.turnId || turn.input.length !== 1)
+        throw new Error("Concurrent native input cannot be assigned to this Host Turn");
+      const terminal = turn.outcome.status !== "unknown";
+      for (const item of turn.items)
+        this.#projectItem(active, item, terminal, turn.outcome.status === "cancelled" || turn.outcome.status === "failed");
+      if (terminal) {
+        if ((await this.client.session.active())[info.id])
+          return;
+        if (this.#active === active)
+          this.#finish(active, turn);
+        return;
+      }
+    }
+    const [permissions, forms] = await Promise.all([
+      this.client.permission.list({ sessionID: info.id }),
+      this.client.session.form.list({ sessionID: info.id })
+    ]);
+    if (this.#active !== active || this.#closed)
+      return;
+    const current = /* @__PURE__ */ new Map();
+    for (const request of permissions) {
+      const pending = permissionInteraction(request, active.turnId);
+      current.set(pending.interaction.interactionId, pending);
+    }
+    for (const form of forms) {
+      const pending = formInteraction(form, active.turnId);
+      current.set(pending.interaction.interactionId, pending);
+    }
+    for (const [id, pending] of current)
+      if (!active.interactions.has(id) && !active.settledInteractions.has(id)) {
+        active.interactions.set(id, pending);
+        this.#channel.emit({ kind: "interaction", interaction: pending.interaction });
+      }
+    for (const id of active.interactions.keys())
+      if (!current.has(id) && !active.replying.has(id))
+        this.#closeInteraction(active, id, "expired");
+  }
+  #projectItem(active, snapshot, terminal, interrupted = false) {
+    const item = snapshot.item;
+    const old = active.live.get(item.itemId);
+    if (!old) {
+      active.live.set(item.itemId, item);
+      this.#emit({ type: "item.started", turnId: active.turnId, item });
+      return;
+    }
+    if ((item.type === "agentMessage" || item.type === "reasoning") && "text" in old) {
+      if (old.text.startsWith(item.text) && !terminal)
+        return;
+      if (terminal && interrupted && old.text.startsWith(item.text)) {
+        active.live.set(item.itemId, item);
+        return;
+      }
+      if (!item.text.startsWith(old.text))
+        throw new Error("OpenCode v2 streamed text differs from durable history");
+      const delta = item.text.slice(old.text.length);
+      if (delta)
+        this.#emit({
+          type: "item.updated",
+          turnId: active.turnId,
+          itemId: item.itemId,
+          update: { type: "text.append", text: delta }
+        });
+    } else if (item.type === "toolExecution" && item.output && JSON.stringify(item) !== JSON.stringify(old)) {
+      this.#emit({
+        type: "item.updated",
+        turnId: active.turnId,
+        itemId: item.itemId,
+        update: { type: "output.replace", output: item.output }
+      });
+    }
+    active.live.set(item.itemId, item);
+  }
+  #finish(active, turn) {
+    if (this.#active !== active || turn.outcome.status === "unknown")
+      return;
+    for (const id of active.interactions.keys())
+      this.#closeInteraction(active, id, "cancelled");
+    for (const [id, item] of active.live) {
+      const snapshot = turn.items.find((entry) => entry.item.itemId === id) ?? {
+        item,
+        outcome: terminalItemOutcome(turn.outcome)
+      };
+      this.#emit({ type: "item.completed", turnId: active.turnId, snapshot });
+    }
+    this.#emit({
+      type: "session.state.changed",
+      state: v2State(this.info, this.catalog, this.policy)
+    });
+    this.#emit({
+      type: "session.usage.changed",
+      usage: v2Usage(this.info),
+      observedForTurnId: active.turnId
+    });
+    this.#active = void 0;
+    this.#emit({
+      type: "turn.completed",
+      turnId: active.turnId,
+      nativeTurnRef: turn.nativeTurnRef,
+      outcome: { ...turn.outcome, ...turn.checkpoint ? { checkpoint: turn.checkpoint } : {} }
+    });
+    active.resolve();
+  }
+  #closeInteraction(active, id, reason) {
+    const pending = active.interactions.get(id);
+    if (!pending)
+      return;
+    active.interactions.delete(id);
+    active.settledInteractions.add(id);
+    this.#emit({
+      type: "interaction.closed",
+      interactionId: pending.interaction.interactionId,
+      turnId: active.turnId,
+      reason
+    });
+  }
+  #emit(event) {
+    this.#channel.emit({ kind: "event", event });
+  }
+  async #fault(error51) {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    if (this.#timer)
+      clearInterval(this.#timer);
+    this.#abort.abort();
+    const active = this.#active;
+    if (active?.admitted) {
+      for (const id of active.interactions.keys())
+        this.#closeInteraction(active, id, "cancelled");
+      for (const item of active.live.values())
+        this.#emit({
+          type: "item.completed",
+          turnId: active.turnId,
+          snapshot: { item, outcome: { status: "failed", error: error51 } }
+        });
+      this.#emit({
+        type: "turn.completed",
+        turnId: active.turnId,
+        outcome: { status: "failed", error: error51 }
+      });
+    }
+    this.#active = void 0;
+    active?.resolve();
+    this.#emit({ type: "session.faulted", error: error51 });
+    this.#channel.end();
+    await this.client.session.interrupt({ sessionID: this.info.id, resume: false }).catch(() => void 0);
+    await this.connection.close();
+    this.onClosed();
+  }
+  close() {
+    return this.#closePromise ??= (async () => {
+      const active = this.#active;
+      if (active?.admitted && !this.#closed) {
+        await this.client.session.interrupt({ sessionID: this.info.id, resume: false }).catch(() => void 0);
+        await this.#refresh();
+        if (this.#active) {
+          let timer;
+          await Promise.race([
+            active.done,
+            new Promise((resolve) => {
+              timer = setTimeout(resolve, this.connection.options.closeTimeoutMs ?? 3e3);
+            })
+          ]).finally(() => {
+            if (timer)
+              clearTimeout(timer);
+          });
+        }
+        if (this.#active)
+          await this.#fault(failure("OpenCode Session closed before native completion was confirmed", "processExited"));
+      }
+      this.#closed = true;
+      if (this.#timer)
+        clearInterval(this.#timer);
+      this.#abort.abort();
+      await this.connection.close();
+      await this.#pump;
+      this.#channel.end();
+      this.onClosed();
+    })();
+  }
+};
+
+// dist/v2/adapter.js
+var V2Adapter = class {
+  options;
+  harnessId = harnessId;
+  commandCatalog = openCodeCommandCatalog;
+  #connections = /* @__PURE__ */ new Set();
+  #sessions = /* @__PURE__ */ new Set();
+  #closed = false;
+  constructor(options) {
+    this.options = options;
+  }
+  async #catalog(client2, cwd) {
+    return readCatalog(client2, cwd, this.options.startupTimeoutMs ?? 2e4);
+  }
+  async inspect(input = {}) {
+    const cwd = input.cwd ?? process.cwd();
+    const connection = new V2Connection(this.options, cwd);
+    this.#connections.add(connection);
+    try {
+      if (this.#closed)
+        throw new Error("OpenCode Adapter is closed");
+      const client2 = await connection.client();
+      const catalog = await this.#catalog(client2, cwd);
+      return {
+        status: "ready",
+        catalog,
+        capabilities: v2Capabilities(catalog),
+        permissionModes: OPENCODE_PERMISSION_MODE_CATALOG
+      };
+    } catch (error51) {
+      return {
+        status: "error",
+        error: {
+          ...errorResult(error51).error,
+          ...connection.stderrTail ? { stderrTail: connection.stderrTail } : {}
+        }
+      };
+    } finally {
+      await connection.close();
+      this.#connections.delete(connection);
+    }
+  }
+  async open(input) {
+    try {
+      input = { ...input, cwd: fs6.realpathSync(input.cwd) };
+    } catch (error51) {
+      return errorResult(error51);
+    }
+    const connection = new V2Connection({
+      ...this.options,
+      environment: { ...this.options.environment ?? process.env, ...input.environment }
+    }, input.cwd);
+    this.#connections.add(connection);
+    let created;
+    let client2;
+    try {
+      if (this.#closed)
+        throw new Error("OpenCode Adapter is closed");
+      if (!input.cwd)
+        throw new Error("OpenCode requires a working directory");
+      let policy = input.kind === "create" ? input.executionPolicy ?? "default" : "default";
+      if (input.kind !== "create") {
+        const locator = v2Locator(input.kind === "resume" ? input.nativeRef : input.sourceRef);
+        if (!sameDirectory(locator.directory, input.cwd))
+          throw new Error("OpenCode cannot resume or derive a Session across directories");
+        policy = locator.executionPolicy;
+      }
+      client2 = await connection.client();
+      const catalog = await this.#catalog(client2, input.cwd);
+      let info;
+      if (input.kind === "create") {
+        const model = selectedModel(input, catalog);
+        info = await client2.session.create({
+          location: { directory: input.cwd },
+          ...model ? { model } : {},
+          permissions: v2Permissions([], input.permissionModeId ?? harnessPermissionModeIdSchema.parse(policy === "unattended-full-access" ? "allow" : "default"))
+        });
+        created = info.id;
+      } else {
+        const ref = input.kind === "resume" ? input.nativeRef : input.sourceRef;
+        info = await client2.session.get({ sessionID: ref.nativeSessionId });
+        if (info.id !== ref.nativeSessionId || !sameDirectory(info.location.directory, input.cwd))
+          throw new Error("OpenCode returned a different Native Session or directory");
+        if ((await client2.session.active())[info.id])
+          throw new Error("OpenCode Session is already running");
+        const source = await readHistory(client2, info, this.options.toolOutputLimit ?? 64e3);
+        if (source.snapshot.turns.some((turn) => turn.outcome.status === "unknown"))
+          throw new Error("OpenCode history contains an incomplete execution");
+        if (input.kind !== "resume") {
+          const parent = info;
+          const turns = source.snapshot.turns;
+          let count;
+          if (input.kind === "rollbackLastTurn") {
+            if (!turns.length)
+              throw new Error("OpenCode history is empty");
+            count = turns.length - 1;
+          } else {
+            if (input.checkpoint.harnessId !== harnessId || input.checkpoint.nativeSessionId !== info.id)
+              throw new Error("Checkpoint belongs to another Session");
+            count = turns.findIndex((turn) => turn.checkpoint?.checkpointId === input.checkpoint.checkpointId) + 1;
+            if (!count || JSON.stringify(turns[count - 1]?.checkpoint) !== JSON.stringify(input.checkpoint))
+              throw new Error("OpenCode checkpoint does not match native history");
+          }
+          const before = turns[count]?.nativeTurnRef.nativeTurnKey;
+          info = await client2.session.fork({ sessionID: parent.id, ...before ? { before } : {} });
+          if (info.id === parent.id)
+            throw new Error("OpenCode fork returned its source Session");
+          created = info.id;
+          if (!sameDirectory(info.location.directory, parent.location.directory))
+            throw new Error("OpenCode fork changed directory");
+          await client2.session.update({
+            sessionID: info.id,
+            permissions: parent.permissions ?? []
+          });
+          if (parent.model)
+            await client2.session.switchModel({ sessionID: info.id, model: parent.model });
+          info = await client2.session.get({ sessionID: info.id });
+          const derived = await readHistory(client2, info, this.options.toolOutputLimit ?? 64e3);
+          if (historyContent(derived.snapshot, false) !== historyContent({ turns: turns.slice(0, count) }, false))
+            throw new Error("OpenCode fork did not preserve the exact history prefix");
+          if (!isDeepStrictEqual2(info.permissions ?? [], parent.permissions ?? []) || !isDeepStrictEqual2(info.model, parent.model))
+            throw new Error("OpenCode fork did not preserve the current configuration");
+          const currentParent = await client2.session.get({ sessionID: parent.id });
+          if (!isDeepStrictEqual2(currentParent.model, parent.model) || !isDeepStrictEqual2(currentParent.permissions, parent.permissions) || !sameDirectory(currentParent.location.directory, parent.location.directory))
+            throw new Error("OpenCode source configuration changed during derivation");
+          const unchanged = await readHistory(client2, currentParent, this.options.toolOutputLimit ?? 64e3);
+          if (historyContent(unchanged.snapshot) !== historyContent(source.snapshot))
+            throw new Error("OpenCode source history changed during derivation");
+        }
+      }
+      if (this.#closed)
+        throw new Error("OpenCode Adapter closed during Session open");
+      const session = new V2Session(client2, connection, info, catalog, policy, this.options.toolOutputLimit ?? 64e3, () => {
+        this.#sessions.delete(session);
+        this.#connections.delete(connection);
+      });
+      this.#sessions.add(session);
+      try {
+        await session.start();
+      } catch (error51) {
+        await session.close();
+        throw error51;
+      }
+      return { ok: true, value: session };
+    } catch (error51) {
+      if (created && client2)
+        await client2.session.remove({ sessionID: created }).catch(() => void 0);
+      await connection.close();
+      this.#connections.delete(connection);
+      return errorResult(error51);
+    }
+  }
+  async close() {
+    this.#closed = true;
+    await Promise.all([...this.#sessions].map((session) => session.close()));
+    await Promise.all([...this.#connections].map((connection) => connection.close()));
+    this.#sessions.clear();
+    this.#connections.clear();
+  }
+};
+function selectedModel(input, catalog) {
+  const selected = input.model ?? catalog.defaultModel;
+  if (!selected) {
+    if (input.thinkingOptionId)
+      throw new Error("Thinking selection requires a Model");
+    return void 0;
+  }
+  const entry = catalog.models.find((model2) => model2.ref.id === selected.id);
+  if (!entry)
+    throw new Error("OpenCode Model is not available");
+  if (input.thinkingOptionId && !entry.supportedThinkingOptionIds?.includes(input.thinkingOptionId))
+    throw new Error("OpenCode Thinking option is not available for this Model");
+  const model = decodeOpenCodeModelRef(selected);
+  const variant = input.thinkingOptionId ? decodeOpenCodeVariant(input.thinkingOptionId) : void 0;
+  return { providerID: model.providerID, id: model.modelID, ...variant ? { variant } : {} };
+}
+function historyContent(snapshot, identities = true) {
+  return JSON.stringify(snapshot.turns.map((turn) => ({
+    ...identities ? { key: turn.nativeTurnRef.nativeTurnKey } : {},
+    input: turn.input,
+    model: turn.model,
+    checkpoint: Boolean(turn.checkpoint),
+    items: identities ? turn.items : turn.items.map(({ item, ...rest }) => ({
+      ...rest,
+      item: { ...item, itemId: void 0 }
+    })),
+    outcome: turn.outcome
+  })));
+}
+
+// dist/versioned-adapter.js
+var OpenCodeAdapter2 = class {
+  options;
+  dependencies;
+  harnessId = harnessId;
+  commandCatalog = openCodeCommandCatalog;
+  #adapters = /* @__PURE__ */ new Set();
+  #closed = false;
+  constructor(options = {}, dependencies) {
+    this.options = options;
+    this.dependencies = dependencies;
+  }
+  async #select(environment, input) {
+    if (this.#closed)
+      throw new Error("OpenCode Adapter is closed");
+    const options = {
+      ...this.options,
+      environment: { ...this.options.environment ?? process.env, ...environment }
+    };
+    const detected = this.dependencies ? { executable: options.command, major: 1 } : await detectOpenCode(options);
+    if (this.#closed)
+      throw new Error("OpenCode Adapter closed during version detection");
+    if (input && input.kind !== "create") {
+      const ref = input.kind === "resume" ? input.nativeRef : input.sourceRef;
+      const locator = ref.locator;
+      const nativeMajor = locator && typeof locator === "object" && !Array.isArray(locator) && locator.protocol === 2 ? 2 : 1;
+      if (nativeMajor !== detected.major)
+        throw new Error(`This OpenCode Session requires v${nativeMajor}; selected CLI is v${detected.major}. Select the matching installation with CODEXHOST_OPENCODE_COMMAND. codexhost does not migrate histories.`);
+    }
+    const pinned = { ...options, ...detected.executable ? { command: detected.executable } : {} };
+    const adapter = detected.major === 2 ? new V2Adapter(pinned) : new OpenCodeAdapter(pinned, this.dependencies);
+    this.#adapters.add(adapter);
+    return adapter;
+  }
+  async inspect(input = {}) {
+    let adapter;
+    try {
+      adapter = await this.#select();
+      return await adapter.inspect(input);
+    } catch (error51) {
+      return {
+        status: error51 instanceof OpenCodeExecutableError ? "notInstalled" : "error",
+        error: normalize(error51)
+      };
+    } finally {
+      if (adapter) {
+        await adapter.close();
+        this.#adapters.delete(adapter);
+      }
+    }
+  }
+  async open(input) {
+    let adapter;
+    try {
+      adapter = await this.#select(input.environment, input);
+      const result = await adapter.open(input);
+      if (!result.ok) {
+        await adapter.close();
+        this.#adapters.delete(adapter);
+      }
+      if (result.ok) {
+        const owner = adapter;
+        const close = result.value.close.bind(result.value);
+        result.value.close = async () => {
+          await close();
+          this.#adapters.delete(owner);
+        };
+      }
+      return result;
+    } catch (error51) {
+      if (adapter) {
+        await adapter.close();
+        this.#adapters.delete(adapter);
+      }
+      return { ok: false, error: normalize(error51) };
+    }
+  }
+  async close() {
+    this.#closed = true;
+    await Promise.all([...this.#adapters].map((adapter) => adapter.close()));
+    this.#adapters.clear();
+  }
+};
+function normalize(error51) {
+  return failure(error51 instanceof Error ? error51.message : String(error51), error51 instanceof OpenCodeExecutableError ? "notInstalled" : "unavailable");
+}
+
+// dist/installation.js
+import { realpath as realpath2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path11 from "node:path";
+function createOpenCodeInstallation(environment, command) {
+  let update;
+  return createInstallationManager({
+    async check() {
+      const executable = resolveOpenCodeExecutable({
+        environment,
+        ...command ? { command } : {}
+      });
+      const currentVersion = versionFromOutput(await runInstallationCommand(executable, ["--version"], environment));
+      const npm = await npmInstallation(executable, ["opencode-ai"], environment);
+      let latestVersion;
+      let canUpdate;
+      if (npm) {
+        latestVersion = await npm.latest();
+        canUpdate = npm.canUpdate;
+        update = npm.update;
+      } else {
+        const release = JSON.parse(await fetchInstallationText("https://api.github.com/repos/anomalyco/opencode/releases/latest"));
+        latestVersion = installationVersion(release.tag_name);
+        const home = environment.HOME ?? environment.USERPROFILE ?? homedir3();
+        const standard = path11.join(home, ".opencode", "bin", process.platform === "win32" ? "opencode.exe" : "opencode");
+        canUpdate = process.platform !== "win32" && path11.resolve(executable) === standard && await realpath2(executable) === standard;
+        update = async (version2) => {
+          await runInstallationCommand(executable, ["upgrade", version2, "--method", "curl"], environment, 3e5);
+        };
+      }
+      return {
+        currentVersion,
+        latestVersion,
+        updateAvailable: newerInstallationVersion(currentVersion, latestVersion),
+        canUpdate,
+        ...!canUpdate ? { message: "Use the original package manager to update this OpenCode installation." } : {}
+      };
+    },
+    async update(state) {
+      await update(state.latestVersion);
+    }
+  });
+}
+
+// dist/plugin.js
+var OPENCODE_COMMAND_ENV = "CODEXHOST_OPENCODE_COMMAND";
+function createHarnessAdapter(context) {
+  const environment = { ...context.environment };
+  return Object.assign(new OpenCodeAdapter2({
+    ...environment[OPENCODE_COMMAND_ENV] ? { command: environment[OPENCODE_COMMAND_ENV] } : {},
+    environment
+  }), { installation: createOpenCodeInstallation(environment, environment[OPENCODE_COMMAND_ENV]) });
 }
 export {
   OPENCODE_COMMAND_ENV,