@opentig/cli 0.1.7 → 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;
@@ -11529,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);
@@ -11854,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({
@@ -12134,7 +12135,7 @@ 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) {
@@ -12194,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) {
@@ -12293,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,
@@ -12301,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,
@@ -12375,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) {
@@ -12428,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);
@@ -12469,7 +12470,20 @@ 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 record2 = envelope;
@@ -12507,20 +12521,6 @@ function codexUsage(stdout) {
     costUsd: null
   };
 }
-function openCodeUsage(info) {
-  if (!info || typeof info !== "object") return { ...EMPTY_AI_USAGE };
-  const record2 = info;
-  const tokens = record2.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(record2.cost, true)
-  };
-}
 function count(value, fractional = false) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
   return fractional ? value : Math.round(value);
@@ -12569,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"), "");
@@ -12663,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;
@@ -12725,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",
@@ -12769,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 [DEFAULT_MODEL$1];
   }
-  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);
-    }
-  }
-  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
-    });
-  }
+function failure(code, message) {
+  return new AiOperationError({ code, operation: "grok-generate", harness: "grok", message });
 }
-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
-    });
-  }
+function openCodeCliName(executable) {
+  return path.parse(executable).name.toLowerCase() === "opencode2" ? "opencode2" : "opencode";
 }
-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
-    });
-  }
+function isOpenCodeV2Version(raw) {
+  return /^(?:opencode2?\s+)?v?2\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(stripAnsi(raw).trim());
 }
-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
-    });
-  }
+function openCodeLoginCommand(cliName) {
+  return cliName === "opencode2" ? "opencode2 auth login" : "opencode auth login";
 }
-class Instance extends _HeyApiClient {
-  /**
-   * Dispose the current instance
-   */
-  dispose(options) {
-    return (options?.client ?? this._client).post({
-      url: "/instance/dispose",
-      ...options
-    });
+function parseOpenCodeAuthList(raw, exitCode) {
+  if (exitCode !== 0) return "unknown";
+  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 {
   }
-}
-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 openCodeCliName(executable) {
-  return path.parse(executable).name.toLowerCase() === "opencode2" ? "opencode2" : "opencode";
-}
-function isOpenCodeV2(executable) {
-  return openCodeCliName(executable) === "opencode2";
-}
-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";
-  }
-  return "unknown";
+  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();
@@ -15070,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 {
@@ -15083,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." });
     }
@@ -15101,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
@@ -15155,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)) {
@@ -15238,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;
@@ -15250,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 {
@@ -15271,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 });
@@ -15298,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." });
@@ -15311,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();
@@ -19319,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
@@ -19726,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";
@@ -19741,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;
   }
@@ -19886,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();
@@ -20408,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);
@@ -22098,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;
   }
@@ -22149,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);
       }
     });