@zhivex-ai/harness 1.1.1 → 1.2.0-rc.13

package/dist/cli-entry-427869g9.js

@@ -0,0 +1,2009 @@
+// src/providers/reasoning.ts
+import { z as z2 } from "zod";
+import { wrapLanguageModel as wrapLanguageModel4 } from "@zhivex-ai/core";
+
+// src/providers/qwen-hosted-policy.ts
+import { wrapLanguageModel } from "@zhivex-ai/core";
+function withQwenHostedPolicy(model) {
+  if (model.modelId !== "kimi-k3")
+    return model;
+  const prepare = (input) => {
+    const options = input.providerOptions ?? {};
+    if (options.apiMode && !["auto", "chat"].includes(String(options.apiMode)))
+      throw new Error("Kimi K3 on Model Studio requires Chat Completions.");
+    if (input.reasoning?.effort !== undefined || input.reasoning?.budgetTokens !== undefined || options.reasoning_effort !== undefined || options.thinking_budget !== undefined || options.enable_thinking === false) {
+      throw new Error("Kimi K3 on Model Studio currently supports default thinking only.");
+    }
+    input.providerOptions = { ...options, apiMode: "chat", enable_thinking: true };
+  };
+  const wrapped = wrapLanguageModel(model, [{
+    name: "harness-kimi-k3-chat-thinking-v1",
+    async wrapGenerate(context, next) {
+      prepare(context.input);
+      return next();
+    },
+    async wrapStream(context, next) {
+      prepare(context.input);
+      return next();
+    }
+  }]);
+  return { ...wrapped, capabilities: {
+    ...wrapped.capabilities,
+    reasoningEfforts: [],
+    webSearch: false,
+    ...wrapped.capabilities.agentCapabilities ? { agentCapabilities: { ...wrapped.capabilities.agentCapabilities, hostedWebSearch: false, codeExecution: false, webExtraction: false } } : {}
+  } };
+}
+
+// src/providers/meta-continuation.ts
+import { setTimeout as delay } from "node:timers/promises";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isReceiptContinuation = (input, init) => {
+  if (init?.method !== "POST" || typeof init.body !== "string")
+    return false;
+  try {
+    const url = new URL(typeof input === "string" ? input : input instanceof URL ? input.href : input.url);
+    if (!url.pathname.endsWith("/responses"))
+      return false;
+    const body = JSON.parse(init.body);
+    if (!isRecord(body))
+      return false;
+    return typeof body.previous_response_id === "string" && body.previous_response_id.length > 0 && Array.isArray(body.input) && body.input.length > 0 && body.input.every((item) => isRecord(item) && item.type === "function_call_output" && typeof item.call_id === "string" && typeof item.output === "string") && Array.isArray(body.tools) && body.tools.every((tool) => isRecord(tool) && tool.type === "function");
+  } catch {
+    return false;
+  }
+};
+var isUnavailableResponse = async (response) => {
+  const reader = response.clone().body?.getReader();
+  if (!reader)
+    return false;
+  const chunks = [];
+  let size = 0;
+  try {
+    for (;; ) {
+      const next = await reader.read();
+      if (next.done)
+        break;
+      size += next.value.byteLength;
+      if (size > 8192)
+        return false;
+      chunks.push(next.value);
+    }
+    const error = JSON.parse(Buffer.concat(chunks).toString("utf8"))?.error;
+    return error?.type === "invalid_request_error" && typeof error.message === "string" && /response/i.test(error.message) && /not found|expired/i.test(error.message) && (error.param == null || error.param === "previous_response_id");
+  } catch {
+    return false;
+  } finally {
+    reader.cancel().catch(() => {});
+  }
+};
+var createMetaContinuationFetch = (fetcher = fetch, backoff = [1000, 2000]) => {
+  const recovered = new WeakSet;
+  return Object.assign(async (input, init) => {
+    let response = await fetcher(input, init);
+    if (response.status !== 400 || !init || recovered.has(init) || !isReceiptContinuation(input, init) || !await isUnavailableResponse(response))
+      return response;
+    recovered.add(init);
+    for (const waitMs of typeof backoff === "number" ? [backoff] : backoff) {
+      init.signal?.throwIfAborted();
+      await response.body?.cancel();
+      await delay(waitMs, undefined, { signal: init.signal ?? undefined });
+      init.signal?.throwIfAborted();
+      response = await fetcher(input, init);
+      if (response.status !== 400 || !await isUnavailableResponse(response))
+        break;
+    }
+    return response;
+  }, { preconnect: fetcher.preconnect });
+};
+
+// src/providers/meta-replay.ts
+import { wrapLanguageModel as wrapLanguageModel2 } from "@zhivex-ai/core";
+import { createMeta } from "@zhivex-ai/meta";
+var replayPlan = (messages) => {
+  let offset = 0;
+  const insertions = [];
+  for (const message of messages) {
+    for (const part of message.parts) {
+      if (message.role !== "assistant" || part.type !== "provider-data" || part.provider !== "meta")
+        continue;
+      const data = part.data;
+      if (!data || typeof data !== "object" || Array.isArray(data) || data.type !== "reasoning" || typeof data.encrypted_content !== "string" || !data.encrypted_content)
+        continue;
+      insertions.push({ offset, item: {
+        type: "reasoning",
+        summary: [],
+        encrypted_content: data.encrypted_content,
+        ...typeof data.id === "string" ? { id: data.id } : {}
+      } });
+    }
+    if (message.role === "tool") {
+      offset += message.parts.filter((part) => part.type === "tool-result").length;
+    } else {
+      if (message.role === "assistant")
+        offset += message.parts.filter((part) => part.type === "tool-call").length;
+      if (message.parts.some((part) => ["text", "image", "audio", "file"].includes(part.type)))
+        offset++;
+    }
+  }
+  return { insertions, itemCount: offset };
+};
+var createMetaReplayModel = (options, modelId) => {
+  const fetcher = options.fetch ?? fetch;
+  const prepare = (input) => {
+    const plan = replayPlan(input.messages);
+    const messages = input.messages.map((message) => ({ ...message, parts: message.parts.filter((part) => !(part.type === "provider-data" && part.provider === "meta" && part.data && typeof part.data === "object" && !Array.isArray(part.data) && ("responseId" in part.data))) }));
+    const { previous_response_id: _previous, ...providerOptions } = input.providerOptions ?? {};
+    const include = Array.isArray(providerOptions.include) ? providerOptions.include.filter((v) => typeof v === "string") : [];
+    const replayFetch = Object.assign(async (url, init) => {
+      if (typeof init?.body !== "string")
+        throw new Error("Meta replay requires a serialized SDK request.");
+      const body = JSON.parse(init.body);
+      const items = body.input ?? [];
+      if (!Array.isArray(items) || items.length !== plan.itemCount)
+        throw new Error("Meta SDK input layout changed; cannot safely replay reasoning.");
+      const replayed = [];
+      let insertion = 0;
+      for (let offset = 0;offset <= items.length; offset++) {
+        while (plan.insertions[insertion]?.offset === offset)
+          replayed.push(plan.insertions[insertion++].item);
+        if (offset < items.length)
+          replayed.push(items[offset]);
+      }
+      delete body.previous_response_id;
+      body.input = replayed;
+      return fetcher(url, { ...init, body: JSON.stringify(body) });
+    }, { preconnect: fetcher.preconnect });
+    return {
+      model: createMeta({ ...options, fetch: replayFetch })(modelId),
+      input: { ...input, messages, providerOptions: {
+        ...providerOptions,
+        apiMode: "responses",
+        store: false,
+        include: [...new Set([...include, "reasoning.encrypted_content"])]
+      } }
+    };
+  };
+  return wrapLanguageModel2(createMeta(options)(modelId), [{
+    name: "harness-meta-stateless-replay-v1",
+    async wrapGenerate({ input }) {
+      const prepared = prepare(input);
+      return prepared.model.generate(prepared.input);
+    },
+    async wrapStream({ input }) {
+      const prepared = prepare(input);
+      return prepared.model.stream(prepared.input);
+    }
+  }]);
+};
+
+// src/providers/meta-errors.ts
+import { ProviderHTTPError } from "@zhivex-ai/core/provider";
+function annotateMetaRequestError(error) {
+  if (error instanceof ProviderHTTPError) {
+    let reason = "reason unavailable";
+    try {
+      const detail = JSON.parse(typeof error.responseBody === "string" ? error.responseBody : "").error;
+      const message = typeof detail?.message === "string" ? detail.message : "";
+      if (detail?.type === "invalid_request_error" && /response/i.test(message) && /not found|expired/i.test(message) && (detail.param == null || detail.param === "previous_response_id")) {
+        reason = "previous response unavailable";
+      } else if (detail?.code === "context_length_exceeded") {
+        reason = "context length exceeded";
+      } else if (detail?.param === "tools") {
+        reason = "tools rejected";
+      } else if (detail?.param === "input") {
+        reason = "input rejected";
+      } else if (detail?.param === "max_output_tokens") {
+        reason = "output token limit rejected";
+      } else if (detail?.param === "previous_response_id") {
+        reason = "previous response rejected";
+      }
+    } catch {}
+    error.message = `Meta request failed with status ${error.status} (${reason}).`;
+  }
+  throw error;
+}
+
+// src/models/catalog.ts
+import { z } from "zod";
+// src/models/catalog.json
+var catalog_default = {
+  schemaVersion: 1,
+  revision: "2026-09-26-frontier",
+  providers: [
+    {
+      id: "openai",
+      defaultModel: "gpt-6-luna",
+      models: [
+        {
+          id: "gpt-6-astra",
+          name: "gpt-6-astra",
+          group: "primary",
+          order: 0,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          limits: {
+            contextWindowTokens: 1050000,
+            contextWindowType: "combined",
+            maxOutputTokens: 128000,
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-6-astra",
+              checkedAt: "2026-09-24"
+            }
+          },
+          pricing: {
+            currency: "USD",
+            inputPerMillionTokens: 10,
+            outputPerMillionTokens: 50,
+            cachedInputPerMillionTokens: 1,
+            maxInputTokens: 272000,
+            scope: "Standard text tokens; excludes regional, mode, cache-write and tool charges.",
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-6-astra",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented text generation and token limits; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-6-astra",
+              checkedAt: "2026-09-24"
+            }
+          }
+        },
+        {
+          id: "gpt-6-sol",
+          name: "gpt-6-sol",
+          group: "primary",
+          order: 1,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools",
+            "vision"
+          ],
+          limits: {
+            contextWindowTokens: 1050000,
+            contextWindowType: "combined",
+            maxOutputTokens: 128000,
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-6-sol",
+              checkedAt: "2026-09-24"
+            }
+          },
+          pricing: {
+            currency: "USD",
+            inputPerMillionTokens: 2,
+            outputPerMillionTokens: 10,
+            cachedInputPerMillionTokens: 0.2,
+            maxInputTokens: 272000,
+            scope: "Standard text tokens; excludes regional, mode, cache-write and tool charges.",
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-6-sol",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented text generation and token limits; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-6-sol",
+              checkedAt: "2026-09-24"
+            }
+          }
+        },
+        {
+          id: "gpt-6-luna",
+          name: "gpt-6-luna",
+          group: "primary",
+          order: 2,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools",
+            "vision"
+          ],
+          limits: {
+            contextWindowTokens: 1050000,
+            contextWindowType: "combined",
+            maxOutputTokens: 128000,
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-6-luna",
+              checkedAt: "2026-09-24"
+            }
+          },
+          pricing: {
+            currency: "USD",
+            inputPerMillionTokens: 0.1,
+            outputPerMillionTokens: 0.5,
+            cachedInputPerMillionTokens: 0.01,
+            maxInputTokens: 272000,
+            scope: "Standard text tokens; excludes regional, mode, cache-write and tool charges.",
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-6-luna",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented text generation and token limits; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-6-luna",
+              checkedAt: "2026-09-24"
+            }
+          }
+        },
+        {
+          id: "gpt-5.6-sol",
+          name: "gpt-5.6-sol",
+          group: "other",
+          order: 3,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "gpt-5.6-terra",
+          name: "gpt-5.6-terra",
+          group: "other",
+          order: 4,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "gpt-5.6-luna",
+          name: "gpt-5.6-luna",
+          group: "other",
+          order: 5,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "gpt-5.5",
+          name: "gpt-5.5",
+          group: "other",
+          order: 6,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          reason: "Earlier generation; GPT-6 and GPT-5.6 are the current primary choices."
+        },
+        {
+          id: "gpt-5.4",
+          name: "gpt-5.4",
+          group: "other",
+          order: 7,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          reason: "Earlier generation; GPT-6 and GPT-5.6 are the current primary choices."
+        },
+        {
+          id: "gpt-5.4-mini",
+          name: "gpt-5.4-mini",
+          group: "other",
+          order: 8,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          reason: "Earlier generation; GPT-6 and GPT-5.6 are the current primary choices."
+        },
+        {
+          id: "gpt-4o-mini",
+          name: "gpt-4o-mini",
+          group: "other",
+          order: 9,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          reason: "Earlier generation; GPT-6 and GPT-5.6 are the current primary choices.",
+          limits: {
+            contextWindowTokens: 128000,
+            contextWindowType: "combined",
+            maxOutputTokens: 16384,
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-4o-mini",
+              checkedAt: "2026-09-24"
+            }
+          },
+          pricing: {
+            currency: "USD",
+            inputPerMillionTokens: 0.15,
+            outputPerMillionTokens: 0.6,
+            cachedInputPerMillionTokens: 0.075,
+            scope: "Standard text tokens; excludes regional, mode, cache-write and tool charges.",
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-4o-mini",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented text generation and token limits; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://developers.openai.com/api/docs/models/gpt-4o-mini",
+              checkedAt: "2026-09-24"
+            }
+          }
+        }
+      ]
+    },
+    {
+      id: "qwen",
+      defaultModel: "qwen3.8-max",
+      models: [
+        {
+          id: "qwen3.8-flash",
+          name: "qwen3.8-flash",
+          group: "primary",
+          order: 0,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          limits: {
+            contextWindowTokens: 1e6,
+            contextWindowType: "combined",
+            maxOutputTokens: 131072,
+            maxInputTokens: 983616,
+            evidence: {
+              sourceUrl: "https://www.alibabacloud.com/help/en/model-studio/qwen3-8-flash",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented text generation. Conservative thinking-mode input limit; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://www.alibabacloud.com/help/en/model-studio/qwen3-8-flash",
+              checkedAt: "2026-09-24"
+            }
+          }
+        },
+        {
+          id: "qwen3.8-max",
+          name: "qwen3.8-max",
+          group: "primary",
+          order: 1,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          limits: {
+            contextWindowTokens: 1e6,
+            contextWindowType: "combined",
+            maxOutputTokens: 131072,
+            maxInputTokens: 983616,
+            evidence: {
+              sourceUrl: "https://www.alibabacloud.com/help/en/model-studio/qwen3-8-max",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented text generation. Conservative thinking-mode input limit; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://www.alibabacloud.com/help/en/model-studio/qwen3-8-max",
+              checkedAt: "2026-09-24"
+            }
+          }
+        },
+        {
+          id: "glm-5.3",
+          name: "GLM 5.3",
+          group: "primary",
+          order: 2,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          reason: "Zhipu model served by Alibaba Model Studio; region and account access vary"
+        },
+        {
+          id: "deepseek-v4.1-flash",
+          name: "DeepSeek V4.1 Flash",
+          group: "primary",
+          order: 3,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools",
+            "vision"
+          ],
+          reason: "DeepSeek model served by Alibaba Model Studio; region and account access vary"
+        },
+        {
+          id: "kimi-k3",
+          name: "Kimi K3",
+          group: "primary",
+          order: 4,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools",
+            "vision"
+          ],
+          reason: "Moonshot model served by Alibaba Model Studio; region and account access vary"
+        },
+        {
+          id: "qwen3.7-plus",
+          name: "qwen3.7-plus",
+          group: "primary",
+          order: 5,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "qwen3.8-omni-flash",
+          name: "qwen3.8-omni-flash",
+          group: "other",
+          order: 6,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "qwen3.8-max-0902",
+          name: "qwen3.8-max-0902",
+          group: "other",
+          order: 7,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "qwen3.8-max-preview",
+          name: "qwen3.8-max-preview",
+          group: "other",
+          order: 8,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "qwen3.7-max",
+          name: "qwen3.7-max",
+          group: "other",
+          order: 9,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "qwen3.6-flash",
+          name: "qwen3.6-flash",
+          group: "other",
+          order: 10,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "qwen3.5-omni-plus",
+          name: "qwen3.5-omni-plus",
+          group: "other",
+          order: 11,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "qwen-plus",
+          name: "qwen-plus",
+          group: "other",
+          order: 12,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        }
+      ]
+    },
+    {
+      id: "gemini",
+      defaultModel: "gemini-3.6-flash",
+      models: [
+        {
+          id: "gemini-3.8-flash",
+          name: "gemini-3.8-flash",
+          group: "other",
+          order: 0,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          limits: {
+            contextWindowTokens: 1048576,
+            contextWindowType: "input",
+            maxOutputTokens: 65536,
+            evidence: {
+              sourceUrl: "https://ai.google.dev/gemini-api/docs/models/gemini-3.8-flash",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented text generation and token limits; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://ai.google.dev/gemini-api/docs/models/gemini-3.8-flash",
+              checkedAt: "2026-09-24"
+            }
+          }
+        },
+        {
+          id: "gemini-3.7-flash",
+          name: "gemini-3.7-flash",
+          group: "other",
+          order: 1,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          limits: {
+            contextWindowTokens: 1048576,
+            contextWindowType: "input",
+            maxOutputTokens: 65536,
+            evidence: {
+              sourceUrl: "https://ai.google.dev/gemini-api/docs/models/gemini-3.7-flash",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented text generation and token limits; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://ai.google.dev/gemini-api/docs/models/gemini-3.7-flash",
+              checkedAt: "2026-09-24"
+            }
+          }
+        },
+        {
+          id: "gemini-3.6-flash",
+          name: "gemini-3.6-flash",
+          group: "primary",
+          order: 2,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          limits: {
+            contextWindowTokens: 1048576,
+            contextWindowType: "input",
+            maxOutputTokens: 65536,
+            evidence: {
+              sourceUrl: "https://ai.google.dev/gemini-api/docs/models/gemini-3.6-flash",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented text generation and token limits; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://ai.google.dev/gemini-api/docs/models/gemini-3.6-flash",
+              checkedAt: "2026-09-24"
+            }
+          }
+        },
+        {
+          id: "gemini-3.5-flash-lite",
+          name: "gemini-3.5-flash-lite",
+          group: "other",
+          order: 3,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ],
+          limits: {
+            contextWindowTokens: 1048576,
+            contextWindowType: "input",
+            maxOutputTokens: 65536,
+            evidence: {
+              sourceUrl: "https://ai.google.dev/gemini-api/docs/models/gemini-3.5-flash-lite",
+              checkedAt: "2026-09-24"
+            }
+          },
+          compaction: {
+            suitability: "candidate",
+            reason: "Editorial candidate based on documented document parsing and text generation; summary fidelity has not been benchmarked.",
+            evidence: {
+              sourceUrl: "https://ai.google.dev/gemini-api/docs/models/gemini-3.5-flash-lite",
+              checkedAt: "2026-09-24"
+            }
+          },
+          pricing: {
+            currency: "USD",
+            inputPerMillionTokens: 0.3,
+            outputPerMillionTokens: 2.5,
+            cachedInputPerMillionTokens: 0.03,
+            scope: "Standard paid-tier text tokens; includes output thinking tokens, excludes cache storage and tool charges.",
+            evidence: {
+              sourceUrl: "https://ai.google.dev/gemini-api/docs/pricing#gemini-3.5-flash-lite",
+              checkedAt: "2026-09-24"
+            }
+          }
+        },
+        {
+          id: "gemini-3.5-flash",
+          name: "gemini-3.5-flash",
+          group: "other",
+          order: 4,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "gemini-3.1-pro-preview",
+          name: "gemini-3.1-pro-preview",
+          group: "other",
+          order: 5,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "gemini-3.1-pro-preview-customtools",
+          name: "gemini-3.1-pro-preview-customtools",
+          group: "other",
+          order: 6,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "gemini-3-flash-preview",
+          name: "gemini-3-flash-preview",
+          group: "other",
+          order: 7,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "gemini-3.1-flash-lite",
+          name: "gemini-3.1-flash-lite",
+          group: "other",
+          order: 8,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        }
+      ]
+    },
+    {
+      id: "meta",
+      defaultModel: "muse-spark-1.3",
+      models: [
+        {
+          id: "muse-spark-1.3",
+          name: "muse-spark-1.3",
+          group: "primary",
+          order: 0,
+          lifecycle: "active",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "muse-spark-1.2",
+          name: "muse-spark-1.2",
+          group: "primary",
+          order: 1,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "muse-spark-1.2-contributor",
+          name: "muse-spark-1.2-contributor",
+          group: "other",
+          order: 2,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        },
+        {
+          id: "muse-spark-1.1",
+          name: "muse-spark-1.1",
+          group: "other",
+          order: 3,
+          lifecycle: "unknown",
+          validation: "unverified",
+          capabilities: [
+            "chat",
+            "tools"
+          ]
+        }
+      ]
+    }
+  ]
+};
+
+// src/models/catalog.ts
+var modelId = z.string().min(1).max(160).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/-]*$/);
+var text = z.string().min(1).max(300).regex(/^[^\x00-\x1f\x7f-\x9f]*$/);
+var evidence = z.object({
+  sourceUrl: z.url().max(1000).refine((value) => {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password;
+  }, "Evidence requires an HTTPS URL without credentials"),
+  checkedAt: z.iso.date()
+}).strict();
+var tokenLimit = z.number().int().positive().max(1e9);
+var price = z.number().finite().nonnegative().max(1e6);
+var catalogModelSchema = z.object({
+  id: modelId,
+  name: text,
+  group: z.enum(["primary", "other"]),
+  order: z.number().int().min(0),
+  lifecycle: z.enum(["active", "deprecated", "retired", "unknown"]),
+  validation: z.enum(["verified", "unverified"]),
+  capabilities: z.array(z.enum(["chat", "tools", "vision"])).max(3),
+  reason: text.optional(),
+  replacement: modelId.optional(),
+  retirementDate: z.iso.date().optional(),
+  limits: z.object({
+    contextWindowTokens: tokenLimit,
+    contextWindowType: z.enum(["combined", "input"]),
+    maxOutputTokens: tokenLimit,
+    maxInputTokens: tokenLimit.optional(),
+    evidence
+  }).strict().optional(),
+  pricing: z.object({
+    currency: z.literal("USD"),
+    inputPerMillionTokens: price,
+    outputPerMillionTokens: price,
+    cachedInputPerMillionTokens: price.optional(),
+    maxInputTokens: tokenLimit.optional(),
+    scope: text,
+    evidence
+  }).strict().optional(),
+  compaction: z.object({
+    suitability: z.enum(["candidate", "evaluated", "unsuitable", "unknown"]),
+    reason: text,
+    evidence
+  }).strict().optional()
+}).strict().superRefine((model, ctx) => {
+  if (!model.limits)
+    return;
+  if (model.limits.maxInputTokens !== undefined && model.limits.maxInputTokens > model.limits.contextWindowTokens) {
+    ctx.addIssue({ code: "custom", message: "maxInputTokens exceeds context window" });
+  }
+  if (model.limits.contextWindowType === "combined" && model.limits.maxOutputTokens > model.limits.contextWindowTokens) {
+    ctx.addIssue({ code: "custom", message: "maxOutputTokens exceeds combined context window" });
+  }
+});
+var modelCatalogSchema = z.object({
+  schemaVersion: z.literal(1),
+  revision: z.string().min(1).max(80).regex(/^[a-zA-Z0-9._-]+$/),
+  providers: z.array(z.object({
+    id: z.enum(["openai", "qwen", "gemini", "meta"]),
+    defaultModel: modelId,
+    models: z.array(catalogModelSchema).min(1).max(500)
+  }).strict()).length(4)
+}).strict().superRefine((catalog, ctx) => {
+  const invalid = (message) => ctx.addIssue({ code: "custom", message });
+  if (new Set(catalog.providers.map((p) => p.id)).size !== 4)
+    invalid("Duplicate providers");
+  for (const provider of catalog.providers) {
+    const ids = new Set(provider.models.map((m) => m.id));
+    if (ids.size !== provider.models.length)
+      invalid(`Duplicate models: ${provider.id}`);
+    const preferred = provider.models.find((m) => m.id === provider.defaultModel);
+    if (!preferred || preferred.group !== "primary" || preferred.lifecycle === "retired")
+      invalid(`Invalid default: ${provider.id}`);
+    for (const model of provider.models) {
+      if (model.group === "primary" && model.lifecycle === "retired")
+        invalid("Retired primary model");
+      if (model.replacement && (!ids.has(model.replacement) || model.replacement === model.id))
+        invalid("Invalid replacement");
+    }
+  }
+});
+var bundledModelCatalog = modelCatalogSchema.parse(catalog_default);
+var bundledDefaultModel = (provider) => {
+  const entry = bundledModelCatalog.providers.find((p) => p.id === provider);
+  if (!entry)
+    throw new Error("UNKNOWN_CATALOG_PROVIDER");
+  return entry.defaultModel;
+};
+function catalogModels(catalog, provider, current) {
+  const models = [...catalog.providers.find((p) => p.id === provider)?.models ?? []].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+  if (current && !models.some((m) => m.id === current))
+    models.unshift({
+      id: current,
+      name: current,
+      group: "other",
+      order: 0,
+      lifecycle: "unknown",
+      validation: "unverified",
+      capabilities: []
+    });
+  return models;
+}
+function modelDescription(model) {
+  return [
+    model.lifecycle === "deprecated" ? "In retirement" : model.lifecycle === "retired" ? "Retired" : "",
+    model.validation === "unverified" ? "Unverified" : "Verified in Zhivex",
+    model.limits ? `Context: ${model.limits.contextWindowTokens.toLocaleString("en-US")} tokens (${model.limits.contextWindowType}) · Output: ${model.limits.maxOutputTokens.toLocaleString("en-US")}` : "Context: unknown",
+    model.reason,
+    model.replacement ? `Suggested replacement: ${model.replacement}` : "",
+    model.retirementDate ? `Retirement: ${model.retirementDate}` : ""
+  ].filter(Boolean).join(" · ");
+}
+
+// src/providers/providers.ts
+import { createHash } from "node:crypto";
+import {
+  wrapLanguageModel as wrapLanguageModel3
+} from "@zhivex-ai/core";
+import { createGemini } from "@zhivex-ai/gemini";
+import { createOpenAI } from "@zhivex-ai/openai";
+import { createQwen } from "@zhivex-ai/qwen";
+var PROVIDERS = ["meta", "qwen", "openai", "gemini"];
+var HARNESS_PROVIDER_CAPABILITIES = [
+  "streaming",
+  "tool-calling",
+  "approval-resume"
+];
+var QWEN_REGIONS = [
+  "singapore",
+  "beijing",
+  "hong-kong",
+  "tokyo",
+  "frankfurt",
+  "virginia"
+];
+var PROVIDER_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+var ENVIRONMENT_VARIABLE = /^[A-Z_][A-Z0-9_]{0,127}$/;
+var DIAGNOSTIC_KEY = /^[a-z][A-Za-z0-9]{0,63}$/;
+var requiredText = (name, value) => {
+  const normalized = value.trim();
+  if (!normalized || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new Error(`${name} must be a non-empty printable string.`);
+  }
+  return normalized;
+};
+var environmentVariable = (name, value) => {
+  if (!ENVIRONMENT_VARIABLE.test(value)) {
+    throw new Error(`${name} must be a valid environment variable name.`);
+  }
+  return value;
+};
+var diagnosticKey = (value) => {
+  if (!DIAGNOSTIC_KEY.test(value)) {
+    throw new Error(`Invalid provider diagnostic key: ${value}.`);
+  }
+  return value;
+};
+var normalizedDescriptor = (descriptor) => {
+  const id = descriptor.id.trim().toLowerCase();
+  if (descriptor.id !== id || !PROVIDER_ID.test(id)) {
+    throw new Error(`Invalid provider id: ${descriptor.id}. Use 1-64 lowercase letters, digits, dot, underscore, or hyphen.`);
+  }
+  if (!(descriptor.support === "certified" || descriptor.support === "provisional")) {
+    throw new Error(`Invalid support level for provider ${id}.`);
+  }
+  const credentialNames = [...new Set(descriptor.credentialNames.map((name) => environmentVariable(`Credential for provider ${id}`, name)))];
+  const capabilities = [...new Set(descriptor.capabilities)];
+  const invalidCapability = capabilities.find((capability) => !HARNESS_PROVIDER_CAPABILITIES.includes(capability));
+  if (invalidCapability) {
+    throw new Error(`Invalid capability for provider ${id}: ${invalidCapability}.`);
+  }
+  return Object.freeze({
+    id,
+    name: requiredText(`Name for provider ${id}`, descriptor.name),
+    defaultModel: requiredText(`Default model for provider ${id}`, descriptor.defaultModel),
+    credentialNames: Object.freeze(credentialNames),
+    capabilities: Object.freeze(capabilities),
+    support: descriptor.support
+  });
+};
+var normalizedDiagnostics = (provider, diagnostics) => {
+  const endpointEnvironmentVariable = diagnostics?.endpointEnvironmentVariable === undefined ? undefined : environmentVariable(`Endpoint diagnostic for provider ${provider}`, diagnostics.endpointEnvironmentVariable);
+  const seenKeys = new Set;
+  const presence = (diagnostics?.presence ?? []).map((entry) => {
+    const key = diagnosticKey(entry.key);
+    if (seenKeys.has(key)) {
+      throw new Error(`Duplicate diagnostic key for provider ${provider}: ${key}.`);
+    }
+    seenKeys.add(key);
+    return Object.freeze({
+      key,
+      environmentVariable: environmentVariable(`Presence diagnostic for provider ${provider}`, entry.environmentVariable)
+    });
+  });
+  const enums = (diagnostics?.enums ?? []).map((entry) => {
+    const key = diagnosticKey(entry.key);
+    if (seenKeys.has(key)) {
+      throw new Error(`Duplicate diagnostic key for provider ${provider}: ${key}.`);
+    }
+    seenKeys.add(key);
+    const allowedValues = [...new Set(entry.allowedValues.map((value) => requiredText(`Allowed diagnostic value for provider ${provider}`, value)))];
+    if (allowedValues.length === 0) {
+      throw new Error(`Enum diagnostic ${key} for provider ${provider} needs allowed values.`);
+    }
+    return Object.freeze({
+      key,
+      environmentVariable: environmentVariable(`Enum diagnostic for provider ${provider}`, entry.environmentVariable),
+      allowedValues: Object.freeze(allowedValues)
+    });
+  });
+  return Object.freeze({
+    ...endpointEnvironmentVariable ? { endpointEnvironmentVariable } : {},
+    ...presence.length > 0 ? { presence: Object.freeze(presence) } : {},
+    ...enums.length > 0 ? { enums: Object.freeze(enums) } : {}
+  });
+};
+var endpointConfiguration = (value) => {
+  const configured = Boolean(value?.trim());
+  if (!configured) {
+    return {
+      customEndpoint: false,
+      endpointValid: true,
+      endpointSecure: true
+    };
+  }
+  try {
+    const endpoint = new URL(value.trim());
+    const supportedProtocol = endpoint.protocol === "https:" || endpoint.protocol === "http:";
+    return {
+      customEndpoint: true,
+      endpointValid: supportedProtocol && !endpoint.username && !endpoint.password && !endpoint.hash && !endpoint.search,
+      endpointSecure: endpoint.protocol === "https:"
+    };
+  } catch {
+    return {
+      customEndpoint: true,
+      endpointValid: false,
+      endpointSecure: false
+    };
+  }
+};
+var createCredentials = (env, provider, names) => Object.freeze({
+  names,
+  get: (name) => {
+    if (!names.includes(name)) {
+      throw new Error(`Credential ${name} is not declared for provider ${provider}.`);
+    }
+    return env[name]?.trim() || undefined;
+  },
+  first: () => {
+    for (const name of names) {
+      const value = env[name]?.trim();
+      if (value) {
+        return value;
+      }
+    }
+    return;
+  },
+  require: () => {
+    for (const name of names) {
+      const value = env[name]?.trim();
+      if (value) {
+        return value;
+      }
+    }
+    throw new Error(names.length === 0 ? `Provider ${provider} does not declare a credential.` : `Missing credentials for ${provider}. Set ${names.join(" or ")} in the environment.`);
+  }
+});
+var normalizeRegistration = (registration) => {
+  if (typeof registration.factory !== "function") {
+    throw new Error("Provider registration factory must be a function.");
+  }
+  const descriptor = normalizedDescriptor(registration.descriptor);
+  return Object.freeze({
+    descriptor,
+    factory: registration.factory,
+    diagnostics: normalizedDiagnostics(descriptor.id, registration.diagnostics)
+  });
+};
+var providerConfiguration = (diagnostics, env) => {
+  const configuration = endpointConfiguration(diagnostics.endpointEnvironmentVariable ? env[diagnostics.endpointEnvironmentVariable] : undefined);
+  for (const entry of diagnostics.presence ?? []) {
+    configuration[`${entry.key}Configured`] = Boolean(env[entry.environmentVariable]?.trim());
+  }
+  for (const entry of diagnostics.enums ?? []) {
+    const value = env[entry.environmentVariable]?.trim();
+    configuration[`${entry.key}Configured`] = Boolean(value);
+    configuration[`${entry.key}Valid`] = !value || entry.allowedValues.includes(value);
+  }
+  return Object.freeze(configuration);
+};
+var parseWithRegistrations = (value, registrations) => {
+  const defaultProvider = registrations.has("openai") ? "openai" : registrations.keys().next().value;
+  const normalized = (value ?? defaultProvider ?? "").trim().toLowerCase();
+  if (registrations.has(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Unknown provider: ${value}. Use ${[...registrations.keys()].join(", ")}.`);
+};
+var createProviderRegistry = (registrations) => {
+  if (registrations.length === 0) {
+    throw new Error("Provider registry must contain at least one provider.");
+  }
+  const entries = new Map;
+  for (const registration of registrations) {
+    const normalized = normalizeRegistration(registration);
+    if (entries.has(normalized.descriptor.id)) {
+      throw new Error(`Duplicate provider registration: ${normalized.descriptor.id}.`);
+    }
+    entries.set(normalized.descriptor.id, normalized);
+  }
+  const frozenRegistrations = Object.freeze([...entries.values()]);
+  const descriptors = Object.freeze(frozenRegistrations.map((entry) => entry.descriptor));
+  const registry = Object.freeze({
+    descriptors,
+    has: (provider) => entries.has(provider.trim().toLowerCase()),
+    parse: (value) => parseWithRegistrations(value, entries),
+    descriptor: (provider) => {
+      const registration = entries.get(provider);
+      if (!registration) {
+        throw new Error(`No descriptor is available for provider ${provider}.`);
+      }
+      return registration.descriptor;
+    },
+    createModel: (config, env = process.env) => {
+      const registration = entries.get(config.provider);
+      if (!registration) {
+        throw new Error(`No factory is available for provider ${config.provider}.`);
+      }
+      return registration.factory(Object.freeze({
+        provider: config.provider,
+        model: config.model,
+        env,
+        credentials: createCredentials(env, config.provider, registration.descriptor.credentialNames)
+      }));
+    },
+    availability: (env = process.env) => Object.freeze(frozenRegistrations.map((registration) => {
+      const credentials = Object.freeze(registration.descriptor.credentialNames.map((name) => Object.freeze({ name, present: Boolean(env[name]?.trim()) })));
+      return Object.freeze({
+        ...registration.descriptor,
+        configured: credentials.length === 0 || credentials.some((credential) => credential.present),
+        credentials,
+        configuration: providerConfiguration(registration.diagnostics, env)
+      });
+    })),
+    transportFingerprint: (env = process.env) => {
+      const transport = frozenRegistrations.map((registration) => {
+        const names = [
+          registration.diagnostics.endpointEnvironmentVariable,
+          ...(registration.diagnostics.presence ?? []).map((entry) => entry.environmentVariable),
+          ...(registration.diagnostics.enums ?? []).map((entry) => entry.environmentVariable)
+        ].filter((name) => Boolean(name));
+        return {
+          provider: registration.descriptor.id,
+          values: names.map((name) => [name, env[name]?.trim() ?? ""])
+        };
+      });
+      return `sha256:${createHash("sha256").update(JSON.stringify(transport)).digest("hex")}`;
+    },
+    extend: (additional) => createProviderRegistry([
+      ...frozenRegistrations,
+      ...additional
+    ])
+  });
+  return registry;
+};
+var optionalQwenRegion = (value) => {
+  if (!value) {
+    return;
+  }
+  if (QWEN_REGIONS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid QWEN_REGION: ${value}.`);
+};
+var generatedToolCallId = (model, input, index, toolCall) => `harness_call_${createHash("sha256").update(JSON.stringify({
+  provider: model.provider,
+  modelId: model.modelId,
+  messages: input.messages,
+  index,
+  name: toolCall.name,
+  input: toolCall.input
+})).digest("hex").slice(0, 48)}`;
+var existingToolCallIds = (messages) => new Set(messages.flatMap((message) => message.parts.flatMap((part) => {
+  if (part.type === "tool-call")
+    return [part.toolCall.id];
+  if (part.type === "tool-result")
+    return [part.toolResult.toolCallId];
+  return [];
+}).filter((id) => typeof id === "string" && id.length > 0)));
+var normalizedToolCall = (model, input, index, toolCall, seenIds) => {
+  const providerId = typeof toolCall.id === "string" ? toolCall.id.trim() : "";
+  const id = providerId.length > 0 && !/^\d+$/.test(providerId) ? providerId : generatedToolCallId(model, input, index, toolCall);
+  if (seenIds.has(id)) {
+    throw new QwenToolCallIdError(`Qwen returned a duplicate tool-call id: ${id}.`);
+  }
+  seenIds.add(id);
+  return id === toolCall.id ? toolCall : { ...toolCall, id };
+};
+
+class QwenToolCallIdError extends Error {
+  diagnosticCode = "QWEN_DUPLICATE_TOOL_CALL_ID";
+  constructor(message) {
+    super(message);
+    this.name = "QwenToolCallIdError";
+  }
+}
+var normalizeMessageToolCallIds = (model, input, messages, seenIds = existingToolCallIds(input.messages)) => {
+  let index = 0;
+  return messages.map((message) => ({
+    ...message,
+    parts: message.parts.map((part) => part.type === "tool-call" ? {
+      ...part,
+      toolCall: normalizedToolCall(model, input, index++, part.toolCall, seenIds)
+    } : part)
+  }));
+};
+var normalizeGenerateToolCallIds = (model, input, result) => {
+  const messages = result.messages ? normalizeMessageToolCallIds(model, input, result.messages) : undefined;
+  const message = result.message ? normalizeMessageToolCallIds(model, input, [result.message])[0] : undefined;
+  return {
+    ...result,
+    ...message ? { message } : {},
+    ...messages ? { messages } : {}
+  };
+};
+var normalizeStreamToolCallIds = async function* (model, input, events) {
+  let index = 0;
+  const seenIds = existingToolCallIds(input.messages);
+  for await (const event of events) {
+    if (event.type !== "tool-call") {
+      yield event;
+      continue;
+    }
+    yield {
+      ...event,
+      toolCall: normalizedToolCall(model, input, index++, event.toolCall, seenIds)
+    };
+  }
+};
+var withQwenDurableToolCallIds = (model) => wrapLanguageModel3(model, [{
+  name: "harness-qwen-durable-tool-call-ids",
+  wrapGenerate: async ({ input }, next) => normalizeGenerateToolCallIds(model, input, await next()),
+  wrapStream: async ({ input }, next) => normalizeStreamToolCallIds(model, input, await next())
+}]);
+var withOpenAIToolResultEnvelopes = (model) => wrapLanguageModel3(model, [{
+  name: "harness-openai-tool-result-envelopes-v1",
+  async wrapGenerate({ input }, next) {
+    input.toolResultFormat = "envelope";
+    return next();
+  },
+  async wrapStream({ input }, next) {
+    input.toolResultFormat = "envelope";
+    return next();
+  }
+}]);
+var withMetaResponses = (model) => wrapLanguageModel3(model, [{
+  name: "harness-meta-responses-v1",
+  async wrapGenerate({ input }, next) {
+    input.providerOptions = { ...input.providerOptions, apiMode: "responses" };
+    try {
+      return await next();
+    } catch (error) {
+      return annotateMetaRequestError(error);
+    }
+  },
+  async wrapStream({ input }, next) {
+    input.providerOptions = { ...input.providerOptions, apiMode: "responses" };
+    try {
+      return await next();
+    } catch (error) {
+      return annotateMetaRequestError(error);
+    }
+  }
+}]);
+var BUILTIN_PROVIDER_REGISTRATIONS = Object.freeze([
+  {
+    descriptor: {
+      id: "meta",
+      name: "Meta Model API",
+      defaultModel: bundledDefaultModel("meta"),
+      credentialNames: ["MODEL_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "certified"
+    },
+    diagnostics: { endpointEnvironmentVariable: "META_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.META_BASE_URL?.trim();
+      return withMetaResponses(createMetaReplayModel({
+        apiKey: credentials.require(),
+        fetch: createMetaContinuationFetch(),
+        ...baseURL ? { baseURL } : {}
+      }, model));
+    }
+  },
+  {
+    descriptor: {
+      id: "qwen",
+      name: "Qwen / Alibaba Cloud Model Studio",
+      defaultModel: bundledDefaultModel("qwen"),
+      credentialNames: ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "certified"
+    },
+    diagnostics: {
+      endpointEnvironmentVariable: "QWEN_BASE_URL",
+      presence: [{ key: "workspaceId", environmentVariable: "QWEN_WORKSPACE_ID" }],
+      enums: [{
+        key: "region",
+        environmentVariable: "QWEN_REGION",
+        allowedValues: QWEN_REGIONS
+      }]
+    },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.QWEN_BASE_URL?.trim();
+      const workspaceId = env.QWEN_WORKSPACE_ID?.trim();
+      const region = optionalQwenRegion(env.QWEN_REGION?.trim());
+      return withQwenHostedPolicy(withQwenDurableToolCallIds(createQwen({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {},
+        ...workspaceId ? { workspaceId } : {},
+        ...region ? { region } : {}
+      })(model)));
+    }
+  },
+  {
+    descriptor: {
+      id: "openai",
+      name: "OpenAI",
+      defaultModel: bundledDefaultModel("openai"),
+      credentialNames: ["OPENAI_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "certified"
+    },
+    diagnostics: { endpointEnvironmentVariable: "OPENAI_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.OPENAI_BASE_URL?.trim();
+      return withOpenAIToolResultEnvelopes(createOpenAI({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {}
+      })(model));
+    }
+  },
+  {
+    descriptor: {
+      id: "gemini",
+      name: "Google Gemini",
+      defaultModel: bundledDefaultModel("gemini"),
+      credentialNames: ["GEMINI_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+      capabilities: HARNESS_PROVIDER_CAPABILITIES,
+      support: "provisional"
+    },
+    diagnostics: { endpointEnvironmentVariable: "GEMINI_BASE_URL" },
+    factory: ({ model, env, credentials }) => {
+      const baseURL = env.GEMINI_BASE_URL?.trim();
+      return createGemini({
+        apiKey: credentials.require(),
+        ...baseURL ? { baseURL } : {}
+      })(model);
+    }
+  }
+]);
+var DEFAULT_PROVIDER_REGISTRY = createProviderRegistry(BUILTIN_PROVIDER_REGISTRATIONS);
+var PROVIDER_DESCRIPTORS = DEFAULT_PROVIDER_REGISTRY.descriptors;
+
+// src/providers/reasoning.ts
+var reasoningEffortSchema = z2.enum(["default", "none", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var supportedReasoningEfforts = (capabilities) => ["default", ...capabilities.reasoning ? capabilities.reasoningEfforts ?? [] : []];
+function modelReasoningEfforts(provider, model) {
+  if (!DEFAULT_PROVIDER_REGISTRY.has(provider))
+    return ["default"];
+  const descriptor = DEFAULT_PROVIDER_REGISTRY.descriptor(provider);
+  const env = Object.fromEntries(descriptor.credentialNames.map((name) => [name, "capability-inspection-only"]));
+  return supportedReasoningEfforts(DEFAULT_PROVIDER_REGISTRY.createModel({ provider, model }, env).capabilities);
+}
+function withReasoningEffort(model, value) {
+  if (!value || value === "default")
+    return model;
+  if (!supportedReasoningEfforts(model.capabilities).includes(value))
+    throw new Error(`Reasoning effort ${value} is not declared for ${model.provider}/${model.modelId}. Use default or a supported level.`);
+  return wrapLanguageModel4(model, [{
+    name: `harness-reasoning-${value}`,
+    async wrapGenerate(context, next) {
+      context.input.reasoning = { ...context.input.reasoning, effort: value };
+      return next();
+    },
+    async wrapStream(context, next) {
+      context.input.reasoning = { ...context.input.reasoning, effort: value };
+      return next();
+    }
+  }]);
+}
+
+// src/runtime/config.ts
+import { createHash as createHash2 } from "node:crypto";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+
+// src/runtime/errors.ts
+var HARNESS_ERROR_CODES = [
+  "CONFIG_INVALID",
+  "CLI_USAGE_INVALID",
+  "WORKSPACE_UNSAFE",
+  "STATE_CONFLICT",
+  "PROVIDER_UNAVAILABLE",
+  "APPROVAL_REQUIRED",
+  "EXECUTION_FAILED"
+];
+var HARNESS_ERROR_SCHEMA_VERSION = 1;
+
+class HarnessError extends Error {
+  code;
+  category;
+  retryable;
+  constructor(message, options) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "HarnessError";
+    this.code = options.code;
+    this.category = options.category;
+    this.retryable = options.retryable ?? false;
+  }
+}
+
+class HarnessConfigError extends HarnessError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "CONFIG_INVALID",
+      category: "configuration",
+      ...options.cause === undefined ? {} : { cause: options.cause }
+    });
+    this.name = "HarnessConfigError";
+  }
+}
+
+class HarnessWorkspaceError extends HarnessError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "WORKSPACE_UNSAFE",
+      category: "workspace",
+      ...options.cause === undefined ? {} : { cause: options.cause }
+    });
+    this.name = "HarnessWorkspaceError";
+  }
+}
+
+class HarnessStateConflictError extends HarnessError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "STATE_CONFLICT",
+      category: "state",
+      retryable: options.retryable ?? false,
+      ...options.cause === undefined ? {} : { cause: options.cause }
+    });
+    this.name = "HarnessStateConflictError";
+  }
+}
+
+class HarnessProviderError extends HarnessError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "PROVIDER_UNAVAILABLE",
+      category: "provider",
+      retryable: options.retryable ?? true,
+      ...options.cause === undefined ? {} : { cause: options.cause }
+    });
+    this.name = "HarnessProviderError";
+  }
+}
+class HarnessExecutionError extends HarnessError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "EXECUTION_FAILED",
+      category: "execution",
+      retryable: options.retryable ?? false,
+      ...options.cause === undefined ? {} : { cause: options.cause }
+    });
+    this.name = "HarnessExecutionError";
+  }
+}
+var harnessErrorDocument = (error) => {
+  const normalized = normalizeHarnessError(error);
+  return {
+    schemaVersion: HARNESS_ERROR_SCHEMA_VERSION,
+    kind: "error",
+    error: {
+      code: normalized.code,
+      category: normalized.category,
+      retryable: normalized.retryable
+    }
+  };
+};
+var numericStatuses = (error) => {
+  if (!error || typeof error !== "object")
+    return;
+  const record = error;
+  const values = [record.status, record.statusCode].filter((value) => typeof value === "number" && Number.isSafeInteger(value));
+  return values.length > 0 ? values : undefined;
+};
+var normalizeHarnessError = (error) => {
+  if (error instanceof HarnessError)
+    return error;
+  const message = error instanceof Error ? error.message : "Harness execution failed.";
+  const statuses = numericStatuses(error) ?? [];
+  if (statuses.some((status) => status === 429 || status >= 500 && status <= 599)) {
+    return new HarnessProviderError(message, { cause: error, retryable: true });
+  }
+  const name = error && typeof error === "object" && typeof error.name === "string" ? error.name : "";
+  const code = error && typeof error === "object" && typeof error.code === "string" ? error.code : "";
+  if (name === "ConflictError" || code === "SQLITE_BUSY" || code === "SQLITE_LOCKED") {
+    return new HarnessStateConflictError(message, {
+      cause: error,
+      retryable: code === "SQLITE_BUSY" || code === "SQLITE_LOCKED"
+    });
+  }
+  return new HarnessExecutionError(message, { cause: error });
+};
+
+// src/runtime/config.ts
+var DEFAULT_ALLOWED_CHECKS = ["test", "typecheck", "lint", "build"];
+var HARNESS_CONFIG_SCHEMA_VERSION = 5;
+var HARNESS_CONFIG_MIGRATABLE_SCHEMA_VERSIONS = [4, 5];
+var HARNESS_STORE_BACKENDS = ["sqlite", "file"];
+var HARNESS_EXECUTION_BACKENDS = ["none", "oci"];
+var HARNESS_OCI_RUNTIMES = ["docker", "podman"];
+var HARNESS_OCI_SHELL_MODES = ["deny", "ask"];
+var HARNESS_EXECUTION_POLICY_VERSION = "2026-09-19-v5-scoped-oci";
+var DEFAULT_OCI_EXECUTION = {
+  runtime: "docker",
+  image: "node:24-bookworm-slim",
+  allowedCommands: ["node", "npm"],
+  shellMode: "deny",
+  maxProcessRuntimeMs: 120000,
+  maxProcessOutputBytes: 20000,
+  maxMemoryMb: 1024,
+  maxPids: 128,
+  maxCpus: 2,
+  maxWorkspaceBytes: 64 * 1024 * 1024,
+  maxFileWriteBytes: 1024 * 1024,
+  tmpfsMb: 256
+};
+var HARNESS_REQUIRED_CAPABILITIES = [
+  "streaming",
+  "tools",
+  "structured-output",
+  "parallel-tools",
+  "reasoning",
+  "web-search"
+];
+var HARNESS_SUBAGENT_PROFILES = [
+  "explorer",
+  "implementer",
+  "tester",
+  "reviewer"
+];
+var DEFAULT_HARNESS_MAX_STEPS = 50;
+var DEFAULT_HARNESS_BUDGET = {
+  maxToolCalls: 32,
+  maxToolErrors: 4,
+  maxInputTokens: 1e5,
+  maxOutputTokens: 30000,
+  maxTotalTokens: 120000,
+  includeChildRuns: true
+};
+var DEFAULT_HARNESS_COMPACTION = {
+  maxMessages: 60,
+  maxEstimatedInputTokens: 40000,
+  keepRecentMessages: 12
+};
+var DEFAULT_SUBAGENT_BUDGET = {
+  maxSteps: 8,
+  maxToolCalls: 16,
+  maxToolErrors: 3,
+  maxInputTokens: 30000,
+  maxOutputTokens: 8000,
+  maxTotalTokens: 36000,
+  includeChildRuns: false
+};
+var migrateHarnessConfigInput = (input) => {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new HarnessConfigError("Harness config migration requires an object.");
+  }
+  const fromVersion = input.schemaVersion;
+  if (fromVersion !== 4 && fromVersion !== HARNESS_CONFIG_SCHEMA_VERSION) {
+    throw new HarnessConfigError(`Unsupported config schema version for migration: ${String(fromVersion)}. ` + `Supported source versions: ${HARNESS_CONFIG_MIGRATABLE_SCHEMA_VERSIONS.join(", ")}.`);
+  }
+  if (fromVersion === HARNESS_CONFIG_SCHEMA_VERSION) {
+    return {
+      fromVersion,
+      toVersion: HARNESS_CONFIG_SCHEMA_VERSION,
+      config: { ...input },
+      notes: []
+    };
+  }
+  return {
+    fromVersion,
+    toVersion: HARNESS_CONFIG_SCHEMA_VERSION,
+    config: {
+      ...input,
+      schemaVersion: HARNESS_CONFIG_SCHEMA_VERSION,
+      projectContext: false,
+      ...input.executionBackend === "oci" ? { ociShellMode: "deny" } : {}
+    },
+    notes: [
+      "Project context remains disabled to preserve schema 4 behavior; enable it explicitly after reviewing repository instructions.",
+      ...input.executionBackend === "oci" ? ["OCI shell exposure remains denied to preserve schema 4 behavior."] : []
+    ]
+  };
+};
+var integerOption = (name, input, envValue, fallback, minimum, maximum) => {
+  const value = input ?? (envValue === undefined ? fallback : Number(envValue));
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new HarnessConfigError(`${name} must be an integer between ${minimum} and ${maximum}.`);
+  }
+  return value;
+};
+var scopeValue = (name, value, fallback) => {
+  const configured = value?.trim();
+  const normalized = configured || fallback?.trim();
+  if (!normalized) {
+    return;
+  }
+  if (normalized.length > 128 || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new HarnessConfigError(`${name} must contain 1-128 printable characters.`);
+  }
+  if (name === "userId" && normalized === "*") {
+    throw new HarnessConfigError('userId cannot be the reserved "*" scope marker.');
+  }
+  return normalized;
+};
+var nonNegativeNumberOption = (name, input, envValue) => {
+  if (input === undefined && envValue === undefined) {
+    return;
+  }
+  const value = input ?? Number(envValue);
+  if (!Number.isFinite(value) || value < 0) {
+    throw new HarnessConfigError(`${name} must be a non-negative number.`);
+  }
+  return value;
+};
+var defaultHarnessNamespace = (workspace) => `workspace-${createHash2("sha256").update(workspace).digest("hex").slice(0, 16)}`;
+var canonicalStateDirectory = (requestedWorkspace, canonicalWorkspace, configured) => {
+  if (!configured) {
+    return path.join(canonicalWorkspace, ".zhivex-harness", "runs");
+  }
+  const requestedStateDirectory = path.resolve(configured);
+  const relative = path.relative(requestedWorkspace, requestedStateDirectory);
+  const insideRequestedWorkspace = relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  return insideRequestedWorkspace ? path.resolve(canonicalWorkspace, relative) : requestedStateDirectory;
+};
+var resolveAllowedChecks = (configured) => {
+  const source = configured ?? (process.env.ZHIVEX_HARNESS_ALLOWED_CHECKS === undefined ? DEFAULT_ALLOWED_CHECKS : process.env.ZHIVEX_HARNESS_ALLOWED_CHECKS.split(","));
+  const checks = [...new Set(source.map((value) => value.trim()).filter(Boolean))];
+  if (checks.length > 50) {
+    throw new HarnessConfigError("allowedChecks cannot contain more than 50 script names.");
+  }
+  const invalid = checks.find((value) => !/^[A-Za-z0-9][A-Za-z0-9:_-]{0,63}$/.test(value));
+  if (invalid) {
+    throw new HarnessConfigError(`Invalid allowed check name: ${invalid}. Use 1-64 letters, digits, colon, underscore, or hyphen.`);
+  }
+  return checks;
+};
+var commaSeparatedValues = (configured, envValue, fallback) => configured ?? (envValue === undefined ? fallback : envValue.split(","));
+var resolveRequiredCapabilities = (configured) => {
+  const values = commaSeparatedValues(configured, process.env.ZHIVEX_HARNESS_REQUIRED_CAPABILITIES, ["streaming", "tools"]);
+  const capabilities = [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+  const invalid = capabilities.find((value) => !HARNESS_REQUIRED_CAPABILITIES.includes(value));
+  if (invalid) {
+    throw new HarnessConfigError(`Unknown required capability: ${invalid}. Use ${HARNESS_REQUIRED_CAPABILITIES.join(", ")}.`);
+  }
+  return capabilities;
+};
+var resolveSubagentProfiles = (configured) => {
+  const values = commaSeparatedValues(configured, process.env.ZHIVEX_HARNESS_SUBAGENTS, HARNESS_SUBAGENT_PROFILES);
+  const profiles = [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+  const invalid = profiles.find((value) => !HARNESS_SUBAGENT_PROFILES.includes(value));
+  if (invalid) {
+    throw new HarnessConfigError(`Unknown subagent profile: ${invalid}. Use ${HARNESS_SUBAGENT_PROFILES.join(", ")}.`);
+  }
+  return profiles;
+};
+var resolveOciAllowedCommands = (configured) => {
+  const values = commaSeparatedValues(configured, process.env.ZHIVEX_HARNESS_OCI_ALLOWED_COMMANDS, DEFAULT_OCI_EXECUTION.allowedCommands);
+  const commands = [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+  if (commands.length === 0 || commands.length > 50) {
+    throw new HarnessConfigError("ociAllowedCommands must contain between 1 and 50 executable names.");
+  }
+  const invalid = commands.find((value) => !/^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/.test(value));
+  if (invalid) {
+    throw new HarnessConfigError(`Invalid OCI command name: ${invalid}. Use a bare executable name without a path.`);
+  }
+  if (!commands.some((command) => ["npm", "pnpm", "yarn", "bun"].includes(command))) {
+    throw new HarnessConfigError("ociAllowedCommands must include npm, pnpm, yarn, or bun so declared package checks remain available.");
+  }
+  return commands;
+};
+var resolveExecutionConfig = (input) => {
+  const backend = (input.executionBackend ?? process.env.ZHIVEX_HARNESS_EXECUTION ?? "none").trim().toLowerCase();
+  if (!HARNESS_EXECUTION_BACKENDS.includes(backend)) {
+    throw new HarnessConfigError(`executionBackend must be one of: ${HARNESS_EXECUTION_BACKENDS.join(", ")}.`);
+  }
+  if (backend === "none") {
+    return { backend: "none" };
+  }
+  const runtime = (input.ociRuntime ?? process.env.ZHIVEX_HARNESS_OCI_RUNTIME ?? DEFAULT_OCI_EXECUTION.runtime).trim().toLowerCase();
+  if (!HARNESS_OCI_RUNTIMES.includes(runtime)) {
+    throw new HarnessConfigError(`ociRuntime must be one of: ${HARNESS_OCI_RUNTIMES.join(", ")}.`);
+  }
+  const image = (input.ociImage ?? process.env.ZHIVEX_HARNESS_OCI_IMAGE ?? DEFAULT_OCI_EXECUTION.image).trim();
+  if (!image || image.length > 512 || /[\u0000-\u001f\u007f\s]/.test(image) || image.startsWith("-")) {
+    throw new HarnessConfigError("ociImage must be a non-empty OCI image reference without whitespace or control characters.");
+  }
+  const shellMode = (input.ociShellMode ?? process.env.ZHIVEX_HARNESS_OCI_SHELL ?? DEFAULT_OCI_EXECUTION.shellMode).trim().toLowerCase();
+  if (!HARNESS_OCI_SHELL_MODES.includes(shellMode)) {
+    throw new HarnessConfigError(`ociShellMode must be one of: ${HARNESS_OCI_SHELL_MODES.join(", ")}.`);
+  }
+  const maxWorkspaceBytes = integerOption("ociMaxWorkspaceBytes", input.ociMaxWorkspaceBytes, process.env.ZHIVEX_HARNESS_OCI_MAX_WORKSPACE_BYTES, DEFAULT_OCI_EXECUTION.maxWorkspaceBytes, 1024 * 1024, 1024 * 1024 * 1024);
+  const maxFileWriteBytes = integerOption("ociMaxFileWriteBytes", input.ociMaxFileWriteBytes, process.env.ZHIVEX_HARNESS_OCI_MAX_FILE_WRITE_BYTES, DEFAULT_OCI_EXECUTION.maxFileWriteBytes, 1024, 16 * 1024 * 1024);
+  if (maxFileWriteBytes > maxWorkspaceBytes) {
+    throw new HarnessConfigError("ociMaxFileWriteBytes cannot exceed ociMaxWorkspaceBytes.");
+  }
+  return {
+    backend: "oci",
+    policyVersion: HARNESS_EXECUTION_POLICY_VERSION,
+    runtime,
+    image,
+    allowedCommands: resolveOciAllowedCommands(input.ociAllowedCommands),
+    shellMode,
+    maxProcessRuntimeMs: integerOption("ociMaxProcessRuntimeMs", input.ociMaxProcessRuntimeMs, process.env.ZHIVEX_HARNESS_OCI_MAX_PROCESS_RUNTIME_MS, DEFAULT_OCI_EXECUTION.maxProcessRuntimeMs, 1000, 60 * 60000),
+    maxProcessOutputBytes: integerOption("ociMaxProcessOutputBytes", input.ociMaxProcessOutputBytes, process.env.ZHIVEX_HARNESS_OCI_MAX_PROCESS_OUTPUT_BYTES, DEFAULT_OCI_EXECUTION.maxProcessOutputBytes, 1024, 1024 * 1024),
+    maxMemoryMb: integerOption("ociMaxMemoryMb", input.ociMaxMemoryMb, process.env.ZHIVEX_HARNESS_OCI_MAX_MEMORY_MB, DEFAULT_OCI_EXECUTION.maxMemoryMb, 64, 64 * 1024),
+    maxPids: integerOption("ociMaxPids", input.ociMaxPids, process.env.ZHIVEX_HARNESS_OCI_MAX_PIDS, DEFAULT_OCI_EXECUTION.maxPids, 16, 4096),
+    maxCpus: integerOption("ociMaxCpus", input.ociMaxCpus, process.env.ZHIVEX_HARNESS_OCI_MAX_CPUS, DEFAULT_OCI_EXECUTION.maxCpus, 1, 64),
+    maxWorkspaceBytes,
+    maxFileWriteBytes,
+    tmpfsMb: integerOption("ociTmpfsMb", input.ociTmpfsMb, process.env.ZHIVEX_HARNESS_OCI_TMPFS_MB, DEFAULT_OCI_EXECUTION.tmpfsMb, 16, 4096)
+  };
+};
+var canonicalWorkspaceFile = (requestedWorkspace, canonicalWorkspace, configured) => {
+  if (!configured?.trim()) {
+    return;
+  }
+  const requestedPath = path.resolve(requestedWorkspace, configured.trim());
+  const relative = path.relative(requestedWorkspace, requestedPath);
+  const insideRequestedWorkspace = relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  return insideRequestedWorkspace ? path.resolve(canonicalWorkspace, relative) : requestedPath;
+};
+var canonicalProjectContextFile = (requestedWorkspace, canonicalWorkspace, configured) => {
+  const candidate = canonicalWorkspaceFile(requestedWorkspace, canonicalWorkspace, configured);
+  const relative = path.relative(canonicalWorkspace, candidate);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new HarnessConfigError("contextConfigPath must resolve inside the workspace.");
+  }
+  return candidate;
+};
+var parseProvider = (value, registry = DEFAULT_PROVIDER_REGISTRY) => {
+  try {
+    return registry.parse(value);
+  } catch (error) {
+    if (error instanceof HarnessConfigError)
+      throw error;
+    throw new HarnessConfigError(error instanceof Error ? error.message : String(error), { cause: error });
+  }
+};
+var providerDescriptor = (provider, registry = DEFAULT_PROVIDER_REGISTRY) => registry.descriptor(provider);
+var resolveHarnessConfig = (input = {}, registry = DEFAULT_PROVIDER_REGISTRY) => {
+  if (input.schemaVersion !== undefined && input.schemaVersion !== HARNESS_CONFIG_SCHEMA_VERSION) {
+    throw new HarnessConfigError(`Unsupported config schema version: ${input.schemaVersion}. Expected ${HARNESS_CONFIG_SCHEMA_VERSION}.`);
+  }
+  const provider = parseProvider(input.provider ?? process.env.ZHIVEX_HARNESS_PROVIDER, registry);
+  const descriptor = providerDescriptor(provider, registry);
+  const requestedWorkspace = path.resolve(input.workspace ?? process.cwd());
+  let workspace = requestedWorkspace;
+  try {
+    workspace = realpathSync(requestedWorkspace);
+  } catch {}
+  const maxSteps = integerOption("maxSteps", input.maxSteps, process.env.ZHIVEX_HARNESS_MAX_STEPS, DEFAULT_HARNESS_MAX_STEPS, 1, Number.MAX_SAFE_INTEGER);
+  const storeBackend = (input.storeBackend ?? process.env.ZHIVEX_HARNESS_STORE ?? "sqlite").trim().toLowerCase();
+  if (!HARNESS_STORE_BACKENDS.includes(storeBackend)) {
+    throw new HarnessConfigError(`storeBackend must be one of: ${HARNESS_STORE_BACKENDS.join(", ")}.`);
+  }
+  const tenantId = scopeValue("tenantId", input.tenantId ?? process.env.ZHIVEX_HARNESS_TENANT_ID, "local");
+  const userId = scopeValue("userId", input.userId ?? process.env.ZHIVEX_HARNESS_USER_ID);
+  const namespace = scopeValue("namespace", input.namespace ?? process.env.ZHIVEX_HARNESS_NAMESPACE, defaultHarnessNamespace(workspace));
+  const timeoutMs = integerOption("timeoutMs", input.timeoutMs, process.env.ZHIVEX_HARNESS_TIMEOUT_MS, 15 * 60000, 1000, 24 * 60 * 60000);
+  if (input.unlimitedTokens !== undefined && typeof input.unlimitedTokens !== "boolean") {
+    throw new HarnessConfigError("unlimitedTokens must be a boolean.");
+  }
+  const tokenMode = input.unlimitedTokens === undefined ? {} : { unlimitedTokens: input.unlimitedTokens };
+  const budget = {
+    ...tokenMode,
+    maxSteps,
+    maxToolCalls: integerOption("maxToolCalls", input.maxToolCalls, process.env.ZHIVEX_HARNESS_MAX_TOOL_CALLS, DEFAULT_HARNESS_BUDGET.maxToolCalls, 0, Number.MAX_SAFE_INTEGER),
+    maxToolErrors: integerOption("maxToolErrors", input.maxToolErrors, process.env.ZHIVEX_HARNESS_MAX_TOOL_ERRORS, DEFAULT_HARNESS_BUDGET.maxToolErrors, 0, 100),
+    maxInputTokens: integerOption("maxInputTokens", input.maxInputTokens, process.env.ZHIVEX_HARNESS_MAX_INPUT_TOKENS, DEFAULT_HARNESS_BUDGET.maxInputTokens, 1, 1e7),
+    maxOutputTokens: integerOption("maxOutputTokens", input.maxOutputTokens, process.env.ZHIVEX_HARNESS_MAX_OUTPUT_TOKENS, DEFAULT_HARNESS_BUDGET.maxOutputTokens, 1, 1e7),
+    maxTotalTokens: integerOption("maxTotalTokens", input.maxTotalTokens, process.env.ZHIVEX_HARNESS_MAX_TOTAL_TOKENS, DEFAULT_HARNESS_BUDGET.maxTotalTokens, 1, 20000000),
+    includeChildRuns: true
+  };
+  if (budget.maxTotalTokens < budget.maxInputTokens || budget.maxTotalTokens < budget.maxOutputTokens) {
+    throw new HarnessConfigError("maxTotalTokens must be greater than or equal to the input and output token limits.");
+  }
+  const maxCostUsd = nonNegativeNumberOption("maxCostUsd", input.maxCostUsd, process.env.ZHIVEX_HARNESS_MAX_COST_USD);
+  const inputCostPerMillion = nonNegativeNumberOption("inputCostPerMillion", input.inputCostPerMillion, process.env.ZHIVEX_HARNESS_INPUT_COST_PER_MILLION);
+  const outputCostPerMillion = nonNegativeNumberOption("outputCostPerMillion", input.outputCostPerMillion, process.env.ZHIVEX_HARNESS_OUTPUT_COST_PER_MILLION);
+  if (maxCostUsd !== undefined && inputCostPerMillion === undefined && outputCostPerMillion === undefined) {
+    throw new HarnessConfigError("maxCostUsd requires inputCostPerMillion or outputCostPerMillion pricing.");
+  }
+  if (maxCostUsd === undefined && (inputCostPerMillion !== undefined || outputCostPerMillion !== undefined)) {
+    throw new HarnessConfigError("Token pricing requires maxCostUsd.");
+  }
+  const compaction = {
+    ...input.compactionModel ? { model: { provider: input.compactionProvider ?? provider, model: input.compactionModel } } : {},
+    maxMessages: integerOption("compactionMaxMessages", input.compactionMaxMessages, process.env.ZHIVEX_HARNESS_COMPACTION_MAX_MESSAGES, DEFAULT_HARNESS_COMPACTION.maxMessages, 4, 1e4),
+    maxEstimatedInputTokens: integerOption("compactionMaxEstimatedInputTokens", input.compactionMaxEstimatedInputTokens, process.env.ZHIVEX_HARNESS_COMPACTION_MAX_INPUT_TOKENS, DEFAULT_HARNESS_COMPACTION.maxEstimatedInputTokens, 1000, 1e7),
+    keepRecentMessages: integerOption("compactionKeepRecentMessages", input.compactionKeepRecentMessages, process.env.ZHIVEX_HARNESS_COMPACTION_KEEP_RECENT, DEFAULT_HARNESS_COMPACTION.keepRecentMessages, 2, 1000)
+  };
+  if (compaction.keepRecentMessages >= compaction.maxMessages) {
+    throw new HarnessConfigError("compactionKeepRecentMessages must be smaller than compactionMaxMessages.");
+  }
+  if (input.compactionProvider && !input.compactionModel)
+    throw new HarnessConfigError("compactionProvider requires compactionModel.");
+  if (compaction.model && (!/^[a-zA-Z0-9][a-zA-Z0-9._:/-]{0,159}$/.test(compaction.model.model) || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(compaction.model.provider)))
+    throw new HarnessConfigError("Invalid compaction model route.");
+  const childBudget = {
+    ...tokenMode,
+    maxSteps: integerOption("subagentMaxSteps", input.subagentMaxSteps, process.env.ZHIVEX_HARNESS_SUBAGENT_MAX_STEPS, DEFAULT_SUBAGENT_BUDGET.maxSteps, 1, Number.MAX_SAFE_INTEGER),
+    maxToolCalls: integerOption("subagentMaxToolCalls", input.subagentMaxToolCalls, process.env.ZHIVEX_HARNESS_SUBAGENT_MAX_TOOL_CALLS, DEFAULT_SUBAGENT_BUDGET.maxToolCalls, 0, Number.MAX_SAFE_INTEGER),
+    maxToolErrors: integerOption("subagentMaxToolErrors", input.subagentMaxToolErrors, process.env.ZHIVEX_HARNESS_SUBAGENT_MAX_TOOL_ERRORS, DEFAULT_SUBAGENT_BUDGET.maxToolErrors, 0, 50),
+    maxInputTokens: integerOption("subagentMaxInputTokens", input.subagentMaxInputTokens, process.env.ZHIVEX_HARNESS_SUBAGENT_MAX_INPUT_TOKENS, DEFAULT_SUBAGENT_BUDGET.maxInputTokens, 1, 2000000),
+    maxOutputTokens: integerOption("subagentMaxOutputTokens", input.subagentMaxOutputTokens, process.env.ZHIVEX_HARNESS_SUBAGENT_MAX_OUTPUT_TOKENS, DEFAULT_SUBAGENT_BUDGET.maxOutputTokens, 1, 2000000),
+    maxTotalTokens: integerOption("subagentMaxTotalTokens", input.subagentMaxTotalTokens, process.env.ZHIVEX_HARNESS_SUBAGENT_MAX_TOTAL_TOKENS, DEFAULT_SUBAGENT_BUDGET.maxTotalTokens, 1, 4000000),
+    includeChildRuns: false
+  };
+  if (childBudget.maxTotalTokens < childBudget.maxInputTokens || childBudget.maxTotalTokens < childBudget.maxOutputTokens) {
+    throw new HarnessConfigError("subagentMaxTotalTokens must be greater than or equal to the child input and output token limits.");
+  }
+  const orchestration = {
+    profiles: resolveSubagentProfiles(input.subagentProfiles),
+    childBudget,
+    childTimeoutMs: integerOption("subagentTimeoutMs", input.subagentTimeoutMs, process.env.ZHIVEX_HARNESS_SUBAGENT_TIMEOUT_MS, Math.min(timeoutMs, 5 * 60000), 1000, 24 * 60 * 60000),
+    maxParallelReviews: integerOption("maxParallelReviews", input.maxParallelReviews, process.env.ZHIVEX_HARNESS_MAX_PARALLEL_REVIEWS, 2, 1, 4)
+  };
+  const mcpConfigPath = canonicalWorkspaceFile(requestedWorkspace, workspace, input.mcpConfigPath ?? process.env.ZHIVEX_HARNESS_MCP_CONFIG);
+  const projectContext = input.projectContext ?? process.env.ZHIVEX_HARNESS_PROJECT_CONTEXT !== "0";
+  const contextConfigPath = canonicalProjectContextFile(requestedWorkspace, workspace, input.contextConfigPath ?? process.env.ZHIVEX_HARNESS_CONTEXT_CONFIG ?? ".zhivex/harness.json");
+  const execution = resolveExecutionConfig(input);
+  if (input.requireVerifiedDelivery !== undefined && typeof input.requireVerifiedDelivery !== "boolean")
+    throw new HarnessConfigError("requireVerifiedDelivery must be boolean.");
+  return {
+    schemaVersion: HARNESS_CONFIG_SCHEMA_VERSION,
+    provider,
+    model: input.model ?? process.env.ZHIVEX_HARNESS_MODEL ?? descriptor.defaultModel,
+    ...input.reasoningEffort === undefined || input.reasoningEffort === "default" ? {} : { reasoningEffort: reasoningEffortSchema.parse(input.reasoningEffort) },
+    workspace,
+    stateDirectory: canonicalStateDirectory(requestedWorkspace, workspace, input.stateDirectory),
+    storeBackend,
+    scope: {
+      tenantId,
+      ...userId ? { userId } : {},
+      ...namespace ? { namespace } : {}
+    },
+    maxSteps,
+    timeoutMs,
+    requireVerifiedDelivery: input.requireVerifiedDelivery ?? false,
+    budget,
+    ...maxCostUsd === undefined ? {} : {
+      costBudget: {
+        maxCostUsd,
+        inputCostPer1kTokens: (inputCostPerMillion ?? 0) / 1000,
+        outputCostPer1kTokens: (outputCostPerMillion ?? 0) / 1000
+      }
+    },
+    compaction,
+    allowedChecks: resolveAllowedChecks(input.allowedChecks),
+    requiredCapabilities: resolveRequiredCapabilities(input.requiredCapabilities),
+    orchestration,
+    context: {
+      enabled: projectContext,
+      configPath: contextConfigPath
+    },
+    execution,
+    ...mcpConfigPath ? { mcpConfigPath } : {}
+  };
+};
+var createProviderModel = (config, env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => {
+  try {
+    return registry.createModel(config, env);
+  } catch (error) {
+    throw new HarnessProviderError(`Provider ${config.provider} could not be initialized.`, {
+      cause: error,
+      retryable: false
+    });
+  }
+};
+var providerAvailability = (env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => registry.availability(env);
+export { HARNESS_ERROR_CODES, HARNESS_ERROR_SCHEMA_VERSION, HarnessError, HarnessConfigError, HarnessWorkspaceError, HarnessStateConflictError, HarnessProviderError, HarnessExecutionError, harnessErrorDocument, normalizeHarnessError, modelCatalogSchema, bundledModelCatalog, catalogModels, modelDescription, PROVIDERS, createProviderRegistry, BUILTIN_PROVIDER_REGISTRATIONS, DEFAULT_PROVIDER_REGISTRY, PROVIDER_DESCRIPTORS, reasoningEffortSchema, modelReasoningEfforts, withReasoningEffort, DEFAULT_ALLOWED_CHECKS, HARNESS_CONFIG_SCHEMA_VERSION, HARNESS_CONFIG_MIGRATABLE_SCHEMA_VERSIONS, HARNESS_STORE_BACKENDS, HARNESS_EXECUTION_BACKENDS, HARNESS_OCI_RUNTIMES, HARNESS_OCI_SHELL_MODES, HARNESS_EXECUTION_POLICY_VERSION, DEFAULT_OCI_EXECUTION, HARNESS_REQUIRED_CAPABILITIES, HARNESS_SUBAGENT_PROFILES, DEFAULT_HARNESS_MAX_STEPS, DEFAULT_HARNESS_BUDGET, DEFAULT_HARNESS_COMPACTION, DEFAULT_SUBAGENT_BUDGET, migrateHarnessConfigInput, defaultHarnessNamespace, parseProvider, providerDescriptor, resolveHarnessConfig, createProviderModel, providerAvailability };