@opentig/cli 0.1.6 → 0.1.8

package/dist/server.mjs

@@ -16,9 +16,6 @@ import { Buffer as Buffer$1 } from "node:buffer";
 import { Transform, getDefaultHighWaterMark, Duplex, Writable, Readable, PassThrough } from "node:stream";
 import { finished } from "node:stream/promises";
 import path$1 from "node:path/win32";
-import require$$0$2 from "child_process";
-import require$$0$1 from "path";
-import require$$0 from "fs";
 import { createServer, isIP } from "node:net";
 import { createServer as createServer$1 } from "node:http";
 import WebSocket, { WebSocketServer } from "ws";
@@ -769,7 +766,7 @@ const handleCommand = (filePath, rawArguments, rawOptions) => {
     verboseInfo
   };
 };
-function pathKey$2(options = {}) {
+function pathKey$1(options = {}) {
   const {
     env = process.env,
     platform: platform2 = process.platform
@@ -798,7 +795,7 @@ function traversePathUp(startPath) {
 }
 const npmRunPath = ({
   cwd = process$3.cwd(),
-  path: pathOption = process$3.env[pathKey$2()],
+  path: pathOption = process$3.env[pathKey$1()],
   preferLocal = true,
   execPath: execPath2 = process$3.execPath,
   addExecPath = true
@@ -830,7 +827,7 @@ const applyExecPath = (result, pathParts, execPath2, cwdPath) => {
 };
 const npmRunPathEnv = ({ env = process$3.env, ...options } = {}) => {
   env = { ...env };
-  const pathName = pathKey$2({ env });
+  const pathName = pathKey$1({ env });
   options.path = env[pathName];
   env[pathName] = npmRunPath(options);
   return env;
@@ -5262,7 +5259,7 @@ if (process.platform === "linux") {
 }
 const processOk = (process2) => !!process2 && typeof process2 === "object" && typeof process2.removeListener === "function" && typeof process2.emit === "function" && typeof process2.reallyExit === "function" && typeof process2.listeners === "function" && typeof process2.kill === "function" && typeof process2.pid === "number" && typeof process2.on === "function";
 const kExitEmitter = /* @__PURE__ */ Symbol.for("signal-exit emitter");
-const global$1 = globalThis;
+const global = globalThis;
 const ObjectDefineProperty = Object.defineProperty.bind(Object);
 class Emitter {
   emitted = {
@@ -5276,10 +5273,10 @@ class Emitter {
   count = 0;
   id = Math.random();
   constructor() {
-    if (global$1[kExitEmitter]) {
-      return global$1[kExitEmitter];
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
     }
-    ObjectDefineProperty(global$1, kExitEmitter, {
+    ObjectDefineProperty(global, kExitEmitter, {
       value: this,
       writable: false,
       enumerable: false,
@@ -7014,26 +7011,30 @@ function cancelled() {
 function processFailed() {
   return new AiOperationError({ code: "AI_PROCESS_FAILED", operation: "ai-process", message: "Could not start the AI tool." });
 }
-const ALLOWED = /* @__PURE__ */ new Set(["codex", "claude", "opencode", "gh"]);
+const ALLOWED = /* @__PURE__ */ new Set(["codex", "claude", "opencode", "grok", "gh"]);
 const ALIASES = {
   codex: ["codex"],
   claude: ["claude"],
-  // OpenCode 2 installs as opencode2 and does not replace OpenCode 1's opencode binary.
+  // Current v2 uses opencode; older distributions also provide opencode2.
   opencode: ["opencode", "opencode2"],
+  grok: ["grok"],
   gh: ["gh"]
 };
 class CliResolver {
   cache = /* @__PURE__ */ new Map();
   async resolve(name, forceRefresh = false) {
-    if (!ALLOWED.has(name)) return null;
-    if (!forceRefresh && this.cache.has(name)) return this.cache.get(name) ?? null;
-    let resolved = null;
+    return (await this.resolveAll(name, forceRefresh))[0] ?? null;
+  }
+  async resolveAll(name, forceRefresh = false) {
+    if (!ALLOWED.has(name)) return [];
+    if (!forceRefresh && this.cache.has(name)) return [...this.cache.get(name)];
+    const resolved = [];
     for (const alias of ALIASES[name] ?? [name]) {
-      resolved = await findOnPath(alias);
-      if (resolved) break;
+      const executable = await findOnPath(alias);
+      if (executable && !resolved.includes(executable)) resolved.push(executable);
     }
     this.cache.set(name, resolved);
-    return resolved;
+    return [...resolved];
   }
 }
 async function findOnPath(name) {
@@ -7286,7 +7287,7 @@ const NUMBER_FORMAT_RANGES = {
   float32: [-34028234663852886e22, 34028234663852886e22],
   float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
 };
-function pick$1(schema, mask) {
+function pick(schema, mask) {
   const currDef = schema._zod.def;
   const checks = currDef.checks;
   const hasChecks = checks && checks.length > 0;
@@ -9098,6 +9099,132 @@ function handleIntersectionResults(result, left, right) {
   result.value = merged.data;
   return result;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!isPlainObject(input)) {
+      payload.issues.push({
+        expected: "record",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    const proms = [];
+    const values = def.keyType._zod.values;
+    if (values) {
+      payload.value = {};
+      const recordKeys = /* @__PURE__ */ new Set();
+      for (const key of values) {
+        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+          recordKeys.add(typeof key === "number" ? key.toString() : key);
+          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+          if (keyResult instanceof Promise) {
+            throw new Error("Async schemas not supported in object keys currently");
+          }
+          if (keyResult.issues.length) {
+            payload.issues.push({
+              code: "invalid_key",
+              origin: "record",
+              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+              input: key,
+              path: [key],
+              inst
+            });
+            continue;
+          }
+          const outKey = keyResult.value;
+          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          if (result instanceof Promise) {
+            proms.push(result.then((result2) => {
+              if (result2.issues.length) {
+                payload.issues.push(...prefixIssues(key, result2.issues));
+              }
+              payload.value[outKey] = result2.value;
+            }));
+          } else {
+            if (result.issues.length) {
+              payload.issues.push(...prefixIssues(key, result.issues));
+            }
+            payload.value[outKey] = result.value;
+          }
+        }
+      }
+      let unrecognized;
+      for (const key in input) {
+        if (!recordKeys.has(key)) {
+          unrecognized = unrecognized ?? [];
+          unrecognized.push(key);
+        }
+      }
+      if (unrecognized && unrecognized.length > 0) {
+        payload.issues.push({
+          code: "unrecognized_keys",
+          input,
+          inst,
+          keys: unrecognized
+        });
+      }
+    } else {
+      payload.value = {};
+      for (const key of Reflect.ownKeys(input)) {
+        if (key === "__proto__")
+          continue;
+        if (!Object.prototype.propertyIsEnumerable.call(input, key))
+          continue;
+        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+        if (keyResult instanceof Promise) {
+          throw new Error("Async schemas not supported in object keys currently");
+        }
+        const checkNumericKey = typeof key === "string" && number$1.test(key) && keyResult.issues.length;
+        if (checkNumericKey) {
+          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+          if (retryResult instanceof Promise) {
+            throw new Error("Async schemas not supported in object keys currently");
+          }
+          if (retryResult.issues.length === 0) {
+            keyResult = retryResult;
+          }
+        }
+        if (keyResult.issues.length) {
+          if (def.mode === "loose") {
+            payload.value[key] = input[key];
+          } else {
+            payload.issues.push({
+              code: "invalid_key",
+              origin: "record",
+              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+              input: key,
+              path: [key],
+              inst
+            });
+          }
+          continue;
+        }
+        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        if (result instanceof Promise) {
+          proms.push(result.then((result2) => {
+            if (result2.issues.length) {
+              payload.issues.push(...prefixIssues(key, result2.issues));
+            }
+            payload.value[keyResult.value] = result2.value;
+          }));
+        } else {
+          if (result.issues.length) {
+            payload.issues.push(...prefixIssues(key, result.issues));
+          }
+          payload.value[keyResult.value] = result.value;
+        }
+      }
+    }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
+  };
+});
 const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
   $ZodType.init(inst, def);
   const values = getEnumValues(def.entries);
@@ -10304,29 +10431,29 @@ const formatMap = {
   // do not set
 };
 const stringProcessor = (schema, ctx, _json, _params) => {
-  const json = _json;
-  json.type = "string";
+  const json2 = _json;
+  json2.type = "string";
   const { minimum, maximum, format: format2, patterns, contentEncoding } = schema._zod.bag;
   if (typeof minimum === "number")
-    json.minLength = minimum;
+    json2.minLength = minimum;
   if (typeof maximum === "number")
-    json.maxLength = maximum;
+    json2.maxLength = maximum;
   if (format2) {
-    json.format = formatMap[format2] ?? format2;
-    if (json.format === "")
-      delete json.format;
+    json2.format = formatMap[format2] ?? format2;
+    if (json2.format === "")
+      delete json2.format;
     if (format2 === "time") {
-      delete json.format;
+      delete json2.format;
     }
   }
   if (contentEncoding)
-    json.contentEncoding = contentEncoding;
+    json2.contentEncoding = contentEncoding;
   if (patterns && patterns.size > 0) {
     const regexes = [...patterns];
     if (regexes.length === 1)
-      json.pattern = regexes[0].source;
+      json2.pattern = regexes[0].source;
     else if (regexes.length > 1) {
-      json.allOf = [
+      json2.allOf = [
         ...regexes.map((regex) => ({
           ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
           pattern: regex.source
@@ -10336,40 +10463,40 @@ const stringProcessor = (schema, ctx, _json, _params) => {
   }
 };
 const numberProcessor = (schema, ctx, _json, _params) => {
-  const json = _json;
+  const json2 = _json;
   const { minimum, maximum, format: format2, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
   if (typeof format2 === "string" && format2.includes("int"))
-    json.type = "integer";
+    json2.type = "integer";
   else
-    json.type = "number";
+    json2.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) {
-      json.minimum = exclusiveMinimum;
-      json.exclusiveMinimum = true;
+      json2.minimum = exclusiveMinimum;
+      json2.exclusiveMinimum = true;
     } else {
-      json.exclusiveMinimum = exclusiveMinimum;
+      json2.exclusiveMinimum = exclusiveMinimum;
     }
   } else if (typeof minimum === "number") {
-    json.minimum = minimum;
+    json2.minimum = minimum;
   }
   if (exMax) {
     if (legacy) {
-      json.maximum = exclusiveMaximum;
-      json.exclusiveMaximum = true;
+      json2.maximum = exclusiveMaximum;
+      json2.exclusiveMaximum = true;
     } else {
-      json.exclusiveMaximum = exclusiveMaximum;
+      json2.exclusiveMaximum = exclusiveMaximum;
     }
   } else if (typeof maximum === "number") {
-    json.maximum = maximum;
+    json2.maximum = maximum;
   }
   if (typeof multipleOf === "number")
-    json.multipleOf = multipleOf;
+    json2.multipleOf = multipleOf;
 };
-const booleanProcessor = (_schema, _ctx, json, _params) => {
-  json.type = "boolean";
+const booleanProcessor = (_schema, _ctx, json2, _params) => {
+  json2.type = "boolean";
 };
 const bigintProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
@@ -10381,13 +10508,13 @@ const symbolProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Symbols cannot be represented in JSON Schema");
   }
 };
-const nullProcessor = (_schema, ctx, json, _params) => {
+const nullProcessor = (_schema, ctx, json2, _params) => {
   if (ctx.target === "openapi-3.0") {
-    json.type = "string";
-    json.nullable = true;
-    json.enum = [null];
+    json2.type = "string";
+    json2.nullable = true;
+    json2.enum = [null];
   } else {
-    json.type = "null";
+    json2.type = "null";
   }
 };
 const undefinedProcessor = (_schema, ctx, _json, _params) => {
@@ -10400,8 +10527,8 @@ const voidProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Void cannot be represented in JSON Schema");
   }
 };
-const neverProcessor = (_schema, _ctx, json, _params) => {
-  json.not = {};
+const neverProcessor = (_schema, _ctx, json2, _params) => {
+  json2.not = {};
 };
 const anyProcessor = (_schema, _ctx, _json, _params) => {
 };
@@ -10412,16 +10539,16 @@ const dateProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Date cannot be represented in JSON Schema");
   }
 };
-const enumProcessor = (schema, _ctx, json, _params) => {
+const enumProcessor = (schema, _ctx, json2, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.every((v) => typeof v === "number"))
-    json.type = "number";
+    json2.type = "number";
   if (values.every((v) => typeof v === "string"))
-    json.type = "string";
-  json.enum = values;
+    json2.type = "string";
+  json2.enum = values;
 };
-const literalProcessor = (schema, ctx, json, _params) => {
+const literalProcessor = (schema, ctx, json2, _params) => {
   const def = schema._zod.def;
   const vals = [];
   for (const val of def.values) {
@@ -10442,22 +10569,22 @@ const literalProcessor = (schema, ctx, json, _params) => {
   if (vals.length === 0) ;
   else if (vals.length === 1) {
     const val = vals[0];
-    json.type = val === null ? "null" : typeof val;
+    json2.type = val === null ? "null" : typeof val;
     if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
-      json.enum = [val];
+      json2.enum = [val];
     } else {
-      json.const = val;
+      json2.const = val;
     }
   } else {
     if (vals.every((v) => typeof v === "number"))
-      json.type = "number";
+      json2.type = "number";
     if (vals.every((v) => typeof v === "string"))
-      json.type = "string";
+      json2.type = "string";
     if (vals.every((v) => typeof v === "boolean"))
-      json.type = "boolean";
+      json2.type = "boolean";
     if (vals.every((v) => v === null))
-      json.type = "null";
-    json.enum = vals;
+      json2.type = "null";
+    json2.enum = vals;
   }
 };
 const nanProcessor = (_schema, ctx, _json, _params) => {
@@ -10465,16 +10592,16 @@ const nanProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("NaN cannot be represented in JSON Schema");
   }
 };
-const templateLiteralProcessor = (schema, _ctx, json, _params) => {
-  const _json = json;
+const templateLiteralProcessor = (schema, _ctx, json2, _params) => {
+  const _json = json2;
   const pattern = schema._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-const fileProcessor = (schema, _ctx, json, _params) => {
-  const _json = json;
+const fileProcessor = (schema, _ctx, json2, _params) => {
+  const _json = json2;
   const file = {
     type: "string",
     format: "binary",
@@ -10497,8 +10624,8 @@ const fileProcessor = (schema, _ctx, json, _params) => {
     Object.assign(_json, file);
   }
 };
-const successProcessor = (_schema, _ctx, json, _params) => {
-  json.type = "boolean";
+const successProcessor = (_schema, _ctx, json2, _params) => {
+  json2.type = "boolean";
 };
 const customProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
@@ -10526,27 +10653,27 @@ const setProcessor = (_schema, ctx, _json, _params) => {
   }
 };
 const arrayProcessor = (schema, ctx, _json, params) => {
-  const json = _json;
+  const json2 = _json;
   const def = schema._zod.def;
   const { minimum, maximum } = schema._zod.bag;
   if (typeof minimum === "number")
-    json.minItems = minimum;
+    json2.minItems = minimum;
   if (typeof maximum === "number")
-    json.maxItems = maximum;
-  json.type = "array";
-  json.items = process$1(def.element, ctx, {
+    json2.maxItems = maximum;
+  json2.type = "array";
+  json2.items = process$1(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
 };
 const objectProcessor = (schema, ctx, _json, params) => {
-  const json = _json;
+  const json2 = _json;
   const def = schema._zod.def;
-  json.type = "object";
-  json.properties = {};
+  json2.type = "object";
+  json2.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json.properties[key] = process$1(shape[key], ctx, {
+    json2.properties[key] = process$1(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -10561,21 +10688,21 @@ const objectProcessor = (schema, ctx, _json, params) => {
     }
   }));
   if (requiredKeys.size > 0) {
-    json.required = Array.from(requiredKeys);
+    json2.required = Array.from(requiredKeys);
   }
   if (def.catchall?._zod.def.type === "never") {
-    json.additionalProperties = false;
+    json2.additionalProperties = false;
   } else if (!def.catchall) {
     if (ctx.io === "output")
-      json.additionalProperties = false;
+      json2.additionalProperties = false;
   } else if (def.catchall) {
-    json.additionalProperties = process$1(def.catchall, ctx, {
+    json2.additionalProperties = process$1(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
   }
 };
-const unionProcessor = (schema, ctx, json, params) => {
+const unionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i2) => process$1(x, ctx, {
@@ -10583,12 +10710,12 @@ const unionProcessor = (schema, ctx, json, params) => {
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i2]
   }));
   if (isExclusive) {
-    json.oneOf = options;
+    json2.oneOf = options;
   } else {
-    json.anyOf = options;
+    json2.anyOf = options;
   }
 };
-const intersectionProcessor = (schema, ctx, json, params) => {
+const intersectionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const a2 = process$1(def.left, ctx, {
     ...params,
@@ -10603,12 +10730,12 @@ const intersectionProcessor = (schema, ctx, json, params) => {
     ...isSimpleIntersection(a2) ? a2.allOf : [a2],
     ...isSimpleIntersection(b) ? b.allOf : [b]
   ];
-  json.allOf = allOf;
+  json2.allOf = allOf;
 };
 const tupleProcessor = (schema, ctx, _json, params) => {
-  const json = _json;
+  const json2 = _json;
   const def = schema._zod.def;
-  json.type = "array";
+  json2.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, i2) => process$1(x, ctx, {
@@ -10620,37 +10747,37 @@ const tupleProcessor = (schema, ctx, _json, params) => {
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
   if (ctx.target === "draft-2020-12") {
-    json.prefixItems = prefixItems;
+    json2.prefixItems = prefixItems;
     if (rest) {
-      json.items = rest;
+      json2.items = rest;
     }
   } else if (ctx.target === "openapi-3.0") {
-    json.items = {
+    json2.items = {
       anyOf: prefixItems
     };
     if (rest) {
-      json.items.anyOf.push(rest);
+      json2.items.anyOf.push(rest);
     }
-    json.minItems = prefixItems.length;
+    json2.minItems = prefixItems.length;
     if (!rest) {
-      json.maxItems = prefixItems.length;
+      json2.maxItems = prefixItems.length;
     }
   } else {
-    json.items = prefixItems;
+    json2.items = prefixItems;
     if (rest) {
-      json.additionalItems = rest;
+      json2.additionalItems = rest;
     }
   }
   const { minimum, maximum } = schema._zod.bag;
   if (typeof minimum === "number")
-    json.minItems = minimum;
+    json2.minItems = minimum;
   if (typeof maximum === "number")
-    json.maxItems = maximum;
+    json2.maxItems = maximum;
 };
 const recordProcessor = (schema, ctx, _json, params) => {
-  const json = _json;
+  const json2 = _json;
   const def = schema._zod.def;
-  json.type = "object";
+  json2.type = "object";
   const keyType = def.keyType;
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
@@ -10659,18 +10786,18 @@ const recordProcessor = (schema, ctx, _json, params) => {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
-    json.patternProperties = {};
+    json2.patternProperties = {};
     for (const pattern of patterns) {
-      json.patternProperties[pattern.source] = valueSchema;
+      json2.patternProperties[pattern.source] = valueSchema;
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json.propertyNames = process$1(def.keyType, ctx, {
+      json2.propertyNames = process$1(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json.additionalProperties = process$1(def.valueType, ctx, {
+    json2.additionalProperties = process$1(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -10679,19 +10806,19 @@ const recordProcessor = (schema, ctx, _json, params) => {
   if (keyValues) {
     const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
     if (validKeyValues.length > 0) {
-      json.required = validKeyValues;
+      json2.required = validKeyValues;
     }
   }
 };
-const nullableProcessor = (schema, ctx, json, params) => {
+const nullableProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const inner = process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
-    json.nullable = true;
+    json2.nullable = true;
   } else {
-    json.anyOf = [inner, { type: "null" }];
+    json2.anyOf = [inner, { type: "null" }];
   }
 };
 const nonoptionalProcessor = (schema, ctx, _json, params) => {
@@ -10700,22 +10827,22 @@ const nonoptionalProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
-const defaultProcessor = (schema, ctx, json, params) => {
+const defaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json.default = JSON.parse(JSON.stringify(def.defaultValue));
+  json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
-const prefaultProcessor = (schema, ctx, json, params) => {
+const prefaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
-    json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+    json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
-const catchProcessor = (schema, ctx, json, params) => {
+const catchProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
@@ -10726,7 +10853,7 @@ const catchProcessor = (schema, ctx, json, params) => {
   } catch {
     throw new Error("Dynamic catch values are not supported in JSON Schema");
   }
-  json.default = catchValue;
+  json2.default = catchValue;
 };
 const pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -10736,12 +10863,12 @@ const pipeProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
-const readonlyProcessor = (schema, ctx, json, params) => {
+const readonlyProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json.readOnly = true;
+  json2.readOnly = true;
 };
 const promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -11082,7 +11209,7 @@ const ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 const _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
   $ZodString.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2);
   const bag = inst._zod.bag;
   inst.format = bag.format ?? null;
   inst.minLength = bag.minimum ?? null;
@@ -11252,7 +11379,7 @@ const ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
 const ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
   $ZodNumber.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2);
   _installLazyMethods(inst, "ZodNumber", {
     gt(value, params) {
       return this.check(/* @__PURE__ */ _gt(value, params));
@@ -11320,7 +11447,7 @@ function int(params) {
 const ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2);
 });
 function boolean(params) {
   return /* @__PURE__ */ _boolean(ZodBoolean, params);
@@ -11328,7 +11455,7 @@ function boolean(params) {
 const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor();
+  inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor();
 });
 function unknown() {
   return /* @__PURE__ */ _unknown(ZodUnknown);
@@ -11336,7 +11463,7 @@ function unknown() {
 const ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
   $ZodNever.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2);
 });
 function never(params) {
   return /* @__PURE__ */ _never(ZodNever, params);
@@ -11344,7 +11471,7 @@ function never(params) {
 const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
   inst.element = def.element;
   _installLazyMethods(inst, "ZodArray", {
     min(n2, params) {
@@ -11370,7 +11497,7 @@ function array(element, params) {
 const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
   defineLazy(inst, "shape", () => {
     return def.shape;
   });
@@ -11403,7 +11530,7 @@ const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
       return merge(this, other);
     },
     pick(mask) {
-      return pick$1(this, mask);
+      return pick(this, mask);
     },
     omit(mask) {
       return omit(this, mask);
@@ -11435,7 +11562,7 @@ function looseObject(shape, params) {
 const ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
   inst.options = def.options;
 });
 function union(options, params) {
@@ -11448,7 +11575,7 @@ function union(options, params) {
 const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
   $ZodIntersection.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
 });
 function intersection(left, right) {
   return new ZodIntersection({
@@ -11457,10 +11584,33 @@ function intersection(left, right) {
     right
   });
 }
+const 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.keyType = def.keyType;
+  inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+  if (!valueType || !valueType._zod) {
+    return new ZodRecord({
+      type: "record",
+      keyType: string(),
+      valueType: keyType,
+      ...normalizeParams(valueType)
+    });
+  }
+  return new ZodRecord({
+    type: "record",
+    keyType,
+    valueType,
+    ...normalizeParams(params)
+  });
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json);
+  inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2);
   inst.enum = def.entries;
   inst.options = Object.values(def.entries);
   const keys = new Set(Object.keys(def.entries));
@@ -11506,7 +11656,7 @@ function _enum(values, params) {
 const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx);
+  inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx);
   inst._zod.parse = (payload, _ctx) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
@@ -11546,7 +11696,7 @@ function transform(fn) {
 const ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
   $ZodOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -11558,7 +11708,7 @@ function optional(innerType) {
 const ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
   $ZodExactOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function exactOptional(innerType) {
@@ -11570,7 +11720,7 @@ function exactOptional(innerType) {
 const ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -11582,7 +11732,7 @@ function nullable(innerType) {
 const ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
   $ZodDefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeDefault = inst.unwrap;
 });
@@ -11598,7 +11748,7 @@ function _default(innerType, defaultValue) {
 const ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
   $ZodPrefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -11613,7 +11763,7 @@ function prefault(innerType, defaultValue) {
 const ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
   $ZodNonOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -11626,7 +11776,7 @@ function nonoptional(innerType, params) {
 const ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
   $ZodCatch.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeCatch = inst.unwrap;
 });
@@ -11640,7 +11790,7 @@ function _catch(innerType, catchValue) {
 const ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   $ZodPipe.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
   inst.in = def.in;
   inst.out = def.out;
 });
@@ -11655,7 +11805,7 @@ function pipe(in_, out) {
 const ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
   $ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
+  inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -11667,7 +11817,7 @@ function readonly(innerType) {
 const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx);
+  inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx);
 });
 function refine(fn, _params = {}) {
   return /* @__PURE__ */ _refine(ZodCustom, fn, _params);
@@ -11705,7 +11855,7 @@ const EMPTY_AI_USAGE = {
 };
 const OPERATIONS = ["commit-message", "pull-request-draft"];
 const STATUSES = ["success", "failed", "cancelled"];
-const HARNESSES = ["codex", "claude", "opencode"];
+const HARNESSES = ["codex", "claude", "opencode", "grok"];
 const MAX_TEXT$1 = 200;
 const MAX_ERROR_TEXT = 400;
 const aiUsageRecordSchema = looseObject({
@@ -11884,8 +12034,8 @@ class AiLogStore {
   }
   /** Records one run. Never rejects; failures are dropped on purpose. */
   append(entry) {
-    const record = { ...entry, id: randomUUID(), at: (/* @__PURE__ */ new Date()).toISOString() };
-    const normalized = normalizeAiLogEntry(record);
+    const record2 = { ...entry, id: randomUUID(), at: (/* @__PURE__ */ new Date()).toISOString() };
+    const normalized = normalizeAiLogEntry(record2);
     if (!normalized) return;
     this.pending = this.pending.then(async () => {
       await mkdir(path.dirname(this.filePath), { recursive: true });
@@ -11985,23 +12135,23 @@ function parseGeneratedParts(value) {
   const parsed = generatedPartsSchema.safeParse(value);
   if (!parsed.success || `${parsed.data.subject}
 
-${parsed.data.body}`.length > 1e4) throw invalidOutput$3();
+${parsed.data.body}`.length > 1e4) throw invalidOutput$4();
   return parsed.data;
 }
 function parseCommitSplitProposal(value, stagedPaths) {
   if (!value || typeof value !== "object") return { status: "absent" };
-  const record = value;
-  if (record.commits === void 0 || Array.isArray(record.commits) && record.commits.length === 0) return { status: "absent" };
-  if (!Array.isArray(record.commits)) return { status: "rejected", reason: "commits was not a list" };
+  const record2 = value;
+  if (record2.commits === void 0 || Array.isArray(record2.commits) && record2.commits.length === 0) return { status: "absent" };
+  if (!Array.isArray(record2.commits)) return { status: "rejected", reason: "commits was not a list" };
   if (stagedPaths.length < 2) return { status: "absent" };
-  if (record.commits.length < 2) return { status: "rejected", reason: "fewer than two groups" };
-  if (record.commits.length > 8) return { status: "rejected", reason: `too many groups (${record.commits.length})` };
-  const rationale = cleanText(record.rationale, 1e3);
+  if (record2.commits.length < 2) return { status: "rejected", reason: "fewer than two groups" };
+  if (record2.commits.length > 8) return { status: "rejected", reason: `too many groups (${record2.commits.length})` };
+  const rationale = cleanText(record2.rationale, 1e3);
   if (rationale === null) return { status: "rejected", reason: "missing or unusable rationale" };
   const allowed = new Set(stagedPaths);
   const used = /* @__PURE__ */ new Set();
   const commits = [];
-  for (const candidate of record.commits) {
+  for (const candidate of record2.commits) {
     if (!candidate || typeof candidate !== "object") return { status: "rejected", reason: "a group was not an object" };
     let parts;
     try {
@@ -12045,14 +12195,14 @@ function parseJsonPayload(raw) {
         if (nested instanceof AiOperationError) throw nested;
       }
     }
-    throw invalidOutput$3();
+    throw invalidOutput$4();
   }
 }
 function asRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw invalidOutput$3();
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw invalidOutput$4();
   return value;
 }
-function invalidOutput$3() {
+function invalidOutput$4() {
   return new AiOperationError({ code: "AI_INVALID_OUTPUT", operation: "ai-parse-output", message: "The AI returned a message with an invalid format.", retryable: true });
 }
 function hasControlCharacters$6(value, allowWhitespace) {
@@ -12144,7 +12294,7 @@ ${parts.body}` : parts.subject,
         splitBlockedReason: context.splitBlockedReason
       };
     } catch (error) {
-      const failure = failureLogFields(error);
+      const failure2 = failureLogFields(error);
       recordSafely(this.log, {
         operation: "commit-message",
         harness: input.harness,
@@ -12152,10 +12302,10 @@ ${parts.body}` : parts.subject,
         repositoryId: input.repositoryId,
         // A cancellation is a decision, not a failure; merging the two would
         // poison any reliability figure taken from this log.
-        status: failure.status,
+        status: failure2.status,
         durationMs: Date.now() - startedAt,
-        errorCode: failure.errorCode,
-        errorMessage: failure.errorMessage,
+        errorCode: failure2.errorCode,
+        errorMessage: failure2.errorMessage,
         usage,
         stagedFileCount,
         contextTruncated,
@@ -12226,10 +12376,10 @@ ${context.patch}`;
 }
 function parsePullRequestDraft(value) {
   const parsed = pullRequestDraftSchema.safeParse(value);
-  if (!parsed.success) throw invalidOutput$2();
+  if (!parsed.success) throw invalidOutput$3();
   return parsed.data;
 }
-function invalidOutput$2() {
+function invalidOutput$3() {
   return new AiOperationError({ code: "AI_INVALID_OUTPUT", operation: "ai-parse-pr-draft", message: "The AI returned a pull request draft with an invalid format.", retryable: true });
 }
 function hasControlCharacters$5(value, allowWhitespace) {
@@ -12279,8 +12429,8 @@ class PullRequestDraftService {
       this.record(input, "success", null, null, usage, contextTruncated, Date.now() - startedAt);
       return { ...parts, harness: input.harness, model: input.model, contextWasTruncated: context.truncated };
     } catch (error) {
-      const failure = failureLogFields(error);
-      this.record(input, failure.status, failure.errorCode, failure.errorMessage, usage, contextTruncated, Date.now() - startedAt);
+      const failure2 = failureLogFields(error);
+      this.record(input, failure2.status, failure2.errorCode, failure2.errorMessage, usage, contextTruncated, Date.now() - startedAt);
       throw error;
     } finally {
       this.active.delete(input.requestId);
@@ -12320,11 +12470,24 @@ function throwIfCancelled(signal, harness) {
 }
 const AI_PROVIDER_TIMEOUT_MS = 9 * 6e4;
 const AI_SERVER_TIMEOUT_MS = AI_PROVIDER_TIMEOUT_MS + 3e4;
-const DEFAULT_MODEL = { id: "default", label: "Default (CLI)" };
+const DEFAULT_MODEL$1 = { id: "default", label: "Default (CLI)" };
+function grokUsage(envelope) {
+  if (!envelope || typeof envelope !== "object") return { ...EMPTY_AI_USAGE };
+  const record2 = envelope;
+  const usage = record2.usage && typeof record2.usage === "object" ? record2.usage : {};
+  return {
+    inputTokens: count(usage.input_tokens),
+    outputTokens: count(usage.output_tokens),
+    reasoningTokens: count(usage.reasoning_tokens),
+    cacheReadTokens: count(usage.cache_read_input_tokens),
+    cacheWriteTokens: count(usage.cache_creation_input_tokens),
+    costUsd: count(record2.total_cost_usd, true)
+  };
+}
 function claudeUsage(envelope) {
   if (!envelope || typeof envelope !== "object") return { ...EMPTY_AI_USAGE };
-  const record = envelope;
-  const usage = record.usage ?? {};
+  const record2 = envelope;
+  const usage = record2.usage ?? {};
   const details = usage.output_tokens_details ?? {};
   return {
     inputTokens: count(usage.input_tokens),
@@ -12332,7 +12495,7 @@ function claudeUsage(envelope) {
     reasoningTokens: count(details.thinking_tokens),
     cacheReadTokens: count(usage.cache_read_input_tokens),
     cacheWriteTokens: count(usage.cache_creation_input_tokens),
-    costUsd: count(record.total_cost_usd, true)
+    costUsd: count(record2.total_cost_usd, true)
   };
 }
 function codexUsage(stdout) {
@@ -12358,20 +12521,6 @@ function codexUsage(stdout) {
     costUsd: null
   };
 }
-function openCodeUsage(info) {
-  if (!info || typeof info !== "object") return { ...EMPTY_AI_USAGE };
-  const record = info;
-  const tokens = record.tokens ?? {};
-  const cache = tokens.cache ?? {};
-  return {
-    inputTokens: count(tokens.input),
-    outputTokens: count(tokens.output),
-    reasoningTokens: count(tokens.reasoning),
-    cacheReadTokens: count(cache.read),
-    cacheWriteTokens: count(cache.write),
-    costUsd: count(record.cost, true)
-  };
-}
 function count(value, fractional = false) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
   return fractional ? value : Math.round(value);
@@ -12420,7 +12569,7 @@ ${diagnostic ?? ""}`.toLowerCase();
   });
 }
 function label(harness) {
-  return harness === "codex" ? "Codex" : harness === "claude" ? "Claude Code" : "OpenCode";
+  return harness === "codex" ? "Codex" : harness === "claude" ? "Claude Code" : harness === "grok" ? "Grok Build" : "OpenCode";
 }
 function stripAnsi(value) {
   return value.replace(new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g"), "");
@@ -12431,29 +12580,29 @@ function toCodexOutputSchema(schema) {
 function strictify(value) {
   if (!value || typeof value !== "object") return value;
   if (Array.isArray(value)) return value.map(strictify);
-  const record = { ...value };
-  delete record.$schema;
-  if (record.properties && typeof record.properties === "object" && !Array.isArray(record.properties)) {
+  const record2 = { ...value };
+  delete record2.$schema;
+  if (record2.properties && typeof record2.properties === "object" && !Array.isArray(record2.properties)) {
     const properties = Object.fromEntries(
-      Object.entries(record.properties).map(([key, item]) => [key, strictify(item)])
+      Object.entries(record2.properties).map(([key, item]) => [key, strictify(item)])
     );
-    record.properties = properties;
-    record.required = Object.keys(properties);
-    record.additionalProperties = false;
+    record2.properties = properties;
+    record2.required = Object.keys(properties);
+    record2.additionalProperties = false;
   }
-  if ("items" in record) record.items = strictify(record.items);
+  if ("items" in record2) record2.items = strictify(record2.items);
   for (const key of ["$defs", "definitions"]) {
-    const defs = record[key];
+    const defs = record2[key];
     if (defs && typeof defs === "object" && !Array.isArray(defs)) {
-      record[key] = Object.fromEntries(
+      record2[key] = Object.fromEntries(
         Object.entries(defs).map(([name, item]) => [name, strictify(item)])
       );
     }
   }
   for (const key of ["anyOf", "oneOf", "allOf"]) {
-    if (Array.isArray(record[key])) record[key] = record[key].map(strictify);
+    if (Array.isArray(record2[key])) record2[key] = record2[key].map(strictify);
   }
-  return record;
+  return record2;
 }
 function cliDiagnostic(result) {
   let fromTurn = null;
@@ -12514,7 +12663,7 @@ function flattenWhitespace(value) {
   }
   return flattened.replace(/ {2,}/g, " ").trim();
 }
-const MODELS = [DEFAULT_MODEL, { id: "sonnet", label: "Sonnet" }, { id: "opus", label: "Opus" }, { id: "haiku", label: "Haiku" }];
+const MODELS = [DEFAULT_MODEL$1, { id: "sonnet", label: "Sonnet" }, { id: "opus", label: "Opus" }, { id: "haiku", label: "Haiku" }];
 class ClaudeProvider {
   constructor(resolver, runner) {
     this.resolver = resolver;
@@ -12576,15 +12725,15 @@ class CodexProvider {
   async status(forceRefresh = false) {
     const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
     const executable = await this.resolver.resolve("codex", forceRefresh);
-    if (!executable) return { id: this.id, label: "Codex", availability: "error", installed: false, authStatus: "unknown", message: "Install Codex CLI to use this harness.", models: [DEFAULT_MODEL], checkedAt };
+    if (!executable) return { id: this.id, label: "Codex", availability: "error", installed: false, authStatus: "unknown", message: "Install Codex CLI to use this harness.", models: [DEFAULT_MODEL$1], checkedAt };
     const version2 = await this.runner.run(executable, ["--version"]);
     const login = await this.runner.run(executable, ["login", "status"]);
     if (login.exitCode !== 0 || !/logged in/i.test(`${login.stdout}
 ${login.stderr}`)) {
-      return { id: this.id, label: "Codex", availability: "error", installed: true, authStatus: "unauthenticated", version: version2.stdout.trim() || version2.stderr.trim(), message: "Run codex login.", models: [DEFAULT_MODEL], checkedAt };
+      return { id: this.id, label: "Codex", availability: "error", installed: true, authStatus: "unauthenticated", version: version2.stdout.trim() || version2.stderr.trim(), message: "Run codex login.", models: [DEFAULT_MODEL$1], checkedAt };
     }
     const catalog = await this.runner.run(executable, ["debug", "models", "--bundled"]);
-    const models = catalog.exitCode === 0 ? parseCodexModels(catalog.stdout) : [DEFAULT_MODEL];
+    const models = catalog.exitCode === 0 ? parseCodexModels(catalog.stdout) : [DEFAULT_MODEL$1];
     return {
       id: this.id,
       label: "Codex",
@@ -12620,2254 +12769,223 @@ function parseCodexModels(raw) {
   try {
     const parsed = JSON.parse(raw);
     const options = (parsed.models ?? []).filter((item) => typeof item.slug === "string" && item.visibility !== "hidden").map((item) => ({ id: item.slug, label: typeof item.display_name === "string" ? item.display_name : item.slug }));
-    return [DEFAULT_MODEL, ...options];
+    return [DEFAULT_MODEL$1, ...options];
   } catch {
-    return [DEFAULT_MODEL];
-  }
-}
-const createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
-  let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
-  const createStream = async function* () {
-    let retryDelay = sseDefaultRetryDelay ?? 3e3;
-    let attempt = 0;
-    const signal = options.signal ?? new AbortController().signal;
-    while (true) {
-      if (signal.aborted)
-        break;
-      attempt++;
-      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
-      if (lastEventId !== void 0) {
-        headers.set("Last-Event-ID", lastEventId);
-      }
-      try {
-        const response = await fetch(url, { ...options, headers, signal });
-        if (!response.ok)
-          throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
-        if (!response.body)
-          throw new Error("No body in SSE response");
-        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-        let buffer = "";
-        const abortHandler = () => {
-          try {
-            void reader.cancel();
-          } catch {
-          }
-        };
-        signal.addEventListener("abort", abortHandler);
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-              break;
-            buffer += value;
-            const chunks = buffer.split("\n\n");
-            buffer = chunks.pop() ?? "";
-            for (const chunk of chunks) {
-              const lines = chunk.split("\n");
-              const dataLines = [];
-              let eventName;
-              for (const line of lines) {
-                if (line.startsWith("data:")) {
-                  dataLines.push(line.replace(/^data:\s*/, ""));
-                } else if (line.startsWith("event:")) {
-                  eventName = line.replace(/^event:\s*/, "");
-                } else if (line.startsWith("id:")) {
-                  lastEventId = line.replace(/^id:\s*/, "");
-                } else if (line.startsWith("retry:")) {
-                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
-                  if (!Number.isNaN(parsed)) {
-                    retryDelay = parsed;
-                  }
-                }
-              }
-              let data;
-              let parsedJson = false;
-              if (dataLines.length) {
-                const rawData = dataLines.join("\n");
-                try {
-                  data = JSON.parse(rawData);
-                  parsedJson = true;
-                } catch {
-                  data = rawData;
-                }
-              }
-              if (parsedJson) {
-                if (responseValidator) {
-                  await responseValidator(data);
-                }
-                if (responseTransformer) {
-                  data = await responseTransformer(data);
-                }
-              }
-              onSseEvent?.({
-                data,
-                event: eventName,
-                id: lastEventId,
-                retry: retryDelay
-              });
-              if (dataLines.length) {
-                yield data;
-              }
-            }
-          }
-        } finally {
-          signal.removeEventListener("abort", abortHandler);
-          reader.releaseLock();
-        }
-        break;
-      } catch (error) {
-        onSseError?.(error);
-        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
-          break;
-        }
-        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
-        await sleep(backoff);
-      }
-    }
-  };
-  const stream = createStream();
-  return { stream };
-};
-const getAuthToken = async (auth, callback) => {
-  const token = typeof callback === "function" ? await callback(auth) : callback;
-  if (!token) {
-    return;
-  }
-  if (auth.scheme === "bearer") {
-    return `Bearer ${token}`;
-  }
-  if (auth.scheme === "basic") {
-    return `Basic ${btoa(token)}`;
-  }
-  return token;
-};
-const jsonBodySerializer = {
-  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
-};
-const separatorArrayExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
-  }
-};
-const separatorArrayNoExplode = (style) => {
-  switch (style) {
-    case "form":
-      return ",";
-    case "pipeDelimited":
-      return "|";
-    case "spaceDelimited":
-      return "%20";
-    default:
-      return ",";
-  }
-};
-const separatorObjectExplode = (style) => {
-  switch (style) {
-    case "label":
-      return ".";
-    case "matrix":
-      return ";";
-    case "simple":
-      return ",";
-    default:
-      return "&";
-  }
-};
-const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
-  if (!explode) {
-    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
-    switch (style) {
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name}=${joinedValues2}`;
-      case "simple":
-        return joinedValues2;
-      default:
-        return `${name}=${joinedValues2}`;
-    }
-  }
-  const separator = separatorArrayExplode(style);
-  const joinedValues = value.map((v) => {
-    if (style === "label" || style === "simple") {
-      return allowReserved ? v : encodeURIComponent(v);
-    }
-    return serializePrimitiveParam({
-      allowReserved,
-      name,
-      value: v
-    });
-  }).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-const serializePrimitiveParam = ({ allowReserved, name, value }) => {
-  if (value === void 0 || value === null) {
-    return "";
-  }
-  if (typeof value === "object") {
-    throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
-  }
-  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
-};
-const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
-  if (value instanceof Date) {
-    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
-  }
-  if (style !== "deepObject" && !explode) {
-    let values = [];
-    Object.entries(value).forEach(([key, v]) => {
-      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
-    });
-    const joinedValues2 = values.join(",");
-    switch (style) {
-      case "form":
-        return `${name}=${joinedValues2}`;
-      case "label":
-        return `.${joinedValues2}`;
-      case "matrix":
-        return `;${name}=${joinedValues2}`;
-      default:
-        return joinedValues2;
-    }
-  }
-  const separator = separatorObjectExplode(style);
-  const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
-    allowReserved,
-    name: style === "deepObject" ? `${name}[${key}]` : key,
-    value: v
-  })).join(separator);
-  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
-};
-const PATH_PARAM_RE = /\{[^{}]+\}/g;
-const defaultPathSerializer = ({ path: path2, url: _url2 }) => {
-  let url = _url2;
-  const matches = _url2.match(PATH_PARAM_RE);
-  if (matches) {
-    for (const match of matches) {
-      let explode = false;
-      let name = match.substring(1, match.length - 1);
-      let style = "simple";
-      if (name.endsWith("*")) {
-        explode = true;
-        name = name.substring(0, name.length - 1);
-      }
-      if (name.startsWith(".")) {
-        name = name.substring(1);
-        style = "label";
-      } else if (name.startsWith(";")) {
-        name = name.substring(1);
-        style = "matrix";
-      }
-      const value = path2[name];
-      if (value === void 0 || value === null) {
-        continue;
-      }
-      if (Array.isArray(value)) {
-        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
-        continue;
-      }
-      if (typeof value === "object") {
-        url = url.replace(match, serializeObjectParam({
-          explode,
-          name,
-          style,
-          value,
-          valueOnly: true
-        }));
-        continue;
-      }
-      if (style === "matrix") {
-        url = url.replace(match, `;${serializePrimitiveParam({
-          name,
-          value
-        })}`);
-        continue;
-      }
-      const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
-      url = url.replace(match, replaceValue);
-    }
-  }
-  return url;
-};
-const getUrl = ({ baseUrl, path: path2, query, querySerializer, url: _url2 }) => {
-  const pathUrl = _url2.startsWith("/") ? _url2 : `/${_url2}`;
-  let url = (baseUrl ?? "") + pathUrl;
-  if (path2) {
-    url = defaultPathSerializer({ path: path2, url });
-  }
-  let search = query ? querySerializer(query) : "";
-  if (search.startsWith("?")) {
-    search = search.substring(1);
-  }
-  if (search) {
-    url += `?${search}`;
-  }
-  return url;
-};
-const createQuerySerializer = ({ allowReserved, array: array2, object: object2 } = {}) => {
-  const querySerializer = (queryParams) => {
-    const search = [];
-    if (queryParams && typeof queryParams === "object") {
-      for (const name in queryParams) {
-        const value = queryParams[name];
-        if (value === void 0 || value === null) {
-          continue;
-        }
-        if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam({
-            allowReserved,
-            explode: true,
-            name,
-            style: "form",
-            value,
-            ...array2
-          });
-          if (serializedArray)
-            search.push(serializedArray);
-        } else if (typeof value === "object") {
-          const serializedObject = serializeObjectParam({
-            allowReserved,
-            explode: true,
-            name,
-            style: "deepObject",
-            value,
-            ...object2
-          });
-          if (serializedObject)
-            search.push(serializedObject);
-        } else {
-          const serializedPrimitive = serializePrimitiveParam({
-            allowReserved,
-            name,
-            value
-          });
-          if (serializedPrimitive)
-            search.push(serializedPrimitive);
-        }
-      }
-    }
-    return search.join("&");
-  };
-  return querySerializer;
-};
-const getParseAs = (contentType) => {
-  if (!contentType) {
-    return "stream";
-  }
-  const cleanContent = contentType.split(";")[0]?.trim();
-  if (!cleanContent) {
-    return;
-  }
-  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
-    return "json";
-  }
-  if (cleanContent === "multipart/form-data") {
-    return "formData";
-  }
-  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
-    return "blob";
-  }
-  if (cleanContent.startsWith("text/")) {
-    return "text";
-  }
-  return;
-};
-const checkForExistence = (options, name) => {
-  if (!name) {
-    return false;
-  }
-  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
-    return true;
-  }
-  return false;
-};
-const setAuthParams = async ({ security, ...options }) => {
-  for (const auth of security) {
-    if (checkForExistence(options, auth.name)) {
-      continue;
-    }
-    const token = await getAuthToken(auth, options.auth);
-    if (!token) {
-      continue;
-    }
-    const name = auth.name ?? "Authorization";
-    switch (auth.in) {
-      case "query":
-        if (!options.query) {
-          options.query = {};
-        }
-        options.query[name] = token;
-        break;
-      case "cookie":
-        options.headers.append("Cookie", `${name}=${token}`);
-        break;
-      case "header":
-      default:
-        options.headers.set(name, token);
-        break;
-    }
-  }
-};
-const buildUrl = (options) => getUrl({
-  baseUrl: options.baseUrl,
-  path: options.path,
-  query: options.query,
-  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
-  url: options.url
-});
-const mergeConfigs = (a2, b) => {
-  const config2 = { ...a2, ...b };
-  if (config2.baseUrl?.endsWith("/")) {
-    config2.baseUrl = config2.baseUrl.substring(0, config2.baseUrl.length - 1);
-  }
-  config2.headers = mergeHeaders(a2.headers, b.headers);
-  return config2;
-};
-const mergeHeaders = (...headers) => {
-  const mergedHeaders = new Headers();
-  for (const header of headers) {
-    if (!header || typeof header !== "object") {
-      continue;
-    }
-    const iterator = header instanceof Headers ? header.entries() : Object.entries(header);
-    for (const [key, value] of iterator) {
-      if (value === null) {
-        mergedHeaders.delete(key);
-      } else if (Array.isArray(value)) {
-        for (const v of value) {
-          mergedHeaders.append(key, v);
-        }
-      } else if (value !== void 0) {
-        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
-      }
-    }
-  }
-  return mergedHeaders;
-};
-class Interceptors {
-  _fns;
-  constructor() {
-    this._fns = [];
-  }
-  clear() {
-    this._fns = [];
-  }
-  getInterceptorIndex(id) {
-    if (typeof id === "number") {
-      return this._fns[id] ? id : -1;
-    } else {
-      return this._fns.indexOf(id);
-    }
+    return [DEFAULT_MODEL$1];
   }
-  exists(id) {
-    const index = this.getInterceptorIndex(id);
-    return !!this._fns[index];
-  }
-  eject(id) {
-    const index = this.getInterceptorIndex(id);
-    if (this._fns[index]) {
-      this._fns[index] = null;
-    }
+}
+function isSupportedGrokVersion(raw) {
+  const match = /^grok (\d+)\.(\d+)\.(\d+)\b/i.exec(stripAnsi(raw).trim());
+  return !!match && Number(match[1]) === 1 && (Number(match[2]) > 0 || Number(match[3]) >= 46);
+}
+function parseGrokModels(raw) {
+  const text2 = stripAnsi(raw);
+  const authStatus = /You are not authenticated\./.test(text2) ? "unauthenticated" : /You are logged in with |You are using XAI_API_KEY\.|is using its own API key\.|authenticated via deployment key/.test(text2) ? "authenticated" : "unknown";
+  const models = [{ id: "default", label: "Default (Grok)" }];
+  const seen = /* @__PURE__ */ new Set(["default"]);
+  const catalog = text2.split("Available models:")[1] ?? "";
+  for (const line of catalog.split(/\r?\n/)) {
+    const match = /^\s+[*-]\s+([^\s]+?)(?:\s+\(default\))?\s*$/.exec(line);
+    const id = match?.[1];
+    if (id && id.length <= 200 && /^[\w.:/#-]+$/.test(id) && !seen.has(id)) {
+      seen.add(id);
+      models.push({ id, label: id });
+    }
+  }
+  return { authStatus, models };
+}
+function parseGrokOutput(raw) {
+  let envelope;
+  try {
+    envelope = parseJsonPayload(stripAnsi(raw));
+  } catch {
+    throw invalidOutput$2();
   }
-  update(id, fn) {
-    const index = this.getInterceptorIndex(id);
-    if (this._fns[index]) {
-      this._fns[index] = fn;
-      return id;
-    } else {
-      return false;
-    }
+  if (envelope.type === "error" || envelope.structuredOutputError || envelope.stopReason !== "end_turn") throw invalidOutput$2();
+  const structured = envelope.structuredOutput;
+  if (structured !== void 0) {
+    if (!structured || typeof structured !== "object" || Array.isArray(structured)) throw invalidOutput$2();
+    return { envelope, output: structured };
   }
-  use(fn) {
-    this._fns = [...this._fns, fn];
-    return this._fns.length - 1;
+  if (typeof envelope.text !== "string") throw invalidOutput$2();
+  try {
+    return { envelope, output: parseJsonPayload(envelope.text) };
+  } catch {
+    throw invalidOutput$2();
   }
 }
-const createInterceptors = () => ({
-  error: new Interceptors(),
-  request: new Interceptors(),
-  response: new Interceptors()
-});
-const defaultQuerySerializer = createQuerySerializer({
-  allowReserved: false,
-  array: {
-    explode: true,
-    style: "form"
-  },
-  object: {
-    explode: true,
-    style: "deepObject"
+function invalidOutput$2() {
+  return new AiOperationError({ code: "AI_INVALID_OUTPUT", operation: "grok-generate", harness: "grok", message: "Grok returned an incomplete or invalid structured response.", retryable: true });
+}
+const DEFAULT_MODEL = { id: "default", label: "Default (Grok)" };
+const UNSUPPORTED = "Grok Build 1.0.46 or later in the 1.x series is required, with headless JSON and tool controls.";
+const CONFIG = "[cli]\nauto_update = false\n[subagents]\nenabled = false\n[managed_mcps]\nenabled = false\ngateway_tools_enabled = false\n[memory]\nenabled = false\n[features]\nmanaged_config = false\ntitle_refresh = false\nturn_summary = false\n";
+const REQUIRED_FLAGS = ["--prompt-file", "--json-schema", "--output-format", "--tools", "--disallowed-tools", "--deny", "--disable-web-search", "--max-turns", "--permission-mode", "--verbatim"];
+class GrokProvider {
+  constructor(resolver, runner) {
+    this.resolver = resolver;
+    this.runner = runner;
   }
-});
-const defaultHeaders = {
-  "Content-Type": "application/json"
-};
-const createConfig = (override = {}) => ({
-  ...jsonBodySerializer,
-  headers: defaultHeaders,
-  parseAs: "auto",
-  querySerializer: defaultQuerySerializer,
-  ...override
-});
-const createClient = (config2 = {}) => {
-  let _config = mergeConfigs(createConfig(), config2);
-  const getConfig = () => ({ ..._config });
-  const setConfig = (config3) => {
-    _config = mergeConfigs(_config, config3);
-    return getConfig();
-  };
-  const interceptors = createInterceptors();
-  const beforeRequest = async (options) => {
-    const opts = {
-      ..._config,
-      ...options,
-      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers),
-      serializedBody: void 0
-    };
-    if (opts.security) {
-      await setAuthParams({
-        ...opts,
-        security: opts.security
-      });
-    }
-    if (opts.requestValidator) {
-      await opts.requestValidator(opts);
-    }
-    if (opts.body && opts.bodySerializer) {
-      opts.serializedBody = opts.bodySerializer(opts.body);
-    }
-    if (opts.serializedBody === void 0 || opts.serializedBody === "") {
-      opts.headers.delete("Content-Type");
-    }
-    const url = buildUrl(opts);
-    return { opts, url };
-  };
-  const request = async (options) => {
-    const { opts, url } = await beforeRequest(options);
-    const requestInit = {
-      redirect: "follow",
-      ...opts,
-      body: opts.serializedBody
-    };
-    let request2 = new Request(url, requestInit);
-    for (const fn of interceptors.request._fns) {
-      if (fn) {
-        request2 = await fn(request2, opts);
-      }
-    }
-    const _fetch = opts.fetch;
-    let response = await _fetch(request2);
-    for (const fn of interceptors.response._fns) {
-      if (fn) {
-        response = await fn(response, request2, opts);
-      }
-    }
-    const result = {
-      request: request2,
-      response
-    };
-    if (response.ok) {
-      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
-        return opts.responseStyle === "data" ? {} : {
-          data: {},
-          ...result
+  resolver;
+  runner;
+  id = "grok";
+  async status(forceRefresh = false) {
+    const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const base = { id: this.id, label: "Grok Build", checkedAt, models: [DEFAULT_MODEL] };
+    const executable = await this.resolver.resolve("grok", forceRefresh);
+    if (!executable) return { ...base, installed: false, availability: "error", authStatus: "unknown", message: "Install the official Grok Build CLI and run grok login." };
+    return this.withEnvironment(async (options) => {
+      const version2 = await this.runner.run(executable, ["--version"], options);
+      const versionText = version2.stdout.trim();
+      const installed = { ...base, installed: true, version: versionText };
+      if (version2.exitCode !== 0 || !isSupportedGrokVersion(versionText)) return { ...installed, availability: "error", authStatus: "unknown", message: UNSUPPORTED };
+      try {
+        await this.checkControls(executable, options);
+        const result = await this.runner.run(executable, ["models"], options);
+        if (result.exitCode !== 0) return { ...installed, availability: "warning", authStatus: "unknown", message: "Could not check Grok authentication or models. Check again or run grok models in a terminal." };
+        const { authStatus, models } = parseGrokModels(result.stdout);
+        return {
+          ...installed,
+          models,
+          authStatus,
+          availability: authStatus === "unauthenticated" ? "error" : authStatus === "authenticated" && models.length > 1 ? "ready" : "warning",
+          ...authStatus === "unauthenticated" ? { message: "Run grok login, or provide XAI_API_KEY to the OpenTig process." } : authStatus === "unknown" ? { message: "Could not confirm Grok authentication." } : {}
         };
+      } catch (error) {
+        return { ...installed, availability: "error", authStatus: "unknown", message: error instanceof AiOperationError ? error.message : "Could not verify Grok execution controls." };
       }
-      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
-      let data;
-      switch (parseAs) {
-        case "arrayBuffer":
-        case "blob":
-        case "formData":
-        case "json":
-        case "text":
-          data = await response[parseAs]();
-          break;
-        case "stream":
-          return opts.responseStyle === "data" ? response.body : {
-            data: response.body,
-            ...result
-          };
-      }
-      if (parseAs === "json") {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data);
-        }
-        if (opts.responseTransformer) {
-          data = await opts.responseTransformer(data);
-        }
-      }
-      return opts.responseStyle === "data" ? data : {
-        data,
-        ...result
-      };
+    });
+  }
+  async generate(input) {
+    const executable = await this.resolver.resolve("grok");
+    if (!executable) throw failure("AI_CLI_NOT_FOUND", "Grok Build is not installed.");
+    const timeout = AbortSignal.timeout(AI_PROVIDER_TIMEOUT_MS);
+    const signal = AbortSignal.any([input.signal, timeout]);
+    try {
+      return await this.withEnvironment(async (options) => {
+        const controlled = { ...options, signal };
+        const version2 = await this.runner.run(executable, ["--version"], controlled);
+        if (version2.exitCode !== 0 || !isSupportedGrokVersion(version2.stdout)) throw failure("AI_PROCESS_FAILED", UNSUPPORTED);
+        await this.checkControls(executable, controlled);
+        const promptFile = path.join(options.cwd, "prompt.txt");
+        await writeFile(promptFile, input.prompt, { encoding: "utf8", mode: 384 });
+        const args = [
+          "--prompt-file",
+          promptFile,
+          "--output-format",
+          "json",
+          "--json-schema",
+          JSON.stringify(input.schema),
+          "--verbatim",
+          "--tools",
+          "read_file",
+          "--disallowed-tools",
+          "read_file,search_tool,use_tool,Agent",
+          "--deny",
+          "MCPTool",
+          "--disable-web-search",
+          "--max-turns",
+          "1",
+          "--permission-mode",
+          "dontAsk",
+          "--no-memory"
+        ];
+        if (input.model !== "default") args.push("--model", input.model);
+        const result = await this.runner.run(executable, args, { ...controlled, timeoutMs: AI_PROVIDER_TIMEOUT_MS });
+        requireGrokSuccess(result);
+        const parsed = parseGrokOutput(result.stdout);
+        return { output: parsed.output, usage: grokUsage(parsed.envelope) };
+      });
+    } catch (error) {
+      if (input.signal.aborted) throw failure("AI_CANCELLED", "Generation canceled.");
+      if (timeout.aborted) throw failure("AI_TIMEOUT", "Generation took too long.");
+      throw error;
     }
-    const textError = await response.text();
-    let jsonError;
+  }
+  async checkControls(executable, options) {
+    const help = await this.runner.run(executable, ["--help"], options);
+    if (help.exitCode !== 0 || REQUIRED_FLAGS.some((flag2) => !help.stdout.includes(flag2))) throw failure("AI_PROCESS_FAILED", UNSUPPORTED);
+    const result = await this.runner.run(executable, ["inspect", "--json"], options);
+    let report;
     try {
-      jsonError = JSON.parse(textError);
+      report = JSON.parse(result.stdout);
     } catch {
+      throw failure("AI_PROCESS_FAILED", "Could not verify the isolated Grok configuration.");
     }
-    const error = jsonError ?? textError;
-    let finalError = error;
-    for (const fn of interceptors.error._fns) {
-      if (fn) {
-        finalError = await fn(error, response, request2, opts);
-      }
-    }
-    finalError = finalError || {};
-    if (opts.throwOnError) {
-      throw finalError;
+    const surfaces = ["hooks", "plugins", "mcpServers", "projectInstructions"];
+    if (result.exitCode !== 0 || !report || surfaces.some((key) => !Array.isArray(report[key]) || report[key].length > 0)) {
+      throw failure("AI_PROCESS_FAILED", "Grok configuration includes hooks, plugins, MCP servers or instructions. OpenTig requires an isolated text-only configuration.");
     }
-    return opts.responseStyle === "data" ? void 0 : {
-      error: finalError,
-      ...result
-    };
-  };
-  const makeMethod = (method) => {
-    const fn = (options) => request({ ...options, method });
-    fn.sse = async (options) => {
-      const { opts, url } = await beforeRequest(options);
-      return createSseClient({
-        ...opts,
-        body: opts.body,
-        headers: opts.headers,
-        method,
-        url
-      });
-    };
-    return fn;
-  };
-  return {
-    buildUrl,
-    connect: makeMethod("CONNECT"),
-    delete: makeMethod("DELETE"),
-    get: makeMethod("GET"),
-    getConfig,
-    head: makeMethod("HEAD"),
-    interceptors,
-    options: makeMethod("OPTIONS"),
-    patch: makeMethod("PATCH"),
-    post: makeMethod("POST"),
-    put: makeMethod("PUT"),
-    request,
-    setConfig,
-    trace: makeMethod("TRACE")
-  };
-};
-const client = createClient(createConfig({
-  baseUrl: "http://localhost:4096"
-}));
-class _HeyApiClient {
-  _client = client;
-  constructor(args) {
-    if (args?.client) {
-      this._client = args.client;
+  }
+  async withEnvironment(run) {
+    const temporary = await mkdtemp(path.join(os.tmpdir(), "opentig-grok-"));
+    const userGrokHome = process.env.GROK_HOME || path.join(os.homedir(), ".grok");
+    const authPath = path.resolve(process.env.GROK_AUTH_PATH || path.join(userGrokHome, "auth.json"));
+    const privateGrokHome = path.join(temporary, ".grok");
+    try {
+      await mkdir(privateGrokHome, { mode: 448 });
+      await writeFile(path.join(privateGrokHome, "config.toml"), CONFIG, { encoding: "utf8", mode: 384 });
+      const env = {
+        HOME: temporary,
+        USERPROFILE: temporary,
+        GROK_HOME: privateGrokHome,
+        GROK_AUTH_PATH: authPath,
+        XDG_CONFIG_HOME: path.join(temporary, "config"),
+        XDG_DATA_HOME: path.join(temporary, "data"),
+        XDG_CACHE_HOME: path.join(temporary, "cache"),
+        GROK_SUBAGENTS: "0",
+        GROK_MANAGED_MCPS_ENABLED: "0",
+        GROK_MANAGED_MCP_GATEWAY_TOOLS_ENABLED: "0",
+        GROK_TITLE_REFRESH: "0"
+      };
+      const preserved = /* @__PURE__ */ new Set([...Object.keys(env), "GROK_AUTH", "GROK_CODE_XAI_API_KEY"]);
+      const removeEnv = Object.keys(process.env).filter((key) => key.startsWith("GROK_") && !preserved.has(key));
+      return await run({ cwd: temporary, env, removeEnv });
+    } finally {
+      await rm(temporary, { recursive: true, force: true, maxRetries: 3 });
     }
   }
 }
-class Global extends _HeyApiClient {
-  /**
-   * Get events
-   */
-  event(options) {
-    return (options?.client ?? this._client).get.sse({
-      url: "/global/event",
-      ...options
-    });
-  }
+function requireGrokSuccess(result) {
+  if (result.exitCode === 0) return;
+  const diagnostic = `${result.stdout}
+${result.stderr}`.toLowerCase();
+  if (/not authenticated|not logged|login required|unauth|authentication|sign in/.test(diagnostic)) throw failure("AI_AUTH_REQUIRED", "Sign in with grok login to generate content.");
+  if (/rate.?limit|quota|usage limit|too many requests|credit/.test(diagnostic)) throw failure("AI_RATE_LIMITED", "Grok rejected the request because of a usage limit.");
+  if (/model.*(not found|unavailable|invalid|access|not supported)|unknown model/.test(diagnostic)) throw failure("AI_MODEL_UNAVAILABLE", "The selected Grok model is unavailable.");
+  throw failure("AI_PROCESS_FAILED", "Grok could not generate content.");
 }
-class Project extends _HeyApiClient {
-  /**
-   * List all projects
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/project",
-      ...options
-    });
-  }
-  /**
-   * Get the current project
-   */
-  current(options) {
-    return (options?.client ?? this._client).get({
-      url: "/project/current",
-      ...options
-    });
-  }
-}
-class Pty extends _HeyApiClient {
-  /**
-   * List all PTY sessions
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/pty",
-      ...options
-    });
-  }
-  /**
-   * Create a new PTY session
-   */
-  create(options) {
-    return (options?.client ?? this._client).post({
-      url: "/pty",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Remove a PTY session
-   */
-  remove(options) {
-    return (options.client ?? this._client).delete({
-      url: "/pty/{id}",
-      ...options
-    });
-  }
-  /**
-   * Get PTY session info
-   */
-  get(options) {
-    return (options.client ?? this._client).get({
-      url: "/pty/{id}",
-      ...options
-    });
-  }
-  /**
-   * Update PTY session
-   */
-  update(options) {
-    return (options.client ?? this._client).put({
-      url: "/pty/{id}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Connect to a PTY session
-   */
-  connect(options) {
-    return (options.client ?? this._client).get({
-      url: "/pty/{id}/connect",
-      ...options
-    });
-  }
-}
-class Config extends _HeyApiClient {
-  /**
-   * Get config info
-   */
-  get(options) {
-    return (options?.client ?? this._client).get({
-      url: "/config",
-      ...options
-    });
-  }
-  /**
-   * Update config
-   */
-  update(options) {
-    return (options?.client ?? this._client).patch({
-      url: "/config",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * List all providers
-   */
-  providers(options) {
-    return (options?.client ?? this._client).get({
-      url: "/config/providers",
-      ...options
-    });
-  }
-}
-class Tool extends _HeyApiClient {
-  /**
-   * List all tool IDs (including built-in and dynamically registered)
-   */
-  ids(options) {
-    return (options?.client ?? this._client).get({
-      url: "/experimental/tool/ids",
-      ...options
-    });
-  }
-  /**
-   * List tools with JSON schema parameters for a provider/model
-   */
-  list(options) {
-    return (options.client ?? this._client).get({
-      url: "/experimental/tool",
-      ...options
-    });
-  }
-}
-class Instance extends _HeyApiClient {
-  /**
-   * Dispose the current instance
-   */
-  dispose(options) {
-    return (options?.client ?? this._client).post({
-      url: "/instance/dispose",
-      ...options
-    });
-  }
-}
-class Path extends _HeyApiClient {
-  /**
-   * Get the current path
-   */
-  get(options) {
-    return (options?.client ?? this._client).get({
-      url: "/path",
-      ...options
-    });
-  }
-}
-class Vcs extends _HeyApiClient {
-  /**
-   * Get VCS info for the current instance
-   */
-  get(options) {
-    return (options?.client ?? this._client).get({
-      url: "/vcs",
-      ...options
-    });
-  }
-}
-class Session extends _HeyApiClient {
-  /**
-   * List all sessions
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/session",
-      ...options
-    });
-  }
-  /**
-   * Create a new session
-   */
-  create(options) {
-    return (options?.client ?? this._client).post({
-      url: "/session",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Get session status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/session/status",
-      ...options
-    });
-  }
-  /**
-   * Delete a session and all its data
-   */
-  delete(options) {
-    return (options.client ?? this._client).delete({
-      url: "/session/{id}",
-      ...options
-    });
-  }
-  /**
-   * Get session
-   */
-  get(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}",
-      ...options
-    });
-  }
-  /**
-   * Update session properties
-   */
-  update(options) {
-    return (options.client ?? this._client).patch({
-      url: "/session/{id}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Get a session's children
-   */
-  children(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/children",
-      ...options
-    });
-  }
-  /**
-   * Get the todo list for a session
-   */
-  todo(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/todo",
-      ...options
-    });
-  }
-  /**
-   * Analyze the app and create an AGENTS.md file
-   */
-  init(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/init",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Fork an existing session at a specific message
-   */
-  fork(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/fork",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Abort a session
-   */
-  abort(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/abort",
-      ...options
-    });
-  }
-  /**
-   * Unshare the session
-   */
-  unshare(options) {
-    return (options.client ?? this._client).delete({
-      url: "/session/{id}/share",
-      ...options
-    });
-  }
-  /**
-   * Share a session
-   */
-  share(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/share",
-      ...options
-    });
-  }
-  /**
-   * Get the diff for this session
-   */
-  diff(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/diff",
-      ...options
-    });
-  }
-  /**
-   * Summarize the session
-   */
-  summarize(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/summarize",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * List messages for a session
-   */
-  messages(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/message",
-      ...options
-    });
-  }
-  /**
-   * Create and send a new message to a session
-   */
-  prompt(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/message",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Get a message from a session
-   */
-  message(options) {
-    return (options.client ?? this._client).get({
-      url: "/session/{id}/message/{messageID}",
-      ...options
-    });
-  }
-  /**
-   * Create and send a new message to a session, start if needed and return immediately
-   */
-  promptAsync(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/prompt_async",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Send a new command to a session
-   */
-  command(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/command",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Run a shell command
-   */
-  shell(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/shell",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Revert a message
-   */
-  revert(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/revert",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Restore all reverted messages
-   */
-  unrevert(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/unrevert",
-      ...options
-    });
-  }
-}
-class Command extends _HeyApiClient {
-  /**
-   * List all commands
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/command",
-      ...options
-    });
-  }
-}
-class Oauth extends _HeyApiClient {
-  /**
-   * Authorize a provider using OAuth
-   */
-  authorize(options) {
-    return (options.client ?? this._client).post({
-      url: "/provider/{id}/oauth/authorize",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Handle OAuth callback for a provider
-   */
-  callback(options) {
-    return (options.client ?? this._client).post({
-      url: "/provider/{id}/oauth/callback",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-}
-class Provider extends _HeyApiClient {
-  /**
-   * List all providers
-   */
-  list(options) {
-    return (options?.client ?? this._client).get({
-      url: "/provider",
-      ...options
-    });
-  }
-  /**
-   * Get provider authentication methods
-   */
-  auth(options) {
-    return (options?.client ?? this._client).get({
-      url: "/provider/auth",
-      ...options
-    });
-  }
-  oauth = new Oauth({ client: this._client });
-}
-class Find extends _HeyApiClient {
-  /**
-   * Find text in files
-   */
-  text(options) {
-    return (options.client ?? this._client).get({
-      url: "/find",
-      ...options
-    });
-  }
-  /**
-   * Find files
-   */
-  files(options) {
-    return (options.client ?? this._client).get({
-      url: "/find/file",
-      ...options
-    });
-  }
-  /**
-   * Find workspace symbols
-   */
-  symbols(options) {
-    return (options.client ?? this._client).get({
-      url: "/find/symbol",
-      ...options
-    });
-  }
-}
-class File extends _HeyApiClient {
-  /**
-   * List files and directories
-   */
-  list(options) {
-    return (options.client ?? this._client).get({
-      url: "/file",
-      ...options
-    });
-  }
-  /**
-   * Read a file
-   */
-  read(options) {
-    return (options.client ?? this._client).get({
-      url: "/file/content",
-      ...options
-    });
-  }
-  /**
-   * Get file status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/file/status",
-      ...options
-    });
-  }
-}
-class App extends _HeyApiClient {
-  /**
-   * Write a log entry to the server logs
-   */
-  log(options) {
-    return (options?.client ?? this._client).post({
-      url: "/log",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * List all agents
-   */
-  agents(options) {
-    return (options?.client ?? this._client).get({
-      url: "/agent",
-      ...options
-    });
-  }
-}
-class Auth extends _HeyApiClient {
-  /**
-   * Remove OAuth credentials for an MCP server
-   */
-  remove(options) {
-    return (options.client ?? this._client).delete({
-      url: "/mcp/{name}/auth",
-      ...options
-    });
-  }
-  /**
-   * Start OAuth authentication flow for an MCP server
-   */
-  start(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/auth",
-      ...options
-    });
-  }
-  /**
-   * Complete OAuth authentication with authorization code
-   */
-  callback(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/auth/callback",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  /**
-   * Start OAuth flow and wait for callback (opens browser)
-   */
-  authenticate(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/auth/authenticate",
-      ...options
-    });
-  }
-  /**
-   * Set authentication credentials
-   */
-  set(options) {
-    return (options.client ?? this._client).put({
-      url: "/auth/{id}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-}
-class Mcp extends _HeyApiClient {
-  /**
-   * Get MCP server status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/mcp",
-      ...options
-    });
-  }
-  /**
-   * Add MCP server dynamically
-   */
-  add(options) {
-    return (options?.client ?? this._client).post({
-      url: "/mcp",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Connect an MCP server
-   */
-  connect(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/connect",
-      ...options
-    });
-  }
-  /**
-   * Disconnect an MCP server
-   */
-  disconnect(options) {
-    return (options.client ?? this._client).post({
-      url: "/mcp/{name}/disconnect",
-      ...options
-    });
-  }
-  auth = new Auth({ client: this._client });
-}
-class Lsp extends _HeyApiClient {
-  /**
-   * Get LSP server status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/lsp",
-      ...options
-    });
-  }
-}
-class Formatter extends _HeyApiClient {
-  /**
-   * Get formatter status
-   */
-  status(options) {
-    return (options?.client ?? this._client).get({
-      url: "/formatter",
-      ...options
-    });
-  }
-}
-class Control extends _HeyApiClient {
-  /**
-   * Get the next TUI request from the queue
-   */
-  next(options) {
-    return (options?.client ?? this._client).get({
-      url: "/tui/control/next",
-      ...options
-    });
-  }
-  /**
-   * Submit a response to the TUI request queue
-   */
-  response(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/control/response",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-}
-class Tui extends _HeyApiClient {
-  /**
-   * Append prompt to the TUI
-   */
-  appendPrompt(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/append-prompt",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Open the help dialog
-   */
-  openHelp(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/open-help",
-      ...options
-    });
-  }
-  /**
-   * Open the session dialog
-   */
-  openSessions(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/open-sessions",
-      ...options
-    });
-  }
-  /**
-   * Open the theme dialog
-   */
-  openThemes(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/open-themes",
-      ...options
-    });
-  }
-  /**
-   * Open the model dialog
-   */
-  openModels(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/open-models",
-      ...options
-    });
-  }
-  /**
-   * Submit the prompt
-   */
-  submitPrompt(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/submit-prompt",
-      ...options
-    });
-  }
-  /**
-   * Clear the prompt
-   */
-  clearPrompt(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/clear-prompt",
-      ...options
-    });
-  }
-  /**
-   * Execute a TUI command (e.g. agent_cycle)
-   */
-  executeCommand(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/execute-command",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Show a toast notification in the TUI
-   */
-  showToast(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/show-toast",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  /**
-   * Publish a TUI event
-   */
-  publish(options) {
-    return (options?.client ?? this._client).post({
-      url: "/tui/publish",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers
-      }
-    });
-  }
-  control = new Control({ client: this._client });
-}
-class Event extends _HeyApiClient {
-  /**
-   * Get events
-   */
-  subscribe(options) {
-    return (options?.client ?? this._client).get.sse({
-      url: "/event",
-      ...options
-    });
-  }
-}
-class OpencodeClient extends _HeyApiClient {
-  /**
-   * Respond to a permission request
-   */
-  postSessionIdPermissionsPermissionId(options) {
-    return (options.client ?? this._client).post({
-      url: "/session/{id}/permissions/{permissionID}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  global = new Global({ client: this._client });
-  project = new Project({ client: this._client });
-  pty = new Pty({ client: this._client });
-  config = new Config({ client: this._client });
-  tool = new Tool({ client: this._client });
-  instance = new Instance({ client: this._client });
-  path = new Path({ client: this._client });
-  vcs = new Vcs({ client: this._client });
-  session = new Session({ client: this._client });
-  command = new Command({ client: this._client });
-  provider = new Provider({ client: this._client });
-  find = new Find({ client: this._client });
-  file = new File({ client: this._client });
-  app = new App({ client: this._client });
-  mcp = new Mcp({ client: this._client });
-  lsp = new Lsp({ client: this._client });
-  formatter = new Formatter({ client: this._client });
-  tui = new Tui({ client: this._client });
-  auth = new Auth({ client: this._client });
-  event = new Event({ client: this._client });
-}
-function wrapClientError(error, response, request, opts) {
-  if (!opts?.throwOnError)
-    return error;
-  if (error instanceof Error)
-    return error;
-  if (typeof error === "object" && error !== null && Object.keys(error).length > 0) {
-    const obj = error;
-    const message = typeof obj.data?.message === "string" && obj.data.message || typeof obj.message === "string" && obj.message || typeof obj.name === "string" && obj.name || describe(request, response);
-    return new Error(message, { cause: { body: error, status: response?.status } });
-  }
-  if (typeof error === "string" && error.length > 0) {
-    return new Error(error, { cause: { body: error, status: response?.status } });
-  }
-  const reason = response ? "(empty response body)" : "network error (no response)";
-  return new Error(`opencode server ${describe(request, response)}: ${reason}`, {
-    cause: { body: error, status: response?.status }
-  });
-}
-function describe(request, response) {
-  const method = request?.method ?? "?";
-  const url = request?.url ?? "?";
-  const status = response?.status;
-  const statusText = response?.statusText;
-  return `${method} ${url}${status ? " → " + status : ""}${statusText ? " " + statusText : ""}`;
-}
-function pick(value, fallback) {
-  if (!value)
-    return;
-  if (!fallback)
-    return value;
-  if (value === fallback)
-    return fallback;
-  if (value === encodeURIComponent(fallback))
-    return fallback;
-  return value;
-}
-function rewrite(request, directory) {
-  if (request.method !== "GET" && request.method !== "HEAD")
-    return request;
-  const value = pick(request.headers.get("x-opencode-directory"), directory);
-  if (!value)
-    return request;
-  const url = new URL(request.url);
-  if (!url.searchParams.has("directory")) {
-    url.searchParams.set("directory", value);
-  }
-  const next = new Request(url, request);
-  next.headers.delete("x-opencode-directory");
-  return next;
-}
-function createOpencodeClient(config2) {
-  if (!config2?.fetch) {
-    const customFetch = (req) => {
-      req.timeout = false;
-      return fetch(req);
-    };
-    config2 = {
-      ...config2,
-      fetch: customFetch
-    };
-  }
-  if (config2?.directory) {
-    config2.headers = {
-      ...config2.headers,
-      "x-opencode-directory": encodeURIComponent(config2.directory)
-    };
-  }
-  const client2 = createClient(config2);
-  client2.interceptors.request.use((request) => rewrite(request, config2?.directory));
-  client2.interceptors.error.use(wrapClientError);
-  return new OpencodeClient({ client: client2 });
-}
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-var crossSpawn = { exports: {} };
-var windows;
-var hasRequiredWindows;
-function requireWindows() {
-  if (hasRequiredWindows) return windows;
-  hasRequiredWindows = 1;
-  windows = isexe;
-  isexe.sync = sync;
-  var fs2 = require$$0;
-  function checkPathExt(path2, options) {
-    var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
-    if (!pathext) {
-      return true;
-    }
-    pathext = pathext.split(";");
-    if (pathext.indexOf("") !== -1) {
-      return true;
-    }
-    for (var i2 = 0; i2 < pathext.length; i2++) {
-      var p = pathext[i2].toLowerCase();
-      if (p && path2.substr(-p.length).toLowerCase() === p) {
-        return true;
-      }
-    }
-    return false;
-  }
-  function checkStat(stat2, path2, options) {
-    if (!stat2.isSymbolicLink() && !stat2.isFile()) {
-      return false;
-    }
-    return checkPathExt(path2, options);
-  }
-  function isexe(path2, options, cb) {
-    fs2.stat(path2, function(er, stat2) {
-      cb(er, er ? false : checkStat(stat2, path2, options));
-    });
-  }
-  function sync(path2, options) {
-    return checkStat(fs2.statSync(path2), path2, options);
-  }
-  return windows;
-}
-var mode;
-var hasRequiredMode;
-function requireMode() {
-  if (hasRequiredMode) return mode;
-  hasRequiredMode = 1;
-  mode = isexe;
-  isexe.sync = sync;
-  var fs2 = require$$0;
-  function isexe(path2, options, cb) {
-    fs2.stat(path2, function(er, stat2) {
-      cb(er, er ? false : checkStat(stat2, options));
-    });
-  }
-  function sync(path2, options) {
-    return checkStat(fs2.statSync(path2), options);
-  }
-  function checkStat(stat2, options) {
-    return stat2.isFile() && checkMode(stat2, options);
-  }
-  function checkMode(stat2, options) {
-    var mod = stat2.mode;
-    var uid = stat2.uid;
-    var gid = stat2.gid;
-    var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
-    var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
-    var u2 = parseInt("100", 8);
-    var g = parseInt("010", 8);
-    var o2 = parseInt("001", 8);
-    var ug = u2 | g;
-    var ret = mod & o2 || mod & g && gid === myGid || mod & u2 && uid === myUid || mod & ug && myUid === 0;
-    return ret;
-  }
-  return mode;
-}
-var isexe_1;
-var hasRequiredIsexe;
-function requireIsexe() {
-  if (hasRequiredIsexe) return isexe_1;
-  hasRequiredIsexe = 1;
-  var core;
-  if (process.platform === "win32" || commonjsGlobal.TESTING_WINDOWS) {
-    core = requireWindows();
-  } else {
-    core = requireMode();
-  }
-  isexe_1 = isexe;
-  isexe.sync = sync;
-  function isexe(path2, options, cb) {
-    if (typeof options === "function") {
-      cb = options;
-      options = {};
-    }
-    if (!cb) {
-      if (typeof Promise !== "function") {
-        throw new TypeError("callback not provided");
-      }
-      return new Promise(function(resolve2, reject) {
-        isexe(path2, options || {}, function(er, is) {
-          if (er) {
-            reject(er);
-          } else {
-            resolve2(is);
-          }
-        });
-      });
-    }
-    core(path2, options || {}, function(er, is) {
-      if (er) {
-        if (er.code === "EACCES" || options && options.ignoreErrors) {
-          er = null;
-          is = false;
-        }
-      }
-      cb(er, is);
-    });
-  }
-  function sync(path2, options) {
-    try {
-      return core.sync(path2, options || {});
-    } catch (er) {
-      if (options && options.ignoreErrors || er.code === "EACCES") {
-        return false;
-      } else {
-        throw er;
-      }
-    }
-  }
-  return isexe_1;
-}
-var which_1;
-var hasRequiredWhich;
-function requireWhich() {
-  if (hasRequiredWhich) return which_1;
-  hasRequiredWhich = 1;
-  const isWindows2 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  const path2 = require$$0$1;
-  const COLON = isWindows2 ? ";" : ":";
-  const isexe = requireIsexe();
-  const getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
-  const getPathInfo = (cmd, opt) => {
-    const colon = opt.colon || COLON;
-    const pathEnv = cmd.match(/\//) || isWindows2 && cmd.match(/\\/) ? [""] : [
-      // windows always checks the cwd first
-      ...isWindows2 ? [process.cwd()] : [],
-      ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
-      "").split(colon)
-    ];
-    const pathExtExe = isWindows2 ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
-    const pathExt = isWindows2 ? pathExtExe.split(colon) : [""];
-    if (isWindows2) {
-      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
-        pathExt.unshift("");
-    }
-    return {
-      pathEnv,
-      pathExt,
-      pathExtExe
-    };
-  };
-  const which = (cmd, opt, cb) => {
-    if (typeof opt === "function") {
-      cb = opt;
-      opt = {};
-    }
-    if (!opt)
-      opt = {};
-    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-    const found = [];
-    const step = (i2) => new Promise((resolve2, reject) => {
-      if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
-      const ppRaw = pathEnv[i2];
-      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path2.join(pathPart, cmd);
-      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve2(subStep(p, i2, 0));
-    });
-    const subStep = (p, i2, ii) => new Promise((resolve2, reject) => {
-      if (ii === pathExt.length)
-        return resolve2(step(i2 + 1));
-      const ext = pathExt[ii];
-      isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
-        if (!er && is) {
-          if (opt.all)
-            found.push(p + ext);
-          else
-            return resolve2(p + ext);
-        }
-        return resolve2(subStep(p, i2, ii + 1));
-      });
-    });
-    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
-  };
-  const whichSync = (cmd, opt) => {
-    opt = opt || {};
-    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-    const found = [];
-    for (let i2 = 0; i2 < pathEnv.length; i2++) {
-      const ppRaw = pathEnv[i2];
-      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path2.join(pathPart, cmd);
-      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      for (let j = 0; j < pathExt.length; j++) {
-        const cur = p + pathExt[j];
-        try {
-          const is = isexe.sync(cur, { pathExt: pathExtExe });
-          if (is) {
-            if (opt.all)
-              found.push(cur);
-            else
-              return cur;
-          }
-        } catch (ex) {
-        }
-      }
-    }
-    if (opt.all && found.length)
-      return found;
-    if (opt.nothrow)
-      return null;
-    throw getNotFoundError(cmd);
-  };
-  which_1 = which;
-  which.sync = whichSync;
-  return which_1;
-}
-var pathKey$1 = { exports: {} };
-var hasRequiredPathKey;
-function requirePathKey() {
-  if (hasRequiredPathKey) return pathKey$1.exports;
-  hasRequiredPathKey = 1;
-  const pathKey2 = (options = {}) => {
-    const environment = options.env || process.env;
-    const platform2 = options.platform || process.platform;
-    if (platform2 !== "win32") {
-      return "PATH";
-    }
-    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
-  };
-  pathKey$1.exports = pathKey2;
-  pathKey$1.exports.default = pathKey2;
-  return pathKey$1.exports;
-}
-var resolveCommand_1;
-var hasRequiredResolveCommand;
-function requireResolveCommand() {
-  if (hasRequiredResolveCommand) return resolveCommand_1;
-  hasRequiredResolveCommand = 1;
-  const path2 = require$$0$1;
-  const which = requireWhich();
-  const getPathKey = requirePathKey();
-  function resolveCommandAttempt(parsed, withoutPathExt) {
-    const env = parsed.options.env || process.env;
-    const cwd = process.cwd();
-    const hasCustomCwd = parsed.options.cwd != null;
-    const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
-    if (shouldSwitchCwd) {
-      try {
-        process.chdir(parsed.options.cwd);
-      } catch (err) {
-      }
-    }
-    let resolved;
-    try {
-      resolved = which.sync(parsed.command, {
-        path: env[getPathKey({ env })],
-        pathExt: withoutPathExt ? path2.delimiter : void 0
-      });
-    } catch (e) {
-    } finally {
-      if (shouldSwitchCwd) {
-        process.chdir(cwd);
-      }
-    }
-    if (resolved) {
-      resolved = path2.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
-    }
-    return resolved;
-  }
-  function resolveCommand(parsed) {
-    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
-  }
-  resolveCommand_1 = resolveCommand;
-  return resolveCommand_1;
-}
-var _escape = {};
-var hasRequired_escape;
-function require_escape() {
-  if (hasRequired_escape) return _escape;
-  hasRequired_escape = 1;
-  const metaCharsRegExp2 = /([()\][%!^"`<>&|;, *?])/g;
-  function escapeCommand(arg) {
-    arg = arg.replace(metaCharsRegExp2, "^$1");
-    return arg;
-  }
-  function escapeArgument2(arg, doubleEscapeMetaChars) {
-    arg = `${arg}`;
-    arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
-    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
-    arg = `"${arg}"`;
-    arg = arg.replace(metaCharsRegExp2, "^$1");
-    if (doubleEscapeMetaChars) {
-      arg = arg.replace(metaCharsRegExp2, "^$1");
-    }
-    return arg;
-  }
-  _escape.command = escapeCommand;
-  _escape.argument = escapeArgument2;
-  return _escape;
-}
-var shebangRegex;
-var hasRequiredShebangRegex;
-function requireShebangRegex() {
-  if (hasRequiredShebangRegex) return shebangRegex;
-  hasRequiredShebangRegex = 1;
-  shebangRegex = /^#!(.*)/;
-  return shebangRegex;
-}
-var shebangCommand;
-var hasRequiredShebangCommand;
-function requireShebangCommand() {
-  if (hasRequiredShebangCommand) return shebangCommand;
-  hasRequiredShebangCommand = 1;
-  const shebangRegex2 = requireShebangRegex();
-  shebangCommand = (string2 = "") => {
-    const match = string2.match(shebangRegex2);
-    if (!match) {
-      return null;
-    }
-    const [path2, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary = path2.split("/").pop();
-    if (binary === "env") {
-      return argument;
-    }
-    return argument ? `${binary} ${argument}` : binary;
-  };
-  return shebangCommand;
-}
-var readShebang_1;
-var hasRequiredReadShebang;
-function requireReadShebang() {
-  if (hasRequiredReadShebang) return readShebang_1;
-  hasRequiredReadShebang = 1;
-  const fs2 = require$$0;
-  const shebangCommand2 = requireShebangCommand();
-  function readShebang2(command2) {
-    const size = 150;
-    const buffer = Buffer.alloc(size);
-    let fd;
-    try {
-      fd = fs2.openSync(command2, "r");
-      fs2.readSync(fd, buffer, 0, size, 0);
-      fs2.closeSync(fd);
-    } catch (e) {
-    }
-    return shebangCommand2(buffer.toString());
-  }
-  readShebang_1 = readShebang2;
-  return readShebang_1;
-}
-var parse_1;
-var hasRequiredParse;
-function requireParse() {
-  if (hasRequiredParse) return parse_1;
-  hasRequiredParse = 1;
-  const path2 = require$$0$1;
-  const resolveCommand = requireResolveCommand();
-  const escape = require_escape();
-  const readShebang2 = requireReadShebang();
-  const isWin = process.platform === "win32";
-  const isExecutableRegExp = /\.(?:com|exe)$/i;
-  const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-  function detectShebang(parsed) {
-    parsed.file = resolveCommand(parsed);
-    const shebang = parsed.file && readShebang2(parsed.file);
-    if (shebang) {
-      parsed.args.unshift(parsed.file);
-      parsed.command = shebang;
-      return resolveCommand(parsed);
-    }
-    return parsed.file;
-  }
-  function parseNonShell(parsed) {
-    if (!isWin) {
-      return parsed;
-    }
-    const commandFile = detectShebang(parsed);
-    const needsShell = !isExecutableRegExp.test(commandFile);
-    if (parsed.options.forceShell || needsShell) {
-      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path2.normalize(parsed.command);
-      parsed.command = escape.command(parsed.command);
-      parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
-      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
-      parsed.command = process.env.comspec || "cmd.exe";
-      parsed.options.windowsVerbatimArguments = true;
-    }
-    return parsed;
-  }
-  function parse2(command2, args, options) {
-    if (args && !Array.isArray(args)) {
-      options = args;
-      args = null;
-    }
-    args = args ? args.slice(0) : [];
-    options = Object.assign({}, options);
-    const parsed = {
-      command: command2,
-      args,
-      options,
-      file: void 0,
-      original: {
-        command: command2,
-        args
-      }
-    };
-    return options.shell ? parsed : parseNonShell(parsed);
-  }
-  parse_1 = parse2;
-  return parse_1;
-}
-var enoent;
-var hasRequiredEnoent;
-function requireEnoent() {
-  if (hasRequiredEnoent) return enoent;
-  hasRequiredEnoent = 1;
-  const isWin = process.platform === "win32";
-  function notFoundError(original, syscall) {
-    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
-      code: "ENOENT",
-      errno: "ENOENT",
-      syscall: `${syscall} ${original.command}`,
-      path: original.command,
-      spawnargs: original.args
-    });
-  }
-  function hookChildProcess(cp2, parsed) {
-    if (!isWin) {
-      return;
-    }
-    const originalEmit = cp2.emit;
-    cp2.emit = function(name, arg1) {
-      if (name === "exit") {
-        const err = verifyENOENT(arg1, parsed);
-        if (err) {
-          return originalEmit.call(cp2, "error", err);
-        }
-      }
-      return originalEmit.apply(cp2, arguments);
-    };
-  }
-  function verifyENOENT(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
-      return notFoundError(parsed.original, "spawn");
-    }
-    return null;
-  }
-  function verifyENOENTSync(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
-      return notFoundError(parsed.original, "spawnSync");
-    }
-    return null;
-  }
-  enoent = {
-    hookChildProcess,
-    verifyENOENT,
-    verifyENOENTSync,
-    notFoundError
-  };
-  return enoent;
-}
-var hasRequiredCrossSpawn;
-function requireCrossSpawn() {
-  if (hasRequiredCrossSpawn) return crossSpawn.exports;
-  hasRequiredCrossSpawn = 1;
-  const cp2 = require$$0$2;
-  const parse2 = requireParse();
-  const enoent2 = requireEnoent();
-  function spawn2(command2, args, options) {
-    const parsed = parse2(command2, args, options);
-    const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
-    enoent2.hookChildProcess(spawned, parsed);
-    return spawned;
-  }
-  function spawnSync2(command2, args, options) {
-    const parsed = parse2(command2, args, options);
-    const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
-    result.error = result.error || enoent2.verifyENOENTSync(result.status, parsed);
-    return result;
-  }
-  crossSpawn.exports = spawn2;
-  crossSpawn.exports.spawn = spawn2;
-  crossSpawn.exports.sync = spawnSync2;
-  crossSpawn.exports._parse = parse2;
-  crossSpawn.exports._enoent = enoent2;
-  return crossSpawn.exports;
-}
-var crossSpawnExports = requireCrossSpawn();
-const launch = /* @__PURE__ */ getDefaultExportFromCjs(crossSpawnExports);
-function stop(proc) {
-  if (proc.exitCode !== null || proc.signalCode !== null)
-    return;
-  if (process.platform === "win32" && proc.pid) {
-    const out = spawnSync("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true });
-    if (!out.error && out.status === 0)
-      return;
-  }
-  proc.kill();
-}
-function bindAbort$1(proc, signal, onAbort) {
-  if (!signal)
-    return () => {
-    };
-  const abort = () => {
-    clear();
-    stop(proc);
-    onAbort?.();
-  };
-  const clear = () => {
-    signal.removeEventListener("abort", abort);
-    proc.off("exit", clear);
-    proc.off("error", clear);
-  };
-  signal.addEventListener("abort", abort, { once: true });
-  proc.on("exit", clear);
-  proc.on("error", clear);
-  if (signal.aborted)
-    abort();
-  return clear;
-}
-async function createOpencodeServer(options) {
-  options = Object.assign({
-    hostname: "127.0.0.1",
-    port: 4096,
-    timeout: 5e3
-  }, options ?? {});
-  const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`];
-  if (options.config?.logLevel)
-    args.push(`--log-level=${options.config.logLevel}`);
-  const proc = launch(`opencode`, args, {
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG_CONTENT: JSON.stringify(options.config ?? {})
-    }
-  });
-  let clear = () => {
-  };
-  const url = await new Promise((resolve2, reject) => {
-    const id = setTimeout(() => {
-      clear();
-      stop(proc);
-      reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`));
-    }, options.timeout);
-    let output = "";
-    let resolved = false;
-    proc.stdout?.on("data", (chunk) => {
-      if (resolved)
-        return;
-      output += chunk.toString();
-      const lines = output.split("\n");
-      for (const line of lines) {
-        if (line.startsWith("opencode server listening")) {
-          const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
-          if (!match) {
-            clear();
-            stop(proc);
-            clearTimeout(id);
-            reject(new Error(`Failed to parse server url from output: ${line}`));
-            return;
-          }
-          clearTimeout(id);
-          resolved = true;
-          resolve2(match[1]);
-          return;
-        }
-      }
-    });
-    proc.stderr?.on("data", (chunk) => {
-      output += chunk.toString();
-    });
-    proc.on("exit", (code) => {
-      clearTimeout(id);
-      let msg = `Server exited with code ${code}`;
-      if (output.trim()) {
-        msg += `
-Server output: ${output}`;
-      }
-      reject(new Error(msg));
-    });
-    proc.on("error", (error) => {
-      clearTimeout(id);
-      reject(error);
-    });
-    clear = bindAbort$1(proc, options.signal, () => {
-      clearTimeout(id);
-      reject(options.signal?.reason);
-    });
-  });
-  return {
-    url,
-    close() {
-      clear();
-      stop(proc);
-    }
-  };
+function failure(code, message) {
+  return new AiOperationError({ code, operation: "grok-generate", harness: "grok", message });
 }
 function openCodeCliName(executable) {
   return path.parse(executable).name.toLowerCase() === "opencode2" ? "opencode2" : "opencode";
 }
-function isOpenCodeV2(executable) {
-  return openCodeCliName(executable) === "opencode2";
+function isOpenCodeV2Version(raw) {
+  return /^(?:opencode2?\s+)?v?2\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(stripAnsi(raw).trim());
 }
 function openCodeLoginCommand(cliName) {
   return cliName === "opencode2" ? "opencode2 auth login" : "opencode auth login";
 }
 function parseOpenCodeAuthList(raw, exitCode) {
   if (exitCode !== 0) return "unknown";
-  const text2 = stripAnsi(raw);
-  if (/no authenticated/i.test(text2)) return "unauthenticated";
-  if (/credential/i.test(text2)) return "authenticated";
-  const lines = text2.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  if (lines.some((line) => /^[A-Za-z0-9._-]+$/.test(line) && !/^(providers?|credentials?|integrations?)$/i.test(line))) {
-    return "authenticated";
+  try {
+    const integrations = JSON.parse(stripAnsi(raw).trim());
+    if (!Array.isArray(integrations) || integrations.some((item) => !item || typeof item !== "object" || !Array.isArray(item.connections))) return "unknown";
+    return integrations.some((item) => item.connections.length > 0) ? "authenticated" : "unauthenticated";
+  } catch {
   }
   return "unknown";
 }
 function parseOpenCodeModels(raw) {
   const seen = /* @__PURE__ */ new Set();
-  const models = stripAnsi(raw).split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[A-Za-z0-9._-]+\/[A-Za-z0-9._:/-]+$/.test(line) && !seen.has(line) && seen.add(line)).map((id) => ({ id, label: id }));
-  return [DEFAULT_MODEL, ...models];
-}
-function parseOpenCodeV1Model(value) {
-  const slash = value.indexOf("/");
-  if (slash <= 0 || slash === value.length - 1) throw invalidModel();
-  return { providerID: value.slice(0, slash), modelID: value.slice(slash + 1) };
+  const models = stripAnsi(raw).split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[A-Za-z0-9._-]+\/[A-Za-z0-9._:/-]+(?:#[A-Za-z0-9._-]+)?$/.test(line) && !seen.has(line) && seen.add(line)).map((id) => ({ id, label: id }));
+  return [DEFAULT_MODEL$1, ...models];
 }
 function parseOpenCodeV2ModelRef(value) {
-  const parsed = parseOpenCodeV1Model(value);
-  const hash = parsed.modelID.lastIndexOf("#");
-  if (hash > 0 && hash < parsed.modelID.length - 1) {
-    return { providerID: parsed.providerID, id: parsed.modelID.slice(0, hash), variant: parsed.modelID.slice(hash + 1) };
-  }
-  return { providerID: parsed.providerID, id: parsed.modelID };
+  const match = /^([^/#\s]+)\/([^#\s]+)(?:#([^#\s]+))?$/.exec(value);
+  if (!match?.[1] || !match[2]) throw invalidModel();
+  return { providerID: match[1], id: match[2], ...match[3] ? { variant: match[3] } : {} };
 }
 function parseOpenCodeV2GenerateText(payload) {
   if (!payload || typeof payload !== "object") throw invalidOutput$1();
@@ -14921,12 +13039,12 @@ async function startOpenCodeV2Server(options) {
   });
   void subprocess.catch(() => void 0);
   let settled = false;
-  const stop2 = () => {
+  const stop = () => {
     if (settled) return;
     settled = true;
     stopProcess(subprocess);
   };
-  const unbind = bindAbort(options.signal, stop2);
+  const unbind = bindAbort(options.signal, stop);
   try {
     const url = await waitForListenUrl(subprocess, timeoutMs, options.signal);
     return {
@@ -14934,12 +13052,12 @@ async function startOpenCodeV2Server(options) {
       password,
       close() {
         unbind();
-        stop2();
+        stop();
       }
     };
   } catch (error) {
     unbind();
-    stop2();
+    stop();
     if (options.signal?.aborted) {
       throw new AiOperationError({ code: "AI_CANCELLED", operation: "opencode-server", harness: "opencode", message: "Generation canceled." });
     }
@@ -14952,8 +13070,9 @@ async function generateOpenCodeV2Text(server, input) {
   const created = await v2Request(server, "/api/session", {
     method: "POST",
     body: {
-      title: "OpenTig commit message",
+      title: "OpenTig text generation",
       location: { directory: input.cwd },
+      permissions: [{ action: "*", resource: "*", effect: "deny" }],
       ...model ? { model } : {}
     },
     signal
@@ -15006,7 +13125,7 @@ function throwIfV2Failed(status, payload, signal) {
   if (status === 401 || /not logged|login required|unauth|authentication|sign in/.test(raw)) {
     throw new AiOperationError({ code: "AI_AUTH_REQUIRED", operation: "opencode-generate", harness: "opencode", message: "Sign in to OpenCode to generate the message." });
   }
-  if (/rate.?limit|quota|usage limit|too many requests|credit/.test(raw)) {
+  if (status === 429 || /rate.?limit|quota|usage limit|too many requests|credit/.test(raw)) {
     throw new AiOperationError({ code: "AI_RATE_LIMITED", operation: "opencode-generate", harness: "opencode", message: "OpenCode rejected the request because of a usage limit.", retryable: true });
   }
   if (/model.*(not found|unavailable|invalid|access)|unknown model|no model specified/.test(raw)) {
@@ -15089,7 +13208,7 @@ function freePort() {
     server.on("error", reject);
   });
 }
-const DISABLED_TOOLS = { bash: false, edit: false, write: false, read: false, glob: false, grep: false, webfetch: false, websearch: false, task: false };
+const UNSUPPORTED_MESSAGE = "OpenCode 2.x is required. Upgrade the installed CLI; OpenCode 1 and legacy beta builds are not supported.";
 class OpenCodeProvider {
   constructor(resolver, runner) {
     this.resolver = resolver;
@@ -15101,18 +13220,17 @@ class OpenCodeProvider {
   servers = /* @__PURE__ */ new Set();
   async status(forceRefresh = false) {
     const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const executable = await this.resolver.resolve("opencode", forceRefresh);
-    if (!executable) return { id: this.id, label: "OpenCode", availability: "error", installed: false, authStatus: "unknown", message: "Install OpenCode to use this harness.", models: [DEFAULT_MODEL], checkedAt };
+    const detected = await this.detect(forceRefresh);
+    if (!detected) return { id: this.id, label: "OpenCode", availability: "error", installed: false, authStatus: "unknown", message: "Install OpenCode 2 to use this harness.", models: [DEFAULT_MODEL$1], checkedAt };
+    const { executable, version: version2, compatible } = detected;
     const cliName = openCodeCliName(executable);
-    const catalogArgs = cliName === "opencode2" ? ["models", "--standalone"] : ["models"];
-    const [version2, auth, catalog] = await Promise.all([
-      this.runner.run(executable, ["--version"]),
-      this.runner.run(executable, ["auth", "list"]),
-      this.runner.run(executable, catalogArgs, cliName === "opencode2" ? { timeoutMs: 3e4 } : {})
+    if (!compatible) return { id: this.id, label: "OpenCode", availability: "error", installed: true, authStatus: "unknown", message: UNSUPPORTED_MESSAGE, cliName, version: version2, models: [DEFAULT_MODEL$1], checkedAt };
+    const [auth, catalog] = await Promise.all([
+      this.runner.run(executable, ["auth", "list", "--format", "json", "--standalone"]),
+      this.runner.run(executable, ["models", "--standalone"], { timeoutMs: 3e4 })
     ]);
-    const models = catalog.exitCode === 0 ? parseOpenCodeModels(catalog.stdout) : [DEFAULT_MODEL];
-    let authStatus = parseOpenCodeAuthList(`${auth.stdout}
-${auth.stderr}`, auth.exitCode);
+    const models = catalog.exitCode === 0 ? parseOpenCodeModels(catalog.stdout) : [DEFAULT_MODEL$1];
+    let authStatus = parseOpenCodeAuthList(auth.stdout, auth.exitCode);
     if (authStatus === "unauthenticated" && models.length > 1) authStatus = "unknown";
     const confirmed = authStatus === "authenticated";
     return {
@@ -15122,19 +13240,21 @@ ${auth.stderr}`, auth.exitCode);
       installed: true,
       authStatus,
       cliName,
-      version: version2.stdout.trim() || version2.stderr.trim(),
+      version: version2,
       models,
       checkedAt,
       ...authStatus === "unauthenticated" ? { message: `Run ${openCodeLoginCommand(cliName)}.` } : !confirmed ? { message: "Could not confirm authentication for the selected provider." } : {}
     };
   }
   async generate(input) {
-    const executable = await this.resolver.resolve("opencode");
-    if (!executable) throw new AiOperationError({ code: "AI_CLI_NOT_FOUND", operation: "opencode-generate", harness: this.id, message: "OpenCode is not installed." });
+    const detected = await this.detect(false, input.signal);
+    if (!detected) throw new AiOperationError({ code: "AI_CLI_NOT_FOUND", operation: "opencode-generate", harness: this.id, message: "OpenCode is not installed." });
+    if (!detected.compatible) throw new AiOperationError({ code: "AI_PROCESS_FAILED", operation: "opencode-generate", harness: this.id, message: UNSUPPORTED_MESSAGE });
+    const executable = detected.executable;
     const timeoutSignal = AbortSignal.timeout(AI_PROVIDER_TIMEOUT_MS);
     const boundedInput = { ...input, signal: AbortSignal.any([input.signal, timeoutSignal]) };
     try {
-      return await (isOpenCodeV2(executable) ? this.generateV2(executable, boundedInput) : this.generateV1(boundedInput));
+      return await this.generateV2(executable, boundedInput);
     } catch (error) {
       if (timeoutSignal.aborted && !input.signal.aborted) {
         throw new AiOperationError({ code: "AI_TIMEOUT", operation: "opencode-generate", harness: this.id, message: "Generation took too long.", retryable: true });
@@ -15149,7 +13269,10 @@ ${auth.stderr}`, auth.exitCode);
     });
     this.servers.add(server);
     try {
-      const text2 = await generateOpenCodeV2Text(server, { prompt: input.prompt, model: input.model, cwd: input.repositoryPath, signal: input.signal });
+      const text2 = await generateOpenCodeV2Text(server, { prompt: `Reply with a single JSON object satisfying this JSON Schema:
+${JSON.stringify(input.schema)}
+
+${input.prompt}`, model: input.model, cwd: input.repositoryPath, signal: input.signal });
       return { output: parseJsonPayload(text2), usage: { ...EMPTY_AI_USAGE } };
     } catch (error) {
       if (input.signal.aborted) throw new AiOperationError({ code: "AI_CANCELLED", operation: "opencode-generate", harness: this.id, message: "Generation canceled." });
@@ -15162,53 +13285,22 @@ ${auth.stderr}`, auth.exitCode);
       this.servers.delete(server);
     }
   }
-  async generateV1(input) {
-    const server = await createOpencodeServer({
-      hostname: "127.0.0.1",
-      port: 0,
-      timeout: 15e3,
-      signal: input.signal,
-      config: { share: "disabled", autoupdate: false, plugin: [], instructions: [], tools: DISABLED_TOOLS, permission: { edit: "deny", bash: "deny", webfetch: "deny", external_directory: "deny" } }
-    }).catch(() => {
-      throw new AiOperationError({ code: "AI_PROCESS_FAILED", operation: "opencode-server", harness: this.id, message: "Could not start the local OpenCode server.", retryable: true });
-    });
-    this.servers.add(server);
-    const client2 = createOpencodeClient({ baseUrl: server.url, directory: input.repositoryPath });
-    let sessionId = null;
-    try {
-      const created = await client2.session.create({ body: { title: "OpenTig commit message" }, query: { directory: input.repositoryPath } });
-      if (!created.data?.id) throw new Error("missing session");
-      sessionId = created.data.id;
-      const model = input.model === "default" ? void 0 : parseOpenCodeV1Model(input.model);
-      const response = await client2.session.prompt({
-        path: { id: sessionId },
-        query: { directory: input.repositoryPath },
-        body: {
-          parts: [{ type: "text", text: input.prompt }],
-          tools: DISABLED_TOOLS,
-          // The server API takes no schema, unlike the Codex and Claude CLIs, so
-          // the only way to hold this harness to the contract is the system
-          // prompt. Without it the model answers in whatever shape it likes.
-          system: `Reply with a single JSON object and nothing else. It must satisfy this JSON Schema:
-${JSON.stringify(input.schema)}`,
-          ...model ? { model } : {}
-        }
-      });
-      const infoError = response.data?.info && "error" in response.data.info ? response.data.info.error : void 0;
-      if (infoError) throw new Error("provider rejected request");
-      const text2 = (response.data?.parts ?? []).filter((part) => part.type === "text" && "text" in part && typeof part.text === "string").map((part) => part.text).join("").trim();
-      return { output: parseJsonPayload(text2), usage: openCodeUsage(response.data?.info) };
-    } catch (error) {
-      if (input.signal?.aborted) throw new AiOperationError({ code: "AI_CANCELLED", operation: "opencode-generate", harness: this.id, message: "Generation canceled." });
-      if (error instanceof AiOperationError) throw error;
-      const synthetic = { exitCode: 1, stdout: "", stderr: error instanceof Error ? error.message : "" };
-      requireSuccess(synthetic, this.id, "opencode-generate");
-      throw error;
-    } finally {
-      if (sessionId) await client2.session.delete({ path: { id: sessionId }, query: { directory: input.repositoryPath } }).catch(() => void 0);
-      server.close();
-      this.servers.delete(server);
+  async detect(forceRefresh = false, signal) {
+    const candidates = await this.resolver.resolveAll("opencode", forceRefresh);
+    let first = null;
+    for (const executable of candidates) {
+      try {
+        const result = await this.runner.run(executable, ["--version"], signal ? { signal } : {});
+        const version2 = result.stdout.trim() || result.stderr.trim();
+        const detected = { executable, version: version2, compatible: result.exitCode === 0 && isOpenCodeV2Version(version2) };
+        if (detected.compatible) return detected;
+        first ??= detected;
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        first ??= { executable, version: "", compatible: false };
+      }
     }
+    return first;
   }
   close() {
     for (const server of this.servers) server.close();
@@ -16472,9 +14564,9 @@ function parseNumstat$1(output) {
   const stats = /* @__PURE__ */ new Map();
   const tokens = output.split("\0");
   for (let index = 0; index < tokens.length; index += 1) {
-    const record = tokens[index];
-    if (!record) continue;
-    const match = /^(\d+|-)\t(\d+|-)\t(.*)$/s.exec(record);
+    const record2 = tokens[index];
+    if (!record2) continue;
+    const match = /^(\d+|-)\t(\d+|-)\t(.*)$/s.exec(record2);
     if (!match) continue;
     const binary = match[1] === "-" || match[2] === "-";
     const entry = {
@@ -16495,8 +14587,8 @@ const FIELD = "";
 const RECORD = "";
 const LOG_FORMAT = `%H${FIELD}%h${FIELD}%s${FIELD}%b${FIELD}%an${FIELD}%ae${FIELD}%aI${FIELD}%D${FIELD}%P${RECORD}`;
 function parseLog(output) {
-  return output.split(RECORD).map((record) => record.trim()).filter(Boolean).flatMap((record) => {
-    const fields = record.split(FIELD);
+  return output.split(RECORD).map((record2) => record2.trim()).filter(Boolean).flatMap((record2) => {
+    const fields = record2.split(FIELD);
     if (fields.length < 9) return [];
     const oid = fields[0] ?? "";
     if (!/^[0-9a-f]{40,64}$/i.test(oid)) return [];
@@ -16517,6 +14609,21 @@ function parseLog(output) {
     }];
   });
 }
+function selectHistoryBase(output, upstream) {
+  const refs = output.trim().split("\n").map((line) => {
+    const [ref = "", oid = "", target = ""] = line.split("\0");
+    return { ref, oid, target };
+  }).filter((ref) => /^[a-f0-9]{40,64}$/i.test(ref.oid));
+  const remoteDefaults = refs.filter((ref) => ref.ref.startsWith("refs/remotes/") && ref.ref.endsWith("/HEAD") && ref.target);
+  const preferred = remoteDefaults.filter((ref) => upstream?.startsWith(ref.ref.slice("refs/remotes/".length, -4))).sort((a2, b) => b.ref.length - a2.ref.length)[0] ?? remoteDefaults.find((ref) => ref.ref === "refs/remotes/origin/HEAD");
+  if (preferred) return { ref: preferred.target.replace(/^refs\/(heads|remotes)\//, ""), oid: preferred.oid };
+  const remotePrefix = upstream?.split("/")[0] ?? "origin";
+  for (const name of [`refs/remotes/${remotePrefix}/main`, `refs/remotes/${remotePrefix}/master`, "refs/heads/main", "refs/heads/master"]) {
+    const ref = refs.find((candidate) => candidate.ref === name);
+    if (ref) return { ref: name.replace(/^refs\/(heads|remotes)\//, ""), oid: ref.oid };
+  }
+  return null;
+}
 const REF_FORMAT = "%(refname)%00%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track)%00%(worktreepath)%00%(objectname)%00%(objectname:short)%00%(subject)%00%(authorname)%00%(committerdate:iso-strict)%00";
 const FIELDS_PER_REF = 11;
 function parseRefs(buffer) {
@@ -16618,25 +14725,25 @@ function parseStatus(buffer) {
   };
   const chunks = splitNul(buffer).map((chunk) => chunk.toString("utf8"));
   for (let index = 0; index < chunks.length; index += 1) {
-    const record = chunks[index] ?? "";
-    if (!record) continue;
-    if (record.startsWith("# ")) {
-      parseHeader(record, status);
+    const record2 = chunks[index] ?? "";
+    if (!record2) continue;
+    if (record2.startsWith("# ")) {
+      parseHeader(record2, status);
       continue;
     }
-    if (record.startsWith("? ")) {
-      status.changes.push(makeChange(record.slice(2), "?", "?"));
+    if (record2.startsWith("? ")) {
+      status.changes.push(makeChange(record2.slice(2), "?", "?"));
       continue;
     }
-    if (record.startsWith("1 ") || record.startsWith("u ")) {
-      const fields = record.split(" ");
+    if (record2.startsWith("1 ") || record2.startsWith("u ")) {
+      const fields = record2.split(" ");
       const xy = fields[1] ?? "..";
-      const pathIndex = record.startsWith("1 ") ? 8 : 10;
+      const pathIndex = record2.startsWith("1 ") ? 8 : 10;
       status.changes.push(makeChange(fields.slice(pathIndex).join(" "), xy[0] ?? ".", xy[1] ?? ".", fields[2] ?? ""));
       continue;
     }
-    if (record.startsWith("2 ")) {
-      const fields = record.split(" ");
+    if (record2.startsWith("2 ")) {
+      const fields = record2.split(" ");
       const xy = fields[1] ?? "..";
       const next = chunks[index + 1] ?? "";
       const pathValue = fields.slice(9).join(" ");
@@ -16984,14 +15091,18 @@ ${base}
       if (cursor && commits[0]?.oid === cursor) commits = commits.slice(1);
       const hasMore = commits.length > 100;
       commits = commits.slice(0, 100);
-      const localOids = await this.localOnlyOids(repository.path, status.upstream, status.detached || status.unborn);
+      const [localOids, base] = await Promise.all([
+        this.localOnlyOids(repository.path, status.upstream, status.detached || status.unborn),
+        this.historyBase(repository.path, revision2, status.upstream)
+      ]);
       commits = commits.map((commit) => ({
         ...commit,
         isHead: commit.oid === status.oid,
-        upstreamState: localOids === null ? "unknown" : localOids.has(commit.oid) ? "local-only" : "published"
+        upstreamState: localOids === null ? "unknown" : localOids.has(commit.oid) ? "local-only" : "published",
+        baseState: base === null ? "unknown" : base.outside.has(commit.oid) ? "outside" : "included"
       }));
       for (const commit of commits) this.rememberOid(repositoryId, commit.oid);
-      return { commits, nextCursor: hasMore ? commits.at(-1)?.oid ?? null : null };
+      return { commits, nextCursor: hasMore ? commits.at(-1)?.oid ?? null : null, baseRef: base?.ref ?? null };
     } catch (error) {
       if (!cursor && error instanceof GitOperationError && /does not have any commits|unknown revision|bad revision/i.test(error.message)) return { commits: [], nextCursor: null };
       throw error;
@@ -17564,6 +15675,18 @@ ${body}
     const status = await this.repositories.status(repositoryId, false);
     if (status.readOnly) throw new GitOperationError({ code: "INVALID_ARGUMENT", operation: "write", message: `The repository is in the middle of ${status.operation}; OpenTig keeps it read-only.` });
   }
+  async historyBase(repositoryPath, revision2, upstream) {
+    try {
+      const options = { operation: "history-base", readOnly: true, maxOutputBytes: 8 * 1024 * 1024 };
+      const refs = await this.git.run(repositoryPath, ["for-each-ref", "--format=%(refname)%00%(objectname)%00%(symref)", "refs/heads/main", "refs/heads/master", "refs/remotes"], options);
+      const base = selectHistoryBase(refs.stdout.toString("utf8"), upstream);
+      if (!base) return null;
+      const output = await this.git.run(repositoryPath, ["rev-list", revision2, `^${base.oid}`, "--"], options);
+      return { ref: base.ref, outside: new Set(output.stdout.toString("utf8").trim().split("\n").filter(Boolean)) };
+    } catch {
+      return null;
+    }
+  }
   async localOnlyOids(repositoryPath, upstream, unavailable) {
     if (!upstream || unavailable) return null;
     try {
@@ -18253,6 +16376,73 @@ function revision(bytes) {
 function invalidReplacement(message) {
   return new GitOperationError({ code: "INVALID_ARGUMENT", operation: "replace-search", message });
 }
+const positive = number().int().positive().safe();
+const membershipSchema = object({
+  stack: object({ number: positive, size: positive, baseRefName: string().min(1) }).nullable(),
+  stackEntry: object({ position: positive }).nullable()
+});
+const stackSchema = object({
+  number: positive,
+  base: union([string().min(1), object({ ref: string().min(1) })]),
+  pull_requests: array(object({
+    number: positive,
+    title: string().optional(),
+    draft: boolean().optional(),
+    head: object({ ref: string().min(1) }),
+    state: _enum(["open", "closed", "merged"]),
+    merged_at: string().nullable().optional()
+  })).min(1)
+});
+function invalid() {
+  return new GhOperationError({ code: "GH_INVALID_OUTPUT", operation: "gh-pr-stack", message: "GitHub returned unreadable stack information." });
+}
+function json(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw invalid();
+  }
+}
+function stackMembershipQuery(numbers) {
+  if (!numbers.length || numbers.some((number2) => !positive.safeParse(number2).success)) throw invalid();
+  return `query($owner:String!,$name:String!){repository(owner:$owner,name:$name){${numbers.map((number2) => `pr${number2}:pullRequest(number:${number2}){stack{number size baseRefName} stackEntry{position}}`).join(" ")}}}`;
+}
+function parseStackMemberships(raw, numbers) {
+  const envelope = object({ data: object({ repository: record(string(), membershipSchema.nullable()) }), errors: array(unknown()).optional() }).safeParse(json(raw));
+  if (!envelope.success || envelope.data.errors?.length) throw invalid();
+  const result = /* @__PURE__ */ new Map();
+  for (const number2 of numbers) {
+    const entry = envelope.data.data.repository[`pr${number2}`];
+    if (entry === void 0) throw invalid();
+    if (!entry?.stack && !entry?.stackEntry) continue;
+    if (!entry?.stack || !entry.stackEntry || entry.stackEntry.position > entry.stack.size) throw invalid();
+    result.set(number2, { number: entry.stack.number, size: entry.stack.size, position: entry.stackEntry.position, base: entry.stack.baseRefName });
+  }
+  return result;
+}
+function parsePullRequestStack(raw, prNumber, listing = false) {
+  let value = json(raw);
+  if (listing) {
+    if (!Array.isArray(value) || value.length > 1) throw invalid();
+    if (!value.length) return null;
+    value = value[0];
+  }
+  const parsed = stackSchema.safeParse(value);
+  if (!parsed.success) throw invalid();
+  const stack = parsed.data;
+  if (!stack.pull_requests.some((pr) => pr.number === prNumber) || new Set(stack.pull_requests.map((pr) => pr.number)).size !== stack.pull_requests.length) throw invalid();
+  return {
+    number: stack.number,
+    base: typeof stack.base === "string" ? stack.base : stack.base.ref,
+    layers: stack.pull_requests.map((pr) => ({
+      number: pr.number,
+      title: pr.title || pr.head.ref,
+      headRefName: pr.head.ref,
+      state: pr.merged_at || pr.state === "merged" ? "MERGED" : pr.state === "closed" ? "CLOSED" : "OPEN",
+      isDraft: pr.draft ?? false
+    }))
+  };
+}
 const OWNER_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/;
 const REPO_PATTERN = /^[A-Za-z0-9._-]+$/;
 function parseGitHubRemote(url) {
@@ -18292,13 +16482,13 @@ function parsePullRequestList(raw) {
 function parsePullRequestDetails(raw) {
   const item = parseJson(raw, "gh-pr-view");
   const summary = parseSummary(item, "gh-pr-view");
-  const record = item;
+  const record2 = item;
   return {
     ...summary,
-    body: typeof record.body === "string" ? record.body : "",
-    changedFiles: numberOrZero(record.changedFiles),
-    labels: parseLabels(record.labels),
-    commits: parseCommits(record.commits)
+    body: typeof record2.body === "string" ? record2.body : "",
+    changedFiles: numberOrZero(record2.changedFiles),
+    labels: parseLabels(record2.labels),
+    commits: parseCommits(record2.commits)
   };
 }
 function sortPullRequestsNewestFirst(pulls) {
@@ -18325,27 +16515,27 @@ function parseCreatedPullRequestUrl(stdout) {
 function parseSummary(item, operation) {
   const parsed = summaryRecordSchema.safeParse(item);
   if (!parsed.success) throw invalidOutput(operation);
-  const record = parsed.data;
+  const record2 = parsed.data;
   const { number: number2, state } = parsed.data;
-  const parsedAuthor = tolerantRecordSchema.safeParse(record.author);
+  const parsedAuthor = tolerantRecordSchema.safeParse(record2.author);
   const authorRecord = parsedAuthor.success ? parsedAuthor.data : null;
   const author = authorRecord?.login;
   const authorLogin = typeof author === "string" ? author : "unknown";
   return {
     number: number2,
-    title: typeof record.title === "string" ? record.title : "",
+    title: typeof record2.title === "string" ? record2.title : "",
     state,
-    isDraft: record.isDraft === true,
+    isDraft: record2.isDraft === true,
     author: authorLogin,
     authorAvatarUrl: avatarUrl(authorLogin, authorRecord?.is_bot === true),
-    headRefName: typeof record.headRefName === "string" ? record.headRefName : "",
-    baseRefName: typeof record.baseRefName === "string" ? record.baseRefName : "",
-    updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : "",
-    url: typeof record.url === "string" ? record.url : "",
-    reviewDecision: typeof record.reviewDecision === "string" && record.reviewDecision ? record.reviewDecision : null,
-    additions: numberOrZero(record.additions),
-    deletions: numberOrZero(record.deletions),
-    checksState: parseChecksState(record.statusCheckRollup)
+    headRefName: typeof record2.headRefName === "string" ? record2.headRefName : "",
+    baseRefName: typeof record2.baseRefName === "string" ? record2.baseRefName : "",
+    updatedAt: typeof record2.updatedAt === "string" ? record2.updatedAt : "",
+    url: typeof record2.url === "string" ? record2.url : "",
+    reviewDecision: typeof record2.reviewDecision === "string" && record2.reviewDecision ? record2.reviewDecision : null,
+    additions: numberOrZero(record2.additions),
+    deletions: numberOrZero(record2.deletions),
+    checksState: parseChecksState(record2.statusCheckRollup)
   };
 }
 function parseLabels(value) {
@@ -18354,10 +16544,10 @@ function parseLabels(value) {
   return parsed.data.flatMap((item) => {
     const candidate = tolerantRecordSchema.safeParse(item);
     if (!candidate.success) return [];
-    const record = candidate.data;
-    if (typeof record.name !== "string" || !record.name) return [];
-    const color = typeof record.color === "string" && /^[0-9a-f]{6}$/i.test(record.color) ? record.color : "6e7781";
-    return [{ name: record.name, color }];
+    const record2 = candidate.data;
+    if (typeof record2.name !== "string" || !record2.name) return [];
+    const color = typeof record2.color === "string" && /^[0-9a-f]{6}$/i.test(record2.color) ? record2.color : "6e7781";
+    return [{ name: record2.name, color }];
   });
 }
 function parseCommits(value) {
@@ -18366,16 +16556,16 @@ function parseCommits(value) {
   return parsed.data.flatMap((item) => {
     const candidate = tolerantRecordSchema.safeParse(item);
     if (!candidate.success) return [];
-    const record = candidate.data;
-    if (typeof record.oid !== "string" || !record.oid) return [];
-    const authors = Array.isArray(record.authors) ? record.authors : [];
+    const record2 = candidate.data;
+    if (typeof record2.oid !== "string" || !record2.oid) return [];
+    const authors = Array.isArray(record2.authors) ? record2.authors : [];
     const authorRecord = authors.map((author) => tolerantRecordSchema.safeParse(author)).find((author) => author.success)?.data;
     const login = typeof authorRecord?.login === "string" ? authorRecord.login : null;
     const name = typeof authorRecord?.name === "string" && authorRecord.name ? authorRecord.name : login ?? "unknown";
     return [{
-      oid: record.oid,
-      messageHeadline: typeof record.messageHeadline === "string" ? record.messageHeadline : "",
-      authoredAt: typeof record.authoredDate === "string" ? record.authoredDate : "",
+      oid: record2.oid,
+      messageHeadline: typeof record2.messageHeadline === "string" ? record2.messageHeadline : "",
+      authoredAt: typeof record2.authoredDate === "string" ? record2.authoredDate : "",
       author: name,
       authorAvatarUrl: login ? avatarUrl(login, login.endsWith("[bot]")) : null
     }];
@@ -18387,11 +16577,11 @@ function parseChecksState(value) {
   for (const item of value) {
     const parsed = tolerantRecordSchema.safeParse(item);
     if (!parsed.success) continue;
-    const record = parsed.data;
-    const conclusion = typeof record.conclusion === "string" ? record.conclusion.toUpperCase() : "";
-    const state = typeof record.state === "string" ? record.state.toUpperCase() : "";
+    const record2 = parsed.data;
+    const conclusion = typeof record2.conclusion === "string" ? record2.conclusion.toUpperCase() : "";
+    const state = typeof record2.state === "string" ? record2.state.toUpperCase() : "";
     if (["FAILURE", "ERROR", "TIMED_OUT", "CANCELLED", "ACTION_REQUIRED", "STARTUP_FAILURE"].includes(conclusion || state)) return "FAILING";
-    const status = typeof record.status === "string" ? record.status.toUpperCase() : "";
+    const status = typeof record2.status === "string" ? record2.status.toUpperCase() : "";
     if (status && status !== "COMPLETED" || ["PENDING", "EXPECTED"].includes(state)) pending = true;
   }
   return pending ? "PENDING" : "PASSING";
@@ -18456,7 +16646,7 @@ class GitHubService {
       ["pr", "list", "-R", nameWithOwner, "--state", state.toLowerCase(), "--json", PR_SUMMARY_FIELDS, "--limit", "50"],
       { cwd: repository.path, operation: "gh-pr-list", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 }
     )));
-    return selectPullRequestsNewestFirst(results.flatMap((result) => parsePullRequestList(result.stdout)), states);
+    return this.withStackMembership(repository.path, nameWithOwner, selectPullRequestsNewestFirst(results.flatMap((result) => parsePullRequestList(result.stdout)), states));
   }
   async findPullRequestForBranch(repositoryId, branchName) {
     const operation = "gh-pr-for-branch";
@@ -18474,7 +16664,51 @@ class GitHubService {
       ["pr", "view", String(prNumber), "-R", nameWithOwner, "--json", PR_DETAIL_FIELDS],
       { cwd: repository.path, operation: "gh-pr-view", timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 }
     );
-    return parsePullRequestDetails(result.stdout);
+    const details = parsePullRequestDetails(result.stdout);
+    return (await this.withStackMembership(repository.path, nameWithOwner, [details]))[0];
+  }
+  async withStackMembership(cwd, nameWithOwner, pulls) {
+    const [owner, name] = nameWithOwner.split("/");
+    const enriched = [];
+    for (let start = 0; start < pulls.length; start += 25) {
+      const batch = pulls.slice(start, start + 25);
+      try {
+        const numbers = batch.map((pr) => pr.number);
+        const result = await this.runGh(["api", "graphql", "-f", `owner=${owner}`, "-f", `name=${name}`, "-f", `query=${stackMembershipQuery(numbers)}`], {
+          cwd,
+          operation: "gh-pr-stack-membership",
+          timeoutMs: 1e4,
+          maxOutputBytes: 1024 * 1024
+        });
+        const memberships = parseStackMemberships(result.stdout, numbers);
+        enriched.push(...batch.map((pr) => {
+          const stack = memberships.get(pr.number);
+          return stack ? { ...pr, stack } : pr;
+        }));
+      } catch {
+        enriched.push(...batch);
+      }
+    }
+    return enriched;
+  }
+  async getPullRequestStack(repositoryId, prNumber) {
+    const operation = "gh-pr-stack";
+    const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, operation);
+    const options = { cwd: repository.path, operation, timeoutMs: NETWORK_TIMEOUT_MS, maxOutputBytes: 4 * 1024 * 1024 };
+    const read = async (endpoint) => this.runGh(["api", endpoint], options);
+    let listing;
+    try {
+      listing = await read(`repos/${nameWithOwner}/stacks?pull_request=${prNumber}`);
+    } catch (error) {
+      if (error instanceof GhOperationError && error.detail.code === "GH_PROCESS_FAILED" && /HTTP 404/.test(error.message)) return null;
+      throw error;
+    }
+    const stack = parsePullRequestStack(listing.stdout, prNumber, true);
+    if (!stack) return null;
+    const details = await read(`repos/${nameWithOwner}/stacks/${stack.number}`);
+    const complete = parsePullRequestStack(details.stdout, prNumber);
+    if (complete?.number !== stack.number) throw new GhOperationError({ code: "GH_INVALID_OUTPUT", operation, message: "The stack changed while loading. Refresh to try again." });
+    return complete;
   }
   async getPullRequestDiff(repositoryId, prNumber) {
     const { repository, nameWithOwner } = await this.requireGitHub(repositoryId, "gh-pr-diff");
@@ -18718,7 +16952,7 @@ class ProblemsLogStore {
     this.loaded = true;
   }
   record(entry) {
-    const record = {
+    const record2 = {
       id: randomUUID(),
       at: (/* @__PURE__ */ new Date()).toISOString(),
       level: entry.level ?? "error",
@@ -18728,7 +16962,7 @@ class ProblemsLogStore {
       message: entry.message,
       repositoryId: entry.repositoryId ?? null
     };
-    const normalized = normalizeProblemLogEntry(record);
+    const normalized = normalizeProblemLogEntry(record2);
     if (!normalized) return;
     this.pending = this.pending.then(async () => {
       await mkdir(path.dirname(this.filePath), { recursive: true });
@@ -18827,10 +17061,10 @@ resolveShortcuts();
 function sanitizeShortcutOverrides(value) {
   const result = {};
   if (!value || typeof value !== "object") return result;
-  const record = value;
+  const record2 = value;
   const usedCombos = /* @__PURE__ */ new Set();
   for (const def of SHORTCUT_DEFINITIONS) {
-    const combo = record[def.id];
+    const combo = record2[def.id];
     if (typeof combo !== "string" || combo === def.defaultCombo) continue;
     if (!isValidCombo(combo, def.allowBare)) continue;
     if (RESERVED_COMBOS.has(combo) || usedCombos.has(combo)) continue;
@@ -19028,7 +17262,7 @@ const defaults = {
     uiFont: "plus-jakarta-sans",
     monoFont: "jetbrains-mono",
     commitMessageHarness: "codex",
-    commitMessageModels: { codex: "default", claude: "default", opencode: "default" },
+    commitMessageModels: { codex: "default", claude: "default", opencode: "default", grok: "default" },
     shortcutOverrides: {},
     doubleControlShortcutEnabled: true,
     remoteFetchIntervalSeconds: DEFAULT_REMOTE_FETCH_INTERVAL_SECONDS
@@ -19435,7 +17669,7 @@ function projectError(message) {
   return new GitOperationError({ code: "INVALID_ARGUMENT", operation: "repository-projects", message });
 }
 function isHarness(value) {
-  return value === "codex" || value === "claude" || value === "opencode";
+  return value === "codex" || value === "claude" || value === "opencode" || value === "grok";
 }
 function normalizeUiFont(value) {
   if (value === "cabinet-grotesk" || value === "satoshi") return "plus-jakarta-sans";
@@ -19450,9 +17684,9 @@ function normalizeSidebarWidth(value) {
   return Math.max(300, Math.min(680, width));
 }
 function modelPreferences(value) {
-  const result = { codex: "default", claude: "default", opencode: "default" };
+  const result = { codex: "default", claude: "default", opencode: "default", grok: "default" };
   if (!value || typeof value !== "object") return result;
-  for (const harness of ["codex", "claude", "opencode"]) {
+  for (const harness of ["codex", "claude", "opencode", "grok"]) {
     const model = value[harness];
     if (typeof model === "string" && model.length > 0 && model.length <= 200 && !hasControlCharacters$1(model)) result[harness] = model;
   }
@@ -19595,7 +17829,8 @@ async function createOpenTigRuntime(options) {
   const providers = [
     new CodexProvider(cliResolver, cliRunner),
     new ClaudeProvider(cliResolver, cliRunner),
-    new OpenCodeProvider(cliResolver, cliRunner)
+    new OpenCodeProvider(cliResolver, cliRunner),
+    new GrokProvider(cliResolver, cliRunner)
   ];
   const aiLog = new AiLogStore(options.aiLogPath);
   await aiLog.load();
@@ -19836,6 +18071,7 @@ const IPC = {
   githubPrForBranch: "github:pr-for-branch",
   githubPrList: "github:pr-list",
   githubPrView: "github:pr-view",
+  githubPrStack: "github:pr-stack",
   githubPrDiff: "github:pr-diff",
   githubPrCommitDiff: "github:pr-commit-diff",
   githubPrCreate: "github:pr-create",
@@ -19920,6 +18156,7 @@ const OPEN_TIG_SERVER_COMMANDS = {
   "github.findPullRequestForBranch": command(IPC.githubPrForBranch, "gh-pr-for-branch", false),
   "github.listPullRequests": command(IPC.githubPrList, "gh-pr-list", false),
   "github.getPullRequest": command(IPC.githubPrView, "gh-pr-view", false),
+  "github.getPullRequestStack": command(IPC.githubPrStack, "gh-pr-stack", false),
   "github.getPullRequestDiff": command(IPC.githubPrDiff, "gh-pr-diff", false),
   "github.getPullRequestCommitDiff": command(IPC.githubPrCommitDiff, "gh-pr-commit-diff", false),
   "github.createPullRequest": command(IPC.githubPrCreate, "gh-pr-create", true),
@@ -20115,7 +18352,7 @@ const searchOptionsSchema = object({
   includeIgnored: unknown().optional()
 });
 const openFileTabSchema = object({ path: unknown(), pinned: boolean() });
-const aiHarnessSchema = _enum(["codex", "claude", "opencode"]);
+const aiHarnessSchema = _enum(["codex", "claude", "opencode", "grok"]);
 const pullRequestStateSchema = _enum(["OPEN", "CLOSED", "MERGED"]);
 function stringArg(value, operation, maxLength = 32768) {
   const parsed = boundedStringSchema(maxLength, { controls: false }).safeParse(value);
@@ -20169,28 +18406,28 @@ function filesTreeStateArg(repositoryId, value, operation) {
   return { repositoryId, expandedPaths: normalizeExpandedPaths(expandedPaths) };
 }
 function openFilesStateArg(repositoryId, tabs, activePath, previewPath, operation) {
-  const invalid = () => new GitOperationError({ code: "INVALID_ARGUMENT", operation, message: "Invalid open files state." });
+  const invalid2 = () => new GitOperationError({ code: "INVALID_ARGUMENT", operation, message: "Invalid open files state." });
   const parsedTabs = array(openFileTabSchema).max(MAX_OPEN_FILE_TABS).safeParse(tabs);
-  if (!isOpenFilesRepositoryId(repositoryId) || !parsedTabs.success) throw invalid();
+  if (!isOpenFilesRepositoryId(repositoryId) || !parsedTabs.success) throw invalid2();
   const normalizedTabs = [];
   const seen = /* @__PURE__ */ new Set();
   for (const input of parsedTabs.data) {
     const path2 = normalizeOpenFilePath(input.path);
-    if (!path2 || typeof input.pinned !== "boolean") throw invalid();
+    if (!path2 || typeof input.pinned !== "boolean") throw invalid2();
     if (seen.has(path2)) continue;
     seen.add(path2);
     normalizedTabs.push({ path: path2, pinned: input.pinned });
   }
-  const active = optionalOpenFilePath(activePath, invalid);
-  const preview = optionalOpenFilePath(previewPath, invalid);
-  if (active && !seen.has(active)) throw invalid();
-  if (preview && !seen.has(preview)) throw invalid();
+  const active = optionalOpenFilePath(activePath, invalid2);
+  const preview = optionalOpenFilePath(previewPath, invalid2);
+  if (active && !seen.has(active)) throw invalid2();
+  if (preview && !seen.has(preview)) throw invalid2();
   return { repositoryId, tabs: normalizedTabs, activePath: active, previewPath: preview };
 }
-function optionalOpenFilePath(value, invalid) {
+function optionalOpenFilePath(value, invalid2) {
   if (value === null || value === void 0) return null;
   const normalized = normalizeOpenFilePath(value);
-  if (!normalized) throw invalid();
+  if (!normalized) throw invalid2();
   return normalized;
 }
 function projectNameArg(value, operation) {
@@ -20770,6 +19007,7 @@ function registerServerCommands(registry2, services, host) {
     pullRequestStatesArg(states, "gh-pr-list")
   ));
   handle(IPC.githubPrView, "gh-pr-view", (id, prNumber) => services.github.getPullRequest(stringArg(id, "gh-pr-view", 64), prNumberArg(prNumber, "gh-pr-view")));
+  handle(IPC.githubPrStack, "gh-pr-stack", (id, prNumber) => services.github.getPullRequestStack(stringArg(id, "gh-pr-stack", 64), prNumberArg(prNumber, "gh-pr-stack")));
   handle(IPC.githubPrDiff, "gh-pr-diff", (id, prNumber) => services.github.getPullRequestDiff(stringArg(id, "gh-pr-diff", 64), prNumberArg(prNumber, "gh-pr-diff")));
   handle(IPC.githubPrCommitDiff, "gh-pr-commit-diff", (id, oid) => services.github.getPullRequestCommitDiff(stringArg(id, "gh-pr-commit-diff", 64), oidArg(oid, "gh-pr-commit-diff")));
   handle(IPC.githubPrCreate, "gh-pr-create", (input) => services.github.createPullRequest(createPullRequestArg(input)));
@@ -21804,12 +20042,12 @@ class OpenTigWebSocketTransport {
   upgradeHandler;
   closePromise = null;
   get connectedSessionCount() {
-    return new Set([...this.clients.values()].map((client2) => client2.sessionId)).size;
+    return new Set([...this.clients.values()].map((client) => client.sessionId)).size;
   }
   connectionCount(sessionId) {
     let count2 = 0;
-    for (const client2 of this.clients.values()) {
-      if (client2.sessionId === sessionId) count2 += 1;
+    for (const client of this.clients.values()) {
+      if (client.sessionId === sessionId) count2 += 1;
     }
     return count2;
   }
@@ -21855,7 +20093,7 @@ class OpenTigWebSocketTransport {
     socket.on("close", () => {
       for (const controller of state.requests.values()) controller.abort();
       this.clients.delete(socket);
-      if (![...this.clients.values()].some((client2) => client2.sessionId === sessionId)) {
+      if (![...this.clients.values()].some((client) => client.sessionId === sessionId)) {
         this.options.registry.clearSession(sessionId);
       }
     });