@jmanuelcorral/openteam 0.24.0 → 0.24.1

package/dist/cli.js

@@ -3356,6 +3356,25 @@ var executionSetupMessages = {
 `),
   localOnlyTitle: "Local execution",
   localRequiredError: "local execution requires an enabled local runtime",
+  lemonadeDetectedHint: (loaded, advertised) => `detected - ${loaded} confirmed loaded of ${advertised} advertised text model(s)`,
+  lemonadeNoLoadedModels: "Lemonade has no text models verified as loaded and ready. Keep the intended model active in Lemonade and rerun setup; inactive or unknown models cannot be selected or entered manually.",
+  lemonadeModelNotLoaded: (model) => `Lemonade model "${model}" is not positively verified as loaded and ready. Keep that exact text model active and rerun setup; no substitute was selected and no implicit loading is allowed.`,
+  lemonadeProbeRequired: "Lemonade setup requires a fresh read-only residency probe before writing configuration. Use the CLI with its runtime probe enabled; manual model IDs cannot bypass this requirement.",
+  lemonadeProbeFailed: "Lemonade residency could not be verified at the configured endpoint. Check connectivity and the read-only /models, /health, and /internal/aliases responses, then rerun setup with the intended text models already active.",
+  lemonadeEndpointMismatch: "Lemonade endpoint/provider mapping differs from the selected runtime. Reconcile the configured base URL and provider before rerunning setup; no model was substituted.",
+  lemonadeModelIdentityUnknown: (model) => `Lemonade model "${model}" has no usable registered wire identity in the effective opencode configuration. Fix its model declaration before rerunning setup; setup will not replace or guess an alias.`,
+  lemonadeEffectiveConfigLabel: "effective setup configuration",
+  lemonadeEffectiveConfigAmbiguous: "Cannot establish one effective openteam configuration from the configured plugin loaders. Reconcile their options before rerunning setup; no provider identity was guessed.",
+  lemonadeRetainedProviderUnprotected: (providerID) => `Cannot safely keep retained Lemonade provider "${providerID}": the effective configuration must retain one matching Lemonade runtime, disabled when deselected. Reconcile the plugin options or machine overlay, or explicitly remove the provider registration before rerunning setup; no configuration was written.`,
+  lemonadeV2InvalidProvider: (providerID) => `Lemonade provider ${JSON.stringify(providerID)} cannot be represented as an exact native V2 policy resource. Choose a non-empty provider ID without wildcards, slashes, backslashes, or whitespace; setup will not broaden a deny rule.`,
+  lemonadeV2InvalidPolicies: "Cannot safely preserve experimental.policies: experimental must be an object and policies must be an array of provider.use statements with a string resource and allow/deny effect. Fix the project configuration before rerunning setup.",
+  lemonadeV2Title: "Lemonade transport compatibility",
+  lemonadeV2Restriction: (providers) => `Project policies disable native V2 Lemonade access for: ${providers.join(", ")}. Ordinary guarded V1 configuration remains supported; V2 is not an openteam-hook execution path. Higher-precedence or global policies can override this project restriction; it is not a server-atomic no-autoload guarantee.`,
+  lemonadeInventory: (instanceID, providerID, models) => {
+    const inventory = models.map((model) => `${model.modelID} (${model.loaded === true ? "loaded" : model.loaded === false ? "inactive" : "residency unknown"})`).join(", ");
+    return `Lemonade inventory ${instanceID} (provider ${providerID}): ${inventory || "no advertised text models"}. Only confirmed loaded text models count as ready.`;
+  },
+  lemonadeAgentResidency: (agent, model, state) => `Lemonade readiness: ${agent} (${model}): ${state === "not-loaded" ? "inactive (not ready)" : "residency unknown"}; advertised inventory is not loaded readiness. Keep this exact model active and verify residency before use; requests without verified readiness are blocked.`,
   mixedPrimaryQuestion: "Primary coordinator model",
   mixedPrimaryLocal: (model) => `Use local thinking model ${model}`,
   mixedPrimaryFrontier: "Choose a frontier model",
@@ -9248,7 +9267,7 @@ function parseOpencodeProviders(opencodeConfig) {
 function localRuntimeStates(config) {
   const map = new Map;
   for (const runtime of config.local.runtimes) {
-    map.set(runtime.id, { enabled: runtime.enabled });
+    map.set(runtime.defaultModel.providerID, { enabled: runtime.enabled });
   }
   return map;
 }
@@ -9256,7 +9275,7 @@ function disabledLocalProviderIDs(config) {
   const ids = new Set;
   for (const runtime of config.local.runtimes) {
     if (!runtime.enabled) {
-      ids.add(runtime.id);
+      ids.add(runtime.defaultModel.providerID);
     }
   }
   return ids;
@@ -9272,7 +9291,11 @@ function computeLive(model, isLocalProvider, liveModels) {
   if (!snapshot.reachable) {
     return "unreachable";
   }
-  return snapshot.modelIDs.has(model.modelID) ? "confirmed" : "not-advertised";
+  if (snapshot.modelIDs.has(model.modelID))
+    return "confirmed";
+  if (snapshot.residency?.has(model.modelID))
+    return snapshot.residency.get(model.modelID) === false ? "not-loaded" : "residency-unknown";
+  return "not-advertised";
 }
 function resolveAgentModel(model, context) {
   const isLocalProvider = KNOWN_LOCAL_PROVIDER_IDS.has(model.providerID) || context.localRuntimes.has(model.providerID);
@@ -16012,6 +16035,243 @@ function ensureFoundryV1BaseURL(endpoint) {
   }
 }
 
+// src/local/lemonadeResidency.ts
+import { z as z22 } from "zod";
+
+// src/messages/modelResidency.ts
+var reasons = {
+  unknown: "fresh residency metadata is unavailable, malformed, or ambiguous",
+  inactive: "the requested model is not verified as resident and serving",
+  identity: "the requested model identity can be rewritten or is ambiguous",
+  destination: "the request destination does not match its configured runtime",
+  transport: "this provider execution path cannot enforce the residency guard",
+  request: "this is not a supported, explicit model inference request",
+  cancelled: "the request was cancelled before residency could be verified",
+  timeout: "the residency metadata deadline expired",
+  configuration: "the residency guard configuration is invalid"
+};
+var modelResidencyMessages = {
+  blocked: (reason) => `[openteam] Lemonade model request blocked: ${reasons[reason]}.`,
+  providerDisabled: (providerID) => `[openteam] Lemonade provider "${providerID}" is disabled because its configured transport or runtime mapping cannot enforce loaded-only requests.`,
+  extractionRuntimeUnavailable: "[openteam] Memory extraction requires one enabled local runtime matching the configured extraction provider."
+};
+
+// src/local/lemonadeResidency.ts
+class ModelResidencyError extends Error {
+  code;
+  statusCode = 400;
+  isRetryable = false;
+  constructor(code) {
+    super(modelResidencyMessages.blocked(code));
+    this.code = code;
+    this.name = "ModelResidencyError";
+  }
+}
+var modelName = z22.string().min(1).refine((name) => name === name.trim());
+var LoadedModelSchema = z22.object({
+  model_name: modelName,
+  loaded: z22.boolean().optional(),
+  status: z22.string().optional(),
+  backend_alive: z22.boolean().optional(),
+  backend_health: z22.string().optional(),
+  watchdog_reset: z22.boolean().optional(),
+  watchdog_reset_reason: z22.string().optional(),
+  residency_class: z22.string().optional(),
+  slot_pool: z22.string().optional(),
+  checkpoint: z22.string().optional(),
+  type: z22.string().optional(),
+  device: z22.string().optional(),
+  backend_url: z22.string().optional(),
+  pid: z22.number().int().optional(),
+  launch_command: z22.unknown().optional(),
+  pinned: z22.boolean().optional(),
+  recipe: z22.string().optional(),
+  recipe_options: z22.unknown().optional(),
+  is_busy: z22.boolean().optional(),
+  is_streaming: z22.boolean().optional(),
+  max_context_window: z22.number().optional(),
+  cost_input_per_million: z22.number().optional(),
+  cost_output_per_million: z22.number().optional(),
+  last_use: z22.number().optional()
+}).strict();
+var TelemetrySchema = z22.object({
+  enabled: z22.boolean(),
+  captures: z22.array(z22.string()).optional()
+}).strict();
+var HealthSchema = z22.object({
+  status: z22.literal("ok"),
+  all_models_loaded: z22.array(LoadedModelSchema),
+  version: z22.string().optional(),
+  model_loaded: z22.string().nullable().optional(),
+  telemetry: TelemetrySchema.optional(),
+  max_models: z22.record(z22.string(), z22.number().int()).optional(),
+  pinned_models: z22.record(z22.string(), z22.number().int()).optional(),
+  pinned_helper_models: z22.record(z22.string(), z22.number().int()).optional(),
+  websocket_port: z22.number().int().optional(),
+  update_check_done: z22.boolean().optional()
+}).strict();
+var AliasSchema = z22.object({
+  alias: modelName,
+  target: modelName,
+  downloaded: z22.boolean().optional(),
+  recipe: z22.string().optional()
+}).strict();
+var AliasesSchema = z22.object({
+  aliases: z22.array(AliasSchema)
+}).strict();
+var MetadataRecordSchema = z22.record(z22.string(), z22.unknown());
+var inactiveStates = new Set([
+  "loading",
+  "downsizing",
+  "downsized",
+  "evicting",
+  "unloaded"
+]);
+var inactiveHealth = new Set(["stopped", "exited", "watchdog_reset"]);
+var standardPools = new Set([
+  "standard/llm",
+  "standard/embedding",
+  "standard/reranking",
+  "standard/transcription",
+  "standard/image",
+  "standard/tts",
+  "standard/audio-generation",
+  "standard/classification",
+  "standard/mesh"
+]);
+function usableState(entry) {
+  if (entry.loaded === false || entry.backend_alive === false || entry.watchdog_reset === true || typeof entry.status === "string" && inactiveStates.has(entry.status) || typeof entry.backend_health === "string" && inactiveHealth.has(entry.backend_health) || entry.residency_class === "routing_helper" || typeof entry.slot_pool === "string" && entry.slot_pool.startsWith("routing_helper/")) {
+    return false;
+  }
+  if (entry.loaded !== true || entry.backend_alive !== true || entry.watchdog_reset !== false || entry.status !== "ready" && entry.status !== "in_use" || entry.backend_health !== "ready" && entry.backend_health !== "busy" || entry.watchdog_reset_reason !== undefined && entry.watchdog_reset_reason !== "" || entry.residency_class !== undefined && entry.residency_class !== "standard" || entry.slot_pool !== undefined && (typeof entry.slot_pool !== "string" || !standardPools.has(entry.slot_pool))) {
+    return;
+  }
+  return true;
+}
+function projectMetadataObject(payload, keys) {
+  const record2 = MetadataRecordSchema.safeParse(payload);
+  if (!record2.success)
+    throw new ModelResidencyError("unknown");
+  return Object.fromEntries(keys.filter((key) => Object.hasOwn(record2.data, key)).map((key) => [key, record2.data[key]]));
+}
+function parseResidency(healthPayload, aliasPayload) {
+  const healthFields = projectMetadataObject(healthPayload, Object.keys(HealthSchema.shape));
+  if (Array.isArray(healthFields.all_models_loaded)) {
+    healthFields.all_models_loaded = healthFields.all_models_loaded.map((entry) => projectMetadataObject(entry, Object.keys(LoadedModelSchema.shape)));
+  }
+  if (healthFields.telemetry !== undefined) {
+    healthFields.telemetry = projectMetadataObject(healthFields.telemetry, Object.keys(TelemetrySchema.shape));
+  }
+  const aliasFields = projectMetadataObject(aliasPayload, Object.keys(AliasesSchema.shape));
+  if (Array.isArray(aliasFields.aliases)) {
+    aliasFields.aliases = aliasFields.aliases.map((entry) => projectMetadataObject(entry, Object.keys(AliasSchema.shape)));
+  }
+  const health = HealthSchema.safeParse(healthFields);
+  const aliases = AliasesSchema.safeParse(aliasFields);
+  if (!health.success || !aliases.success)
+    throw new ModelResidencyError("unknown");
+  const result = new Map;
+  for (const entry of health.data.all_models_loaded) {
+    if (result.has(entry.model_name))
+      throw new ModelResidencyError("unknown");
+    result.set(entry.model_name, {
+      loaded: entry.model_name.endsWith(":latest") ? undefined : usableState(entry),
+      metadata: entry
+    });
+  }
+  const seenAliases = new Set;
+  for (const entry of aliases.data.aliases) {
+    if (seenAliases.has(entry.alias))
+      throw new ModelResidencyError("unknown");
+    seenAliases.add(entry.alias);
+    result.set(entry.alias, {
+      loaded: undefined,
+      metadata: result.get(entry.alias)?.metadata ?? {}
+    });
+  }
+  return result;
+}
+function lemonadeBaseURL(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ModelResidencyError("destination");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !/^\/(?:api\/)?v[01]\/?$/.test(url.pathname)) {
+    throw new ModelResidencyError("destination");
+  }
+  return `${url.origin}${url.pathname.replace(/\/$/, "")}`;
+}
+async function withResidencyDeadline(operation, options) {
+  const timeoutMs = options.timeoutMs ?? 5000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new ModelResidencyError("configuration");
+  }
+  const controller = new AbortController;
+  const cancel = () => controller.abort(new ModelResidencyError("cancelled"));
+  if (options.signal?.aborted)
+    throw new ModelResidencyError("cancelled");
+  options.signal?.addEventListener("abort", cancel, { once: true });
+  const schedule = options.scheduleTimeout ?? ((callback, ms2) => {
+    const timer = setTimeout(callback, ms2);
+    return () => clearTimeout(timer);
+  });
+  let onAbort = () => {};
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(controller.signal.reason);
+    controller.signal.addEventListener("abort", onAbort, { once: true });
+  });
+  const clearTimer = schedule(() => controller.abort(new ModelResidencyError("timeout")), timeoutMs);
+  try {
+    controller.signal.throwIfAborted();
+    return await Promise.race([operation(controller.signal), aborted]);
+  } finally {
+    clearTimer();
+    options.signal?.removeEventListener("abort", cancel);
+    controller.signal.removeEventListener("abort", onAbort);
+    controller.abort();
+  }
+}
+async function metadata(url, fetch2, signal, headers) {
+  signal.throwIfAborted();
+  let payload;
+  try {
+    const response = await fetch2(url, {
+      method: "GET",
+      headers,
+      signal,
+      redirect: "error",
+      cache: "no-store"
+    });
+    signal.throwIfAborted();
+    if (!response.ok || response.redirected || response.url !== "" && response.url !== url) {
+      throw new ModelResidencyError("unknown");
+    }
+    payload = await response.json();
+  } catch {
+    signal.throwIfAborted();
+    throw new ModelResidencyError("unknown");
+  }
+  signal.throwIfAborted();
+  return payload;
+}
+async function readLemonadeResidency(baseURL, fetch2, options = {}) {
+  const base = lemonadeBaseURL(baseURL);
+  const headers = new Headers(options.headers);
+  headers.delete("content-type");
+  headers.delete("content-length");
+  headers.set("accept", "application/json");
+  headers.set("cache-control", "no-cache, no-store");
+  headers.delete("if-none-match");
+  headers.delete("if-modified-since");
+  return withResidencyDeadline(async (signal) => {
+    const aliases = await metadata(`${new URL(base).origin}/internal/aliases`, fetch2, signal, headers);
+    const health = await metadata(`${base}/health`, fetch2, signal, headers);
+    return parseResidency(health, aliases);
+  }, options);
+}
+
 // src/local/lemonade.ts
 var LEMONADE_DEFAULT_BASE_URL = "http://localhost:13305/api/v1";
 var NON_TEXT_LABELS = new Set([
@@ -16098,36 +16358,19 @@ function isNonTextModel(entry) {
   return entry.labels.some((label) => typeof label === "string" && NON_TEXT_LABELS.has(label));
 }
 async function readLoadedModels(baseURL, fetch2) {
-  let payload;
   try {
-    const response = await fetch2(`${baseURL}/health`, {
-      method: "GET",
-      headers: { accept: "application/json" }
-    });
-    if (!response.ok) {
-      return;
-    }
-    payload = await response.json();
+    const residency = await readLemonadeResidency(baseURL, fetch2);
+    return new Map([...residency].map(([name, entry]) => [
+      name,
+      {
+        loaded: entry.loaded,
+        slots: entry.loaded === true ? readSlotCount(entry.metadata) : undefined,
+        totalContextWindow: entry.loaded === true ? readLoadedContextWindow(entry.metadata) : undefined
+      }
+    ]));
   } catch {
     return;
   }
-  if (!isObject2(payload) || !Array.isArray(payload.all_models_loaded)) {
-    return;
-  }
-  const loaded = new Map;
-  for (const entry of payload.all_models_loaded) {
-    if (!isObject2(entry) || typeof entry.model_name !== "string") {
-      continue;
-    }
-    if (entry.loaded === false) {
-      continue;
-    }
-    loaded.set(entry.model_name, {
-      slots: readSlotCount(entry),
-      totalContextWindow: readLoadedContextWindow(entry)
-    });
-  }
-  return loaded;
 }
 function readSlotCount(entry) {
   return slotsFromLlamacppArgs(entry) ?? slotsFromLaunchCommand(entry);
@@ -16274,6 +16517,9 @@ function enrichWithLoadState(models, loaded) {
     if (hit === undefined) {
       return { ...base, loaded: false };
     }
+    if (hit.loaded !== true) {
+      return hit.loaded === false ? { ...base, loaded: false } : base;
+    }
     const contextWindow = derivedConservativeContextWindow(model.contextWindow, hit);
     return {
       ...base,
@@ -16290,6 +16536,11 @@ function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/local/modelResidency.ts
+function hasRequiredModelResidency(kind, model) {
+  return kind !== "lemonade" || model?.loaded === true;
+}
+
 // src/local/lmstudio.ts
 var LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1";
 function createLMStudioAdapter() {
@@ -16507,50 +16758,36 @@ function createDetect(exec) {
       foundryDiscovery: foundryDiscoveryFromExec(exec)
     });
     const snapshots = await registry.probe(DETECTION_RUNTIMES);
-    return snapshots.map((snapshot) => {
-      const detected = {
-        id: snapshot.id,
-        baseURL: snapshot.baseURL,
-        reachable: snapshot.reachable,
-        models: snapshot.models.map((model) => model.modelID)
-      };
-      if (snapshot.models.some((model) => model.loaded !== undefined)) {
-        detected.modelInfo = snapshot.models;
-      }
-      if (snapshot.error !== undefined) {
-        detected.error = snapshot.error;
-      }
-      return detected;
-    });
+    return DETECTION_RUNTIMES.map((runtime) => detectedRuntime(runtime, snapshots.find((snapshot) => snapshot.id === runtime.id)));
+  };
+}
+function detectedRuntime(runtime, snapshot) {
+  const modelInfo = snapshot?.models ?? [];
+  return {
+    id: runtime.id,
+    baseURL: snapshot?.baseURL ?? runtime.baseURL ?? "",
+    reachable: snapshot?.reachable ?? false,
+    models: modelInfo.filter((model) => hasRequiredModelResidency(localRuntimeKind(runtime), model)).map((model) => model.modelID),
+    modelInfo,
+    ...snapshot?.error === undefined ? {} : { error: snapshot.error }
   };
 }
 function createProbeRuntime(exec) {
-  return async (id, baseURL) => {
+  return async (kind, baseURL) => {
     const registry = new RuntimeRegistry({
       fetch: globalThis.fetch,
       clock: () => new Date().toISOString(),
       foundryDiscovery: foundryDiscoveryFromExec(exec)
     });
     const runtime = {
-      id,
+      id: kind,
+      kind,
       enabled: true,
       baseURL,
-      defaultModel: { providerID: id, modelID: "probe" }
+      defaultModel: { providerID: kind, modelID: "probe" }
     };
     const [snapshot] = await registry.probe([runtime]);
-    const detected = {
-      id,
-      baseURL: snapshot?.baseURL ?? baseURL,
-      reachable: snapshot?.reachable ?? false,
-      models: snapshot?.models.map((model) => model.modelID) ?? []
-    };
-    if (snapshot?.models.some((model) => model.loaded !== undefined) === true) {
-      detected.modelInfo = snapshot.models;
-    }
-    if (snapshot?.error !== undefined) {
-      detected.error = snapshot.error;
-    }
-    return detected;
+    return detectedRuntime(runtime, snapshot);
   };
 }
 
@@ -16663,11 +16900,11 @@ function planWorktreeReconciliation(input) {
 }
 
 // src/telemetry/otelConfig.ts
-import { z as z22 } from "zod";
-var OtelBackendConfigSchema = z22.object({
-  backend: z22.literal("opentelemetry"),
-  connectionEnv: z22.string().min(1),
-  serviceName: z22.string().min(1).optional()
+import { z as z23 } from "zod";
+var OtelBackendConfigSchema = z23.object({
+  backend: z23.literal("opentelemetry"),
+  connectionEnv: z23.string().min(1),
+  serviceName: z23.string().min(1).optional()
 }).strict();
 function parseConnectionString(raw) {
   const pairs = new Map;
@@ -17809,7 +18046,7 @@ import { posix as pathPosix, win32 as pathWin32 } from "node:path";
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.24.0",
+  version: "0.24.1",
   packageManager: "bun@1.3.14",
   description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
   license: "MIT",
@@ -17953,31 +18190,31 @@ function compareSemver(a, b) {
 }
 
 // src/graph/soakLedger.ts
-import { z as z23 } from "zod";
-var Sha256Schema2 = z23.string().regex(/^[0-9a-f]{64}$/);
-var SoakPlatformSchema = z23.enum(["linux", "win32", "darwin"]);
-var PrivacyPairSchema = z23.object({
-  surfacesScanned: z23.number().int().nonnegative(),
-  rawFindings: z23.number().int().nonnegative()
+import { z as z24 } from "zod";
+var Sha256Schema2 = z24.string().regex(/^[0-9a-f]{64}$/);
+var SoakPlatformSchema = z24.enum(["linux", "win32", "darwin"]);
+var PrivacyPairSchema = z24.object({
+  surfacesScanned: z24.number().int().nonnegative(),
+  rawFindings: z24.number().int().nonnegative()
 }).strict();
-var DuplicateEffectPairSchema = z23.object({
-  effectsExamined: z23.number().int().nonnegative(),
-  duplicatesFound: z23.number().int().nonnegative()
+var DuplicateEffectPairSchema = z24.object({
+  effectsExamined: z24.number().int().nonnegative(),
+  duplicatesFound: z24.number().int().nonnegative()
 }).strict();
-var ModelVerificationPairSchema = z23.object({
-  nodesChecked: z23.number().int().nonnegative(),
-  unverified: z23.number().int().nonnegative(),
-  mismatched: z23.number().int().nonnegative()
+var ModelVerificationPairSchema = z24.object({
+  nodesChecked: z24.number().int().nonnegative(),
+  unverified: z24.number().int().nonnegative(),
+  mismatched: z24.number().int().nonnegative()
 }).strict();
-var SoakObservationSchema = z23.object({
-  version: z23.literal(1),
-  seq: z23.number().int().nonnegative(),
-  timestamp: z23.string().datetime(),
+var SoakObservationSchema = z24.object({
+  version: z24.literal(1),
+  seq: z24.number().int().nonnegative(),
+  timestamp: z24.string().datetime(),
   platform: SoakPlatformSchema,
-  opencodeVersion: z23.string().min(1),
-  provenance: z23.enum(["genuine-usage", "ci-synthetic"]),
+  opencodeVersion: z24.string().min(1),
+  provenance: z24.enum(["genuine-usage", "ci-synthetic"]),
   traceDigest: Sha256Schema2,
-  criticalDivergences: z23.number().int().nonnegative().nullable(),
+  criticalDivergences: z24.number().int().nonnegative().nullable(),
   privacy: PrivacyPairSchema.nullable(),
   duplicateEffects: DuplicateEffectPairSchema.nullable(),
   modelVerification: ModelVerificationPairSchema.nullable(),
@@ -18259,6 +18496,12 @@ var KNOWN_RUNTIMES = [
     dynamicPort: true
   }
 ];
+var LEMONADE_PROJECT_CONFIG_CANDIDATES = [
+  ".opencode/opencode.jsonc",
+  ".opencode/opencode.json",
+  "opencode.jsonc",
+  "opencode.json"
+];
 function knownRuntime(id) {
   const found = KNOWN_RUNTIMES.find((runtime) => runtime.id === id);
   if (found === undefined) {
@@ -18275,7 +18518,44 @@ function choiceKind(choice) {
 function choiceProviderID(choice) {
   return choice.providerID ?? choice.id;
 }
+function selectableModelIDs(models, modelInfo, kind) {
+  const byID = new Map(modelInfo?.map((model) => [model.modelID, model]));
+  return models.filter((id) => hasRequiredModelResidency(kind, byID.get(id)));
+}
+function assertRuntimeResidency(choice, primary) {
+  const kind = localRuntimeKind(choice);
+  const references2 = [
+    choice.defaultModelID,
+    choice.thinkingModelID,
+    choice.coderModelID,
+    ...primary.providerID === choiceProviderID(choice) ? [primary.modelID] : []
+  ];
+  for (const id of references2) {
+    if (id === undefined)
+      continue;
+    const info = choice.models.includes(id) ? choice.modelInfo?.find((model) => model.modelID === id) : undefined;
+    if (!hasRequiredModelResidency(kind, info))
+      throw new Error(executionSetupMessages.lemonadeModelNotLoaded(`${choiceProviderID(choice)}/${id}`));
+  }
+}
+function assertSetupResidency(answers) {
+  for (const choice of answers.runtimes) {
+    if (choice.enabled) {
+      assertRuntimeResidency(choice, answers.primaryModel);
+    } else if (choiceProviderID(choice) === answers.primaryModel.providerID && !hasRequiredModelResidency(localRuntimeKind(choice), undefined)) {
+      throw new Error(executionSetupMessages.lemonadeModelNotLoaded(`${answers.primaryModel.providerID}/${answers.primaryModel.modelID}`));
+    }
+  }
+}
+function lemonadeV2Policies(providers) {
+  return [...new Set(providers)].sort().map((providerID) => {
+    if (providerID.length === 0 || /[*?\\/\s]/.test(providerID))
+      throw new Error(executionSetupMessages.lemonadeV2InvalidProvider(providerID));
+    return { action: "provider.use", resource: providerID, effect: "deny" };
+  });
+}
 function buildOpenTeamConfig(answers) {
+  assertSetupResidency(answers);
   const runtimes = answers.runtimes.filter((choice) => choice.enabled).map((choice) => {
     const runtime = {
       id: choice.id,
@@ -18344,6 +18624,8 @@ function orchestratorAgentModel(answers) {
   return { ...answers.primaryModel };
 }
 function buildOpencodeConfig(answers) {
+  assertSetupResidency(answers);
+  const policies = lemonadeV2Policies(answers.runtimes.filter((choice) => choice.enabled && choiceKind(choice) === "lemonade").map(choiceProviderID));
   const provider = {};
   const providerOwner = new Map;
   for (const choice of answers.runtimes) {
@@ -18356,7 +18638,7 @@ function buildOpencodeConfig(answers) {
       continue;
     }
     const providerID = choiceProviderID(choice);
-    const modelIDs = new Set(choice.models);
+    const modelIDs = new Set(selectableModelIDs(choice.models, choice.modelInfo, meta.id));
     modelIDs.add(choice.defaultModelID);
     if (choice.thinkingModelID !== undefined) {
       modelIDs.add(choice.thinkingModelID);
@@ -18412,6 +18694,8 @@ function buildOpencodeConfig(answers) {
   if (answers.yolo) {
     config.permission = { "*": "allow" };
   }
+  if (policies.length > 0)
+    config.experimental = { policies };
   return config;
 }
 function serializeOpencodeConfig(config) {
@@ -18511,10 +18795,11 @@ async function chooseFrontier(prompt, profiles) {
   }
   return parseFrontierRef(selected);
 }
-function orderModelChoices(models, modelInfo) {
+function orderModelChoices(models, modelInfo, kind) {
   const byID = new Map((modelInfo ?? []).map((model) => [model.modelID, model]));
   const anyLoadState = (modelInfo ?? []).some((model) => model.loaded !== undefined);
-  const decorated = models.map((modelID, index) => {
+  const offered = kind === undefined ? models : selectableModelIDs(models, modelInfo, kind);
+  const decorated = offered.map((modelID, index) => {
     const info = byID.get(modelID);
     return {
       modelID,
@@ -18540,27 +18825,34 @@ function modelStateSuffix(loaded, slots) {
   }
   return slots === undefined ? "(loaded)" : `(loaded · ${slots} slot${slots === 1 ? "" : "s"})`;
 }
-function preferredModelID(models, modelInfo) {
-  const loaded = (modelInfo ?? []).find((model) => model.loaded === true && models.includes(model.modelID));
-  return loaded?.modelID ?? models[0];
+function preferredModelID(models, modelInfo, kind) {
+  const offered = kind === undefined ? models : selectableModelIDs(models, modelInfo, kind);
+  const loaded = (modelInfo ?? []).find((model) => model.loaded === true && offered.includes(model.modelID));
+  return loaded?.modelID ?? offered[0];
 }
 async function chooseRuntimeModel(prompt, models, meta, modelInfo) {
-  if (models.length === 0) {
+  const offered = selectableModelIDs(models, modelInfo, meta.id);
+  if (offered.length === 0) {
+    if (meta.id === "lemonade")
+      throw new Error(executionSetupMessages.lemonadeNoLoadedModels);
     return prompt.text({
       message: `Default model for ${meta.label} (no models detected)`,
       placeholder: meta.fallbackModelID,
       initial: meta.fallbackModelID
     });
   }
-  const first = preferredModelID(models, modelInfo);
+  const first = preferredModelID(offered, modelInfo, meta.id);
   const opts = {
     message: `Default local model for ${meta.label}`,
-    choices: orderModelChoices(models, modelInfo)
+    choices: orderModelChoices(offered, modelInfo, meta.id)
   };
   if (first !== undefined) {
     opts.initial = first;
   }
-  return prompt.select(opts);
+  const selected = await prompt.select(opts);
+  if (meta.id === "lemonade" && !offered.includes(selected))
+    throw new Error(executionSetupMessages.lemonadeModelNotLoaded(selected));
+  return selected;
 }
 function remoteBaseURLExample(meta) {
   const base = meta.defaultBaseURL ?? "http://localhost:11434/v1";
@@ -18615,6 +18907,8 @@ async function resolveRuntimeConnection(deps, meta, info) {
     initial: RUNTIME_LOCATION_LOCAL
   });
   if (location === RUNTIME_LOCATION_LOCAL) {
+    if (meta.id === "lemonade" && info?.reachable !== true)
+      throw new Error(executionSetupMessages.lemonadeProbeFailed);
     const baseURL2 = info?.baseURL !== undefined && info.baseURL.length > 0 ? info.baseURL : meta.defaultBaseURL;
     return { baseURL: baseURL2, ...connectionOf(info) };
   }
@@ -18624,16 +18918,26 @@ async function resolveRuntimeConnection(deps, meta, info) {
   });
   const baseURL = normalizeRemoteBaseURL(entered, meta.defaultBaseURL);
   let probedRuntime;
+  if (meta.id === "lemonade" && deps.probeRuntime === undefined)
+    throw new Error(executionSetupMessages.lemonadeProbeRequired);
   if (deps.probeRuntime !== undefined) {
     try {
       probedRuntime = await deps.probeRuntime(meta.id, baseURL);
-    } catch {}
+    } catch (cause) {
+      if (meta.id === "lemonade")
+        throw new Error(executionSetupMessages.lemonadeProbeFailed, { cause });
+    }
+    if (meta.id === "lemonade" && probedRuntime?.reachable !== true)
+      throw new Error(executionSetupMessages.lemonadeProbeFailed);
   }
   return { baseURL, ...connectionOf(probedRuntime) };
 }
 async function chooseClassModel(prompt, models, meta, defaultModelID, modelClass, modelInfo) {
   const label = modelClass === "thinking" ? `Thinking model for ${meta.label} (design, analysis, review reasoning)` : `Coder model for ${meta.label} (writing and editing code)`;
-  if (models.length === 0) {
+  const offered = selectableModelIDs(models, modelInfo, meta.id);
+  if (offered.length === 0) {
+    if (meta.id === "lemonade")
+      throw new Error(executionSetupMessages.lemonadeNoLoadedModels);
     const raw = await prompt.text({
       message: `${label} — enter to reuse the default`,
       placeholder: defaultModelID,
@@ -18641,14 +18945,17 @@ async function chooseClassModel(prompt, models, meta, defaultModelID, modelClass
     });
     return raw.trim().length > 0 ? raw.trim() : defaultModelID;
   }
-  return prompt.select({
+  const selected = await prompt.select({
     message: label,
-    choices: orderModelChoices(models, modelInfo).map((choice) => ({
+    choices: orderModelChoices(offered, modelInfo, meta.id).map((choice) => ({
       value: choice.value,
       label: choice.value === defaultModelID ? `${choice.label} — default` : choice.label
     })),
     initial: defaultModelID
   });
+  if (meta.id === "lemonade" && !offered.includes(selected))
+    throw new Error(executionSetupMessages.lemonadeModelNotLoaded(selected));
+  return selected;
 }
 async function resolveEnabledRuntime(deps, meta, info) {
   const connection = await resolveRuntimeConnection(deps, meta, info);
@@ -18661,7 +18968,8 @@ async function resolveEnabledRuntime(deps, meta, info) {
     defaultModelID,
     thinkingModelID,
     coderModelID,
-    models: connection.models
+    models: selectableModelIDs(connection.models, connection.modelInfo, meta.id),
+    ...connection.modelInfo === undefined ? {} : { modelInfo: connection.modelInfo }
   };
   if (connection.baseURL !== undefined) {
     choice.baseURL = connection.baseURL;
@@ -19161,17 +19469,52 @@ async function readExistingOpencodeConfigFiles(paths, deps) {
 function opencodeFileAt(files, path2) {
   return files.find((file) => file.path === path2);
 }
-function mergeExistingOpencodeConfigFiles(files) {
+function mergeExistingOpencodeConfigFiles(files, paths, planned = new Map) {
   let merged;
-  for (const path2 of [...OPENCODE_CONFIG_CANDIDATES].reverse()) {
-    const file = opencodeFileAt(files, path2);
-    if (file === undefined) {
+  for (const path2 of [...paths].reverse()) {
+    const raw = planned.get(path2) ?? opencodeFileAt(files, path2)?.raw;
+    if (raw === undefined) {
       continue;
     }
-    merged = merged === undefined ? file.raw : mergeOpencodeConfigs(merged, file.raw);
+    merged = merged === undefined ? raw : mergeOpencodeConfigs(merged, raw);
   }
   return merged;
 }
+async function effectiveSetupConfig(portable, files, deps) {
+  const optionsByLoader = new Map;
+  for (const file of files) {
+    if (!Array.isArray(file.raw.plugin))
+      continue;
+    for (const entry of [...file.raw.plugin].reverse()) {
+      const spec = extractPluginSpec(entry);
+      if (spec === undefined)
+        continue;
+      let identity;
+      if (isOpenteamNpmSpec(spec)) {
+        identity = OPENTEAM_PACKAGE_NAME;
+      } else if (isLocalFileSpec(spec) && await classifyLocalPluginSpecForSetup(spec, file.path, deps.classifyLocalPluginSpec) === "ours") {
+        const resolved = resolvePluginSpecPath(spec, file.path);
+        if (resolved === undefined)
+          throw new Error(executionSetupMessages.lemonadeEffectiveConfigAmbiguous);
+        identity = resolved;
+      } else {
+        continue;
+      }
+      if (!optionsByLoader.has(identity)) {
+        optionsByLoader.set(identity, Array.isArray(entry) ? entry[1] : undefined);
+      }
+    }
+  }
+  const overlayText = await deps.readFile(DEFAULT_LOCAL_OVERLAY_PATH);
+  const overlay = overlayText === undefined ? undefined : parseConfigFileJson(DEFAULT_LOCAL_OVERLAY_PATH, overlayText);
+  const resolutions = [
+    ...optionsByLoader.size > 0 ? optionsByLoader.values() : [undefined]
+  ].map((options) => validateConfigInput(executionSetupMessages.lemonadeEffectiveConfigLabel, mergeConfigInputs(mergeConfigInputs(portable, configOptionsFromPluginOptions(options)), overlay)));
+  const effective = resolutions[0];
+  if (effective === undefined || resolutions.some((config) => JSON.stringify(config) !== JSON.stringify(effective)))
+    throw new Error(executionSetupMessages.lemonadeEffectiveConfigAmbiguous);
+  return effective;
+}
 function relevantLocalProviderIDs(generated, existingOpenTeamConfig) {
   const ids = new Set(Object.keys(generated.provider ?? {}));
   for (const runtime of existingOpenTeamConfig?.local.runtimes ?? []) {
@@ -19348,15 +19691,42 @@ function highestExistingPinVersion(files) {
   }
   return highest;
 }
+function reconcileLemonadeV2Policies(raw, denials) {
+  if (denials.length === 0)
+    return raw;
+  const experimental = raw.experimental;
+  if (experimental !== undefined && !isRecord6(experimental))
+    throw new Error(executionSetupMessages.lemonadeV2InvalidPolicies);
+  const policies = experimental?.policies;
+  if (policies !== undefined && !Array.isArray(policies))
+    throw new Error(executionSetupMessages.lemonadeV2InvalidPolicies);
+  const existing = policies ?? [];
+  for (const policy of existing) {
+    if (!isRecord6(policy) || policy.action !== "provider.use" || typeof policy.resource !== "string" || policy.effect !== "allow" && policy.effect !== "deny")
+      throw new Error(executionSetupMessages.lemonadeV2InvalidPolicies);
+  }
+  const terminal = denials.every((denial, index) => {
+    const policy = existing[existing.length - denials.length + index];
+    return isRecord6(policy) && Object.keys(policy).length === 3 && policy.action === denial.action && policy.resource === denial.resource && policy.effect === denial.effect;
+  });
+  if (terminal)
+    return raw;
+  return {
+    ...raw,
+    experimental: { ...experimental, policies: [...existing, ...denials] }
+  };
+}
 function mergeOpencodeConfigForRerun(generated, targetRaw, options) {
   const effectiveRaw = options.effectiveRaw ?? targetRaw;
   const includePlugin = options.includePlugin ?? true;
+  const managesV2Policies = (generated.experimental?.policies.length ?? 0) > 0;
   const managedKeys = new Set([
     "$schema",
     "provider",
     "model",
     "small_model",
     "permission",
+    ...managesV2Policies ? ["experimental"] : [],
     ...includePlugin ? ["plugin"] : []
   ]);
   const unknownFields = {};
@@ -19419,7 +19789,10 @@ function mergeOpencodeConfigForRerun(generated, targetRaw, options) {
   if (permission !== undefined) {
     result.permission = permission;
   }
-  return result;
+  if (managesV2Policies && hasOwn2(targetRaw, "experimental")) {
+    result.experimental = targetRaw.experimental;
+  }
+  return reconcileLemonadeV2Policies(result, generated.experimental?.policies ?? []);
 }
 function mergeOpenTeamConfigForRerun(generated, existing) {
   const existingOrch = existing.orchestrator;
@@ -19469,6 +19842,21 @@ function mergeOpenTeamConfigForRerun(generated, existing) {
   assertEffectiveConfigModelDomains(merged);
   return merged;
 }
+function preserveRetainedLemonadeRuntimes(generated, previous, opencode) {
+  const providers = recordAt2(opencode, "provider") ?? {};
+  const retained = (previous?.local.runtimes ?? []).filter((runtime) => localRuntimeKind(runtime) === "lemonade" && hasOwn2(providers, runtime.defaultModel.providerID));
+  const deselected = retained.filter((runtime) => !generated.local.runtimes.some((selected) => selected.defaultModel.providerID === runtime.defaultModel.providerID)).map((runtime) => ({ ...runtime, enabled: false }));
+  return {
+    config: deselected.length === 0 ? generated : OpenTeamConfigSchema.parse({
+      ...generated,
+      local: {
+        ...generated.local,
+        runtimes: [...generated.local.runtimes, ...deselected]
+      }
+    }),
+    providerIDs: retained.map((runtime) => runtime.defaultModel.providerID)
+  };
+}
 async function existingPluginOwnerPath(files, classifyLocalPluginSpec) {
   let unknownLocalPlugin;
   for (const file of files) {
@@ -19496,6 +19884,86 @@ async function confirmJsonNormalization(prompt, path2, format) {
     initial: false
   });
 }
+function assertPreviousLemonadePrimary(answers, previousConfig) {
+  const priorLemonadePrimary = previousConfig?.local.runtimes.some((runtime) => runtime.defaultModel.providerID === answers.primaryModel.providerID && localRuntimeKind(runtime) === "lemonade");
+  if (priorLemonadePrimary && !answers.runtimes.some((choice) => choice.enabled && choiceProviderID(choice) === answers.primaryModel.providerID)) {
+    throw new Error(executionSetupMessages.lemonadeModelNotLoaded(`${answers.primaryModel.providerID}/${answers.primaryModel.modelID}`));
+  }
+}
+async function verifyLemonadeBeforeWrite(deps, answers, config, opencode) {
+  for (const choice of answers.runtimes) {
+    if (choice.enabled && localRuntimeKind(choice) === "lemonade" && !config.local.runtimes.some((runtime) => runtime.enabled && runtime.defaultModel.providerID === choiceProviderID(choice) && localRuntimeKind(runtime) === "lemonade"))
+      throw new Error(executionSetupMessages.lemonadeEndpointMismatch);
+  }
+  for (const runtime of config.local.runtimes) {
+    if (localRuntimeKind(runtime) !== "lemonade")
+      continue;
+    const providerID = runtime.defaultModel.providerID;
+    const provider = isRecord6(opencode.provider) ? opencode.provider[providerID] : undefined;
+    if (!runtime.enabled && provider === undefined)
+      continue;
+    const endpoint = isRecord6(provider) ? (isRecord6(provider.options) ? provider.options.baseURL : undefined) ?? provider.api : undefined;
+    if (typeof endpoint !== "string" || lemonadeBaseURL(endpoint) !== lemonadeBaseURL(runtime.baseURL ?? LEMONADE_DEFAULT_BASE_URL) || config.local.runtimes.filter((candidate) => candidate.defaultModel.providerID === providerID).length !== 1)
+      throw new Error(executionSetupMessages.lemonadeEndpointMismatch);
+    if (!runtime.enabled)
+      continue;
+    if (deps.probeRuntime === undefined)
+      throw new Error(executionSetupMessages.lemonadeProbeRequired);
+    const references2 = new Set([
+      runtime.defaultModel.modelID,
+      runtime.thinkingModel,
+      runtime.coderModel
+    ]);
+    for (const choice of answers.runtimes) {
+      if (choice.enabled && choiceProviderID(choice) === providerID) {
+        for (const id of [
+          ...choice.models,
+          choice.defaultModelID,
+          choice.thinkingModelID,
+          choice.coderModelID
+        ])
+          references2.add(id);
+      }
+    }
+    for (const ref of [
+      answers.primaryModel,
+      config.orchestrator?.primary?.model,
+      config.router.localDefault
+    ]) {
+      if (ref !== null && typeof ref === "object" && ref.providerID === providerID)
+        references2.add(ref.modelID);
+    }
+    for (const key of ["model", "small_model"]) {
+      const ref = opencode[key];
+      if (typeof ref === "string" && ref.startsWith(`${providerID}/`))
+        references2.add(ref.slice(providerID.length + 1));
+    }
+    const models = isRecord6(provider) ? recordAt2(provider, "models") : undefined;
+    const wireIDs = new Set;
+    for (const alias of references2) {
+      if (alias === undefined)
+        continue;
+      const declaration = recordAt2(models, alias);
+      const wireID = declaration !== undefined && hasOwn2(declaration, "id") ? declaration.id : alias;
+      if (declaration === undefined || typeof wireID !== "string" || wireID.length === 0 || wireID !== wireID.trim())
+        throw new Error(executionSetupMessages.lemonadeModelIdentityUnknown(`${providerID}/${alias}`));
+      wireIDs.add(wireID);
+    }
+    let fresh;
+    try {
+      fresh = await deps.probeRuntime(localRuntimeKind(runtime), endpoint);
+    } catch (cause) {
+      throw new Error(executionSetupMessages.lemonadeProbeFailed, { cause });
+    }
+    if (!fresh.reachable || fresh.id !== localRuntimeKind(runtime) || fresh.baseURL.replace(/\/+$/, "") !== endpoint.replace(/\/+$/, ""))
+      throw new Error(executionSetupMessages.lemonadeProbeFailed);
+    for (const wireID of wireIDs) {
+      const info = fresh.models.includes(wireID) ? fresh.modelInfo?.find((model) => model.modelID === wireID) : undefined;
+      if (!hasRequiredModelResidency("lemonade", info))
+        throw new Error(executionSetupMessages.lemonadeModelNotLoaded(`${providerID}/${wireID}`));
+    }
+  }
+}
 async function runSetup(deps) {
   const { prompt } = deps;
   try {
@@ -19507,7 +19975,7 @@ async function runSetup(deps) {
       return {
         value: meta.id,
         label: meta.label,
-        hint: info?.reachable ? `detected · ${info.models.length} model(s)` : "not detected (you can point it to another machine)",
+        hint: info?.reachable ? meta.id === "lemonade" ? executionSetupMessages.lemonadeDetectedHint(selectableModelIDs(info.models, info.modelInfo, meta.id).length, info.modelInfo?.length ?? info.models.length) : `detected · ${info.models.length} model(s)` : "not detected (you can point it to another machine)",
         selected: info?.reachable ?? false
       };
     });
@@ -19624,17 +20092,18 @@ async function runSetup(deps) {
     };
     const openTeamConfig = buildOpenTeamConfig(answers);
     const opencodeConfig = buildOpencodeConfig(answers);
+    const opencodeConfigPaths = LEMONADE_PROJECT_CONFIG_CANDIDATES;
     const orchestratorAgent = buildOrchestratorAgent(orchestratorAgentModel(answers), { yolo });
     const slashCommands = buildOpenteamCommands();
     const openTeamPath = DEFAULT_CONFIG_PATH;
-    const existingOpencodePath = await deps.resolveOpencodeWriteTarget(OPENCODE_CONFIG_CANDIDATES);
+    const existingOpencodePath = await deps.resolveOpencodeWriteTarget(opencodeConfigPaths);
     const opencodeDataPath = existingOpencodePath ?? OPENCODE_CONFIG_CANDIDATES[0];
     const agentPath = ORCHESTRATOR_AGENT_PATH;
     let existingOpenTeamConfig;
     let existingOpencodeFiles;
     try {
       existingOpenTeamConfig = await readExistingOpenTeamConfig(openTeamPath, deps);
-      existingOpencodeFiles = await readExistingOpencodeConfigFiles(OPENCODE_CONFIG_CANDIDATES, deps);
+      existingOpencodeFiles = await readExistingOpencodeConfigFiles(opencodeConfigPaths, deps);
     } catch (error) {
       if (error instanceof ConfigParseError) {
         return {
@@ -19644,7 +20113,29 @@ async function runSetup(deps) {
       }
       throw error;
     }
-    const effectiveExistingOpencode = mergeExistingOpencodeConfigFiles(existingOpencodeFiles);
+    assertPreviousLemonadePrimary(answers, existingOpenTeamConfig);
+    const effectiveExistingOpencode = mergeExistingOpencodeConfigFiles(existingOpencodeFiles, opencodeConfigPaths);
+    const {
+      config: finalOpenTeamConfig,
+      providerIDs: retainedLemonadeProviderIDs
+    } = preserveRetainedLemonadeRuntimes(existingOpenTeamConfig !== undefined ? mergeOpenTeamConfigForRerun(openTeamConfig, existingOpenTeamConfig) : openTeamConfig, existingOpenTeamConfig, effectiveExistingOpencode);
+    assertEffectiveConfigModelDomains(finalOpenTeamConfig);
+    const effectiveOpenTeamConfig = await effectiveSetupConfig(finalOpenTeamConfig, existingOpencodeFiles, deps);
+    assertEffectiveConfigModelDomains(effectiveOpenTeamConfig);
+    for (const providerID of retainedLemonadeProviderIDs) {
+      const matches = effectiveOpenTeamConfig.local.runtimes.filter((runtime) => runtime.defaultModel.providerID === providerID);
+      if (matches.length !== 1 || matches[0] === undefined || localRuntimeKind(matches[0]) !== "lemonade")
+        throw new Error(executionSetupMessages.lemonadeRetainedProviderUnprotected(providerID));
+    }
+    const v2Denials = lemonadeV2Policies([
+      ...opencodeConfig.experimental?.policies.map((policy) => policy.resource) ?? [],
+      ...effectiveOpenTeamConfig.local.runtimes.filter((runtime) => localRuntimeKind(runtime) === "lemonade").map((runtime) => runtime.defaultModel.providerID)
+    ]);
+    if (v2Denials.length > 0)
+      opencodeConfig.experimental = { policies: v2Denials };
+    const v2Notice = v2Denials.length > 0 ? executionSetupMessages.lemonadeV2Restriction(v2Denials.map((policy) => policy.resource)) : undefined;
+    if (v2Notice !== undefined)
+      prompt.note(v2Notice, executionSetupMessages.lemonadeV2Title);
     const relevantProviderIDs = relevantLocalProviderIDs(opencodeConfig, existingOpenTeamConfig);
     for (const file of existingOpencodeFiles) {
       assertRelevantLimitNumbers(file, relevantProviderIDs);
@@ -19673,8 +20164,6 @@ async function runSetup(deps) {
     const pluginOwnerFile = opencodeFileAt(existingOpencodeFiles, pluginOwnerPath);
     const pluginPlan = await mergePluginEntriesForRerun(Array.isArray(pluginOwnerFile?.raw.plugin) ? pluginOwnerFile.raw.plugin : [], pluginOwnerPath, preservePlugin, deps.classifyLocalPluginSpec);
     const includePluginInDataFile = pluginOwnerPath === opencodeDataPath;
-    const finalOpenTeamConfig = existingOpenTeamConfig !== undefined ? mergeOpenTeamConfigForRerun(openTeamConfig, existingOpenTeamConfig) : openTeamConfig;
-    assertEffectiveConfigModelDomains(finalOpenTeamConfig);
     const dataTargetRaw = opencodeFileAt(existingOpencodeFiles, opencodeDataPath)?.raw ?? {};
     const mergedOpencodeRaw = mergeOpencodeConfigForRerun(opencodeConfig, dataTargetRaw, {
       ...effectiveExistingOpencode !== undefined ? { effectiveRaw: effectiveExistingOpencode } : {},
@@ -19689,7 +20178,7 @@ async function runSetup(deps) {
       providerIDs: relevantProviderIDs
     });
     const opencodeWritePlan = new Map([
-      [opencodeDataPath, serializeOpencodeConfig(repairedDataTarget.raw)]
+      [opencodeDataPath, repairedDataTarget.raw]
     ]);
     for (const file of existingOpencodeFiles) {
       if (file.path === opencodeDataPath) {
@@ -19701,14 +20190,14 @@ async function runSetup(deps) {
         generated: opencodeConfig,
         providerIDs: relevantProviderIDs
       });
-      let plannedRaw = repaired.raw;
-      let changed = repaired.changed;
+      let plannedRaw = reconcileLemonadeV2Policies(repaired.raw, v2Denials);
+      let changed = repaired.changed || plannedRaw !== repaired.raw;
       if (file.path === pluginOwnerPath && !includePluginInDataFile && pluginPlan.changed) {
         plannedRaw = { ...plannedRaw, plugin: [...pluginPlan.plugins] };
         changed = true;
       }
       if (changed) {
-        opencodeWritePlan.set(file.path, serializeOpencodeConfig(plannedRaw));
+        opencodeWritePlan.set(file.path, plannedRaw);
       }
     }
     const opencodeGitignorePath = OPENCODE_GITIGNORE_PATH;
@@ -19772,9 +20261,13 @@ async function runSetup(deps) {
         stdout: shouldWriteOpencodeGitignore ? `setup cancelled by user; ${OPENCODE_GITIGNORE_PATH} ensured` : "setup cancelled by user"
       };
     }
+    const effectivePlannedOpencode = mergeExistingOpencodeConfigFiles(existingOpencodeFiles, opencodeConfigPaths, opencodeWritePlan);
+    if (effectivePlannedOpencode === undefined)
+      throw new Error(executionSetupMessages.lemonadeEndpointMismatch);
+    await verifyLemonadeBeforeWrite(deps, answers, effectiveOpenTeamConfig, effectivePlannedOpencode);
     await deps.writeFile(openTeamPath, serializeOpenTeamConfig(finalOpenTeamConfig));
     for (const [path2, contents] of opencodeWritePlan) {
-      await deps.writeFile(path2, contents);
+      await deps.writeFile(path2, serializeOpencodeConfig(contents));
     }
     await deps.writeFile(agentPath, orchestratorAgent);
     for (const command of slashCommands) {
@@ -19805,7 +20298,11 @@ async function runSetup(deps) {
     prompt.outro(executionSetupMessages.done);
     return {
       exitCode: 0,
-      stdout: executionSetupMessages.complete(`${writtenOpencodePaths}, ${DEFAULT_CONFIG_PATH}, ${ORCHESTRATOR_AGENT_PATH}, ${OPENTEAM_COMMAND_DIR}/*.md, ${OPENCODE_GITIGNORE_PATH}`)
+      stdout: [
+        executionSetupMessages.complete(`${writtenOpencodePaths}, ${DEFAULT_CONFIG_PATH}, ${ORCHESTRATOR_AGENT_PATH}, ${OPENTEAM_COMMAND_DIR}/*.md, ${OPENCODE_GITIGNORE_PATH}`),
+        ...v2Notice === undefined ? [] : [v2Notice]
+      ].join(`
+`)
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -20460,7 +20957,7 @@ import {
 import { basename as basename3, dirname as dirname8, join as join19, relative as relative2, resolve as resolve11, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify as promisify2 } from "node:util";
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var NPM_ORIGIN = "https://registry.npmjs.org";
 var NPM_PACKAGE_PATH = "/@jmanuelcorral%2Fopenteam";
 var NPM_LATEST_URL = `${NPM_ORIGIN}${NPM_PACKAGE_PATH}/latest`;
@@ -20479,9 +20976,9 @@ var UPGRADE_BACKUP_DIRECTORY = ".opencode/openteam-local/upgrade-backups";
 function npmVersionUrl(version) {
   return `${NPM_ORIGIN}${NPM_PACKAGE_PATH}/${version}`;
 }
-var RegistryPackageIdentitySchema = z24.object({
-  name: z24.string(),
-  version: z24.string()
+var RegistryPackageIdentitySchema = z25.object({
+  name: z25.string(),
+  version: z25.string()
 }).strict();
 
 class TransientFetchError extends Error {
@@ -22140,12 +22637,19 @@ function defaultModelFromOpencode(opencodeConfig) {
   }
   return;
 }
-function liveModelsFromSnapshots(snapshots) {
+function liveModelsFromSnapshots(snapshots, config) {
   const map = new Map;
   for (const snapshot of snapshots) {
-    map.set(snapshot.id, {
+    const runtime = config.local.runtimes.find((runtime2) => runtime2.id === snapshot.id);
+    if (runtime === undefined || !runtime.enabled)
+      continue;
+    const kind = localRuntimeKind(runtime);
+    map.set(runtime.defaultModel.providerID, {
       reachable: snapshot.reachable,
-      modelIDs: new Set(snapshot.models.map((model) => model.modelID))
+      modelIDs: new Set(snapshot.models.filter((model) => hasRequiredModelResidency(kind, model)).map((model) => model.modelID)),
+      ...kind === "lemonade" ? {
+        residency: new Map(snapshot.models.map((model) => [model.modelID, model.loaded]))
+      } : {}
     });
   }
   return map;
@@ -22431,7 +22935,7 @@ async function runCli(argv, deps) {
       const agentModels = diagnoseAgentModels(agentFiles, {
         opencodeProviders: parseOpencodeProviders(opencodeConfig),
         localRuntimes: localRuntimeStates(config),
-        liveModels: liveModelsFromSnapshots(snapshots),
+        liveModels: liveModelsFromSnapshots(snapshots, config),
         sourceDir: deps.agentDir,
         ...defaultModel !== undefined ? { defaultModel } : {}
       });
@@ -22470,29 +22974,53 @@ async function runCli(argv, deps) {
       const rosterMissing = deps.loadRosterForDoctor !== undefined && roster === undefined && rosterLoadError === undefined;
       const orchestratorAgentName = ORCHESTRATOR_AGENT_PATH.slice(ORCHESTRATOR_AGENT_PATH.lastIndexOf("/") + 1).replace(/\.md$/, "");
       const orchestratorAgentMissing = !agentFiles.some((file) => file.name === orchestratorAgentName);
+      const inventoryNotes = [];
+      const readySnapshots = snapshots.map((snapshot) => {
+        const runtime = config.local.runtimes.find((runtime2) => runtime2.id === snapshot.id);
+        if (runtime === undefined || localRuntimeKind(runtime) !== "lemonade")
+          return snapshot;
+        inventoryNotes.push(executionSetupMessages.lemonadeInventory(runtime.id, runtime.defaultModel.providerID, snapshot.models));
+        return {
+          ...snapshot,
+          models: snapshot.models.filter((model) => hasRequiredModelResidency(localRuntimeKind(runtime), model))
+        };
+      });
+      const residencyNotes = agentModels.flatMap((agent) => {
+        const live = agent.resolution?.live;
+        if (agent.model === undefined || live !== "not-loaded" && live !== "residency-unknown")
+          return [];
+        return [
+          executionSetupMessages.lemonadeAgentResidency(agent.name, `${agent.model.providerID}/${agent.model.modelID}`, live)
+        ];
+      });
       return {
         exitCode: 0,
-        stdout: renderDoctor({
-          config,
-          snapshots,
-          telemetryPath,
-          telemetryRecords: records.length,
-          agentModels,
-          opencodeConfigPaths,
-          ...opencodeConfig !== undefined ? { opencodeConfig } : {},
-          ...queueWait !== undefined ? { queueWait } : {},
-          ...rosterAudit !== undefined ? { rosterAudit } : {},
-          ...rosterRoleCount !== undefined ? { rosterRoleCount } : {},
-          ...rosterLoadError !== undefined ? { rosterLoadError } : {},
-          ...rosterMissing ? { rosterMissing } : {},
-          ...orchestratorAgentMissing ? { orchestratorAgentMissing } : {},
-          ...diagnostics !== undefined && diagnostics.length > 0 ? { diagnostics } : {},
-          ...opencodeConfigError !== undefined ? { opencodeConfigError } : {},
-          ...cacheEntries !== undefined ? { cacheEntries, cliVersion: deps.version } : {},
-          ...legacyLayout !== undefined && legacyLayout.length > 0 ? { legacyLayout } : {},
-          ...otelBackend !== undefined ? { otelBackend } : {},
-          ...gitignoreCoverage !== undefined ? { gitignore: gitignoreCoverage } : {}
-        })
+        stdout: [
+          renderDoctor({
+            config,
+            snapshots: readySnapshots,
+            telemetryPath,
+            telemetryRecords: records.length,
+            agentModels,
+            opencodeConfigPaths,
+            ...opencodeConfig !== undefined ? { opencodeConfig } : {},
+            ...queueWait !== undefined ? { queueWait } : {},
+            ...rosterAudit !== undefined ? { rosterAudit } : {},
+            ...rosterRoleCount !== undefined ? { rosterRoleCount } : {},
+            ...rosterLoadError !== undefined ? { rosterLoadError } : {},
+            ...rosterMissing ? { rosterMissing } : {},
+            ...orchestratorAgentMissing ? { orchestratorAgentMissing } : {},
+            ...diagnostics !== undefined && diagnostics.length > 0 ? { diagnostics } : {},
+            ...opencodeConfigError !== undefined ? { opencodeConfigError } : {},
+            ...cacheEntries !== undefined ? { cacheEntries, cliVersion: deps.version } : {},
+            ...legacyLayout !== undefined && legacyLayout.length > 0 ? { legacyLayout } : {},
+            ...otelBackend !== undefined ? { otelBackend } : {},
+            ...gitignoreCoverage !== undefined ? { gitignore: gitignoreCoverage } : {}
+          }),
+          ...inventoryNotes,
+          ...residencyNotes
+        ].join(`
+`)
       };
     }
     if (command === "migrate") {
@@ -22609,14 +23137,14 @@ ${HELP}`
 }
 
 // src/orchestrator/roster.ts
-import { z as z25 } from "zod";
-var RosterEntrySchema = z25.object({
-  roleID: z25.string().min(1),
-  agentName: z25.string().min(1)
+import { z as z26 } from "zod";
+var RosterEntrySchema = z26.object({
+  roleID: z26.string().min(1),
+  agentName: z26.string().min(1)
 }).strict();
-var RosterSchema = z25.object({
-  universe: z25.string().min(1),
-  entries: z25.array(RosterEntrySchema)
+var RosterSchema = z26.object({
+  universe: z26.string().min(1),
+  entries: z26.array(RosterEntrySchema)
 }).strict();
 var ROSTER_JSON_FENCE = /```json\s*([\s\S]*?)```/;
 
@@ -23170,7 +23698,7 @@ import { readFile as readFile4 } from "node:fs/promises";
 import { basename as basename4, dirname as dirname9 } from "node:path";
 
 // src/graph/certificate.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/contract/opencode.ts
 var SUPPORTED_OPENCODE_VERSIONS = [
@@ -23211,7 +23739,7 @@ function isCertificateVersionCompatible(certifiedVersion, liveVersion) {
 
 // src/graph/certificate.ts
 var SHADOW_CERTIFICATE_MIN_RUNS = 1000;
-var DivergenceCodeSchema = z26.enum([
+var DivergenceCodeSchema = z27.enum([
   "status",
   "order",
   "roles",
@@ -23219,50 +23747,50 @@ var DivergenceCodeSchema = z26.enum([
   "fixes",
   "outcome"
 ]);
-var ProvenanceSchema = z26.enum([
+var ProvenanceSchema = z27.enum([
   "recomputed",
   "compiled",
   "validated",
   "carried"
 ]);
-var EvidenceSchema = z26.object({
-  opencodeVersion: z26.string().min(1),
-  parity: z26.object({
-    runs: z26.number().int().nonnegative(),
-    match: z26.number().int().nonnegative(),
-    divergent: z26.number().int().nonnegative(),
-    inconclusive: z26.number().int().nonnegative(),
-    divergences: z26.array(DivergenceCodeSchema)
+var EvidenceSchema = z27.object({
+  opencodeVersion: z27.string().min(1),
+  parity: z27.object({
+    runs: z27.number().int().nonnegative(),
+    match: z27.number().int().nonnegative(),
+    divergent: z27.number().int().nonnegative(),
+    inconclusive: z27.number().int().nonnegative(),
+    divergences: z27.array(DivergenceCodeSchema)
   }).strict(),
-  legacy: z26.object({
-    observed: z26.number().int().nonnegative(),
-    duplicated: z26.number().int().nonnegative()
+  legacy: z27.object({
+    observed: z27.number().int().nonnegative(),
+    duplicated: z27.number().int().nonnegative()
   }).strict(),
-  privacy: z26.object({
-    surfacesScanned: z26.number().int().nonnegative(),
-    rawFindings: z26.number().int().nonnegative()
+  privacy: z27.object({
+    surfacesScanned: z27.number().int().nonnegative(),
+    rawFindings: z27.number().int().nonnegative()
   }).strict(),
-  overhead: z26.object({
-    p95Millis: z26.number().nonnegative(),
-    budgetMillis: z26.number().positive(),
-    samples: z26.number().int().nonnegative()
+  overhead: z27.object({
+    p95Millis: z27.number().nonnegative(),
+    budgetMillis: z27.number().positive(),
+    samples: z27.number().int().nonnegative()
   }).strict(),
-  provenance: z26.record(DivergenceCodeSchema, ProvenanceSchema)
+  provenance: z27.record(DivergenceCodeSchema, ProvenanceSchema)
 }).strict();
-var CertificateSchema = z26.object({
-  version: z26.literal(1),
-  certificate: z26.literal("graph-shadow"),
-  opencodeVersion: z26.string().min(1),
+var CertificateSchema = z27.object({
+  version: z27.literal(1),
+  certificate: z27.literal("graph-shadow"),
+  opencodeVersion: z27.string().min(1),
   evidence: EvidenceSchema,
-  verdict: z26.enum(["pass", "fail"]),
-  failedGates: z26.array(z26.enum([
+  verdict: z27.enum(["pass", "fail"]),
+  failedGates: z27.array(z27.enum([
     "sample",
     "parity",
     "one-legacy-execution",
     "privacy",
     "overhead"
   ])),
-  digest: z26.string().regex(/^[0-9a-f]{64}$/)
+  digest: z27.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
 
 class ShadowCertificateError extends Error {
@@ -23377,37 +23905,37 @@ function parseShadowCertificate(value, opencodeVersion) {
   }
   return certificate;
 }
-var ReleaseDeterminismSchema = z26.object({ runs: z26.number().int().nonnegative(), allMatch: z26.boolean() }).strict();
-var ReleaseCrashRecoverySchema = z26.object({
-  scenarios: z26.number().int().nonnegative(),
-  allConverge: z26.boolean()
+var ReleaseDeterminismSchema = z27.object({ runs: z27.number().int().nonnegative(), allMatch: z27.boolean() }).strict();
+var ReleaseCrashRecoverySchema = z27.object({
+  scenarios: z27.number().int().nonnegative(),
+  allConverge: z27.boolean()
 }).strict();
-var ReleaseReplayEquivalenceSchema = z26.object({
-  checks: z26.number().int().nonnegative(),
-  allEquivalent: z26.boolean()
+var ReleaseReplayEquivalenceSchema = z27.object({
+  checks: z27.number().int().nonnegative(),
+  allEquivalent: z27.boolean()
 }).strict();
-var ReleasePrivacySchema = z26.object({
-  surfacesScanned: z26.number().int().nonnegative(),
-  rawFindings: z26.number().int().nonnegative()
+var ReleasePrivacySchema = z27.object({
+  surfacesScanned: z27.number().int().nonnegative(),
+  rawFindings: z27.number().int().nonnegative()
 }).strict();
-var ReleaseContractSchema = z26.object({
-  roundTrips: z26.number().int().nonnegative(),
-  allSettled: z26.boolean()
+var ReleaseContractSchema = z27.object({
+  roundTrips: z27.number().int().nonnegative(),
+  allSettled: z27.boolean()
 }).strict();
-var ReleaseHealthSchema = z26.object({
-  samples: z26.number().int().nonnegative(),
-  bounded: z26.boolean(),
-  idempotent: z26.boolean()
+var ReleaseHealthSchema = z27.object({
+  samples: z27.number().int().nonnegative(),
+  bounded: z27.boolean(),
+  idempotent: z27.boolean()
 }).strict();
-var ReleasePerformanceSchema = z26.object({
-  p95Millis: z26.number().nonnegative(),
-  budgetMillis: z26.number().positive(),
-  samples: z26.number().int().nonnegative()
+var ReleasePerformanceSchema = z27.object({
+  p95Millis: z27.number().nonnegative(),
+  budgetMillis: z27.number().positive(),
+  samples: z27.number().int().nonnegative()
 }).strict();
-var ReleaseEvidenceSchema = z26.object({
-  opencodeVersion: z26.string().min(1),
-  platform: z26.enum(["linux", "win32"]),
-  shadowCertificateDigest: z26.string().regex(/^[0-9a-f]{64}$/),
+var ReleaseEvidenceSchema = z27.object({
+  opencodeVersion: z27.string().min(1),
+  platform: z27.enum(["linux", "win32"]),
+  shadowCertificateDigest: z27.string().regex(/^[0-9a-f]{64}$/),
   determinism: ReleaseDeterminismSchema,
   crashRecovery: ReleaseCrashRecoverySchema,
   replayEquivalence: ReleaseReplayEquivalenceSchema,
@@ -23416,15 +23944,15 @@ var ReleaseEvidenceSchema = z26.object({
   health: ReleaseHealthSchema,
   performance: ReleasePerformanceSchema
 }).strict();
-var ReleaseCertificateSchema = z26.object({
-  version: z26.literal(2),
-  certificate: z26.literal("graph-release"),
-  platform: z26.enum(["linux", "win32"]),
-  opencodeVersion: z26.string().min(1),
-  shadowCertificateDigest: z26.string().regex(/^[0-9a-f]{64}$/),
+var ReleaseCertificateSchema = z27.object({
+  version: z27.literal(2),
+  certificate: z27.literal("graph-release"),
+  platform: z27.enum(["linux", "win32"]),
+  opencodeVersion: z27.string().min(1),
+  shadowCertificateDigest: z27.string().regex(/^[0-9a-f]{64}$/),
   evidence: ReleaseEvidenceSchema,
-  verdict: z26.enum(["pass", "fail"]),
-  failedGates: z26.array(z26.enum([
+  verdict: z27.enum(["pass", "fail"]),
+  failedGates: z27.array(z27.enum([
     "shadow-valid",
     "determinism",
     "crash-recovery",
@@ -23434,7 +23962,7 @@ var ReleaseCertificateSchema = z26.object({
     "health",
     "performance"
   ])),
-  digest: z26.string().regex(/^[0-9a-f]{64}$/)
+  digest: z27.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
 
 class ReleaseCertificateError extends Error {
@@ -23562,7 +24090,7 @@ function parseReleaseCertificate(value, opencodeVersion, expectedShadowDigest) {
   }
   return certificate;
 }
-var ShadowDivergenceCodeSchema = z26.enum([
+var ShadowDivergenceCodeSchema = z27.enum([
   "status",
   "order",
   "roles",
@@ -23571,13 +24099,13 @@ var ShadowDivergenceCodeSchema = z26.enum([
   "outcome"
 ]);
 var RECOMPUTED_DIVERGENCE_CODES = ["fixes"];
-var RecomputedDivergenceCodeSchema = z26.enum(RECOMPUTED_DIVERGENCE_CODES);
-var SoakPolicySchema = z26.object({
-  minimumGenuineObservations: z26.number().int().positive(),
-  minimumDistinctDays: z26.number().int().positive(),
-  requireGenuineUsageOnAllPlatforms: z26.boolean(),
-  supportedOpencodeVersions: z26.array(z26.string().min(1)).min(1),
-  criticalDivergenceCodes: z26.array(RecomputedDivergenceCodeSchema).min(1)
+var RecomputedDivergenceCodeSchema = z27.enum(RECOMPUTED_DIVERGENCE_CODES);
+var SoakPolicySchema = z27.object({
+  minimumGenuineObservations: z27.number().int().positive(),
+  minimumDistinctDays: z27.number().int().positive(),
+  requireGenuineUsageOnAllPlatforms: z27.boolean(),
+  supportedOpencodeVersions: z27.array(z27.string().min(1)).min(1),
+  criticalDivergenceCodes: z27.array(RecomputedDivergenceCodeSchema).min(1)
 }).strict();
 var DEFAULT_SOAK_POLICY = {
   minimumGenuineObservations: 100,
@@ -23586,46 +24114,46 @@ var DEFAULT_SOAK_POLICY = {
   supportedOpencodeVersions: [...SUPPORTED_OPENCODE_VERSIONS],
   criticalDivergenceCodes: ["fixes"]
 };
-var SoakPlatformEnumSchema = z26.enum(["linux", "win32", "darwin"]);
-var SoakPrivacyPairEvidenceSchema = z26.object({
-  surfacesScanned: z26.number().int().nonnegative(),
-  rawFindings: z26.number().int().nonnegative()
+var SoakPlatformEnumSchema = z27.enum(["linux", "win32", "darwin"]);
+var SoakPrivacyPairEvidenceSchema = z27.object({
+  surfacesScanned: z27.number().int().nonnegative(),
+  rawFindings: z27.number().int().nonnegative()
 }).strict();
-var SoakDuplicateEffectPairEvidenceSchema = z26.object({
-  effectsExamined: z26.number().int().nonnegative(),
-  duplicatesFound: z26.number().int().nonnegative()
+var SoakDuplicateEffectPairEvidenceSchema = z27.object({
+  effectsExamined: z27.number().int().nonnegative(),
+  duplicatesFound: z27.number().int().nonnegative()
 }).strict();
-var SoakModelVerificationPairEvidenceSchema = z26.object({
-  nodesChecked: z26.number().int().nonnegative(),
-  unverified: z26.number().int().nonnegative(),
-  mismatched: z26.number().int().nonnegative()
+var SoakModelVerificationPairEvidenceSchema = z27.object({
+  nodesChecked: z27.number().int().nonnegative(),
+  unverified: z27.number().int().nonnegative(),
+  mismatched: z27.number().int().nonnegative()
 }).strict();
-var SoakEvidenceSchema = z26.object({
-  totalObservations: z26.number().int().nonnegative(),
-  genuineUsageObservations: z26.number().int().nonnegative(),
-  ciSyntheticObservations: z26.number().int().nonnegative(),
-  recorderCount: z26.number().int().nonnegative(),
-  ineligibleObservations: z26.number().int().nonnegative(),
-  firstTimestamp: z26.string().datetime().nullable(),
-  lastTimestamp: z26.string().datetime().nullable(),
-  distinctDays: z26.number().int().nonnegative(),
-  criticalDivergences: z26.number().int().nonnegative().nullable(),
+var SoakEvidenceSchema = z27.object({
+  totalObservations: z27.number().int().nonnegative(),
+  genuineUsageObservations: z27.number().int().nonnegative(),
+  ciSyntheticObservations: z27.number().int().nonnegative(),
+  recorderCount: z27.number().int().nonnegative(),
+  ineligibleObservations: z27.number().int().nonnegative(),
+  firstTimestamp: z27.string().datetime().nullable(),
+  lastTimestamp: z27.string().datetime().nullable(),
+  distinctDays: z27.number().int().nonnegative(),
+  criticalDivergences: z27.number().int().nonnegative().nullable(),
   privacy: SoakPrivacyPairEvidenceSchema.nullable(),
   duplicateEffects: SoakDuplicateEffectPairEvidenceSchema.nullable(),
   modelVerification: SoakModelVerificationPairEvidenceSchema.nullable(),
-  platformsGenuine: z26.array(SoakPlatformEnumSchema),
-  platformsSynthetic: z26.array(SoakPlatformEnumSchema),
-  opencodeVersionsObserved: z26.array(z26.string().min(1)),
-  invalidChains: z26.number().int().nonnegative()
+  platformsGenuine: z27.array(SoakPlatformEnumSchema),
+  platformsSynthetic: z27.array(SoakPlatformEnumSchema),
+  opencodeVersionsObserved: z27.array(z27.string().min(1)),
+  invalidChains: z27.number().int().nonnegative()
 }).strict();
-var SoakCertificateSchema = z26.object({
-  version: z26.literal(1),
-  certificate: z26.literal("graph-soak"),
-  trustBoundary: z26.literal("contributors"),
+var SoakCertificateSchema = z27.object({
+  version: z27.literal(1),
+  certificate: z27.literal("graph-soak"),
+  trustBoundary: z27.literal("contributors"),
   policy: SoakPolicySchema,
   evidence: SoakEvidenceSchema,
-  verdict: z26.enum(["pass", "fail"]),
-  failedGates: z26.array(z26.enum([
+  verdict: z27.enum(["pass", "fail"]),
+  failedGates: z27.array(z27.enum([
     "minimum-observations",
     "minimum-duration",
     "chain-integrity",
@@ -23636,8 +24164,8 @@ var SoakCertificateSchema = z26.object({
     "os-diversity",
     "opencode-pin"
   ])),
-  ledgerDigest: z26.string().regex(/^[0-9a-f]{64}$/),
-  digest: z26.string().regex(/^[0-9a-f]{64}$/)
+  ledgerDigest: z27.string().regex(/^[0-9a-f]{64}$/),
+  digest: z27.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
 
 class SoakCertificateError extends Error {
@@ -24285,62 +24813,62 @@ var realCacheAdapter = {
 };
 
 // src/memory/types.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var SHARED_OWNER_KEY = "*";
-var OwnerKeySchema = z27.string().min(1);
-var MemoryKindSchema = z27.enum(["fact", "preference", "entity"]);
-var MemoryBaseSchema = z27.object({
-  id: z27.string().min(1),
+var OwnerKeySchema = z28.string().min(1);
+var MemoryKindSchema = z28.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z28.object({
+  id: z28.string().min(1),
   ownerKey: OwnerKeySchema,
-  confidence: z27.number().min(0).max(1),
-  validFrom: z27.number().finite(),
-  validUntil: z27.number().finite().nullable().default(null),
-  createdAt: z27.number().finite(),
-  invalidatedAt: z27.number().finite().nullable().default(null),
-  sourceHash: z27.string().min(1),
-  supersededBy: z27.string().min(1).nullable().default(null)
+  confidence: z28.number().min(0).max(1),
+  validFrom: z28.number().finite(),
+  validUntil: z28.number().finite().nullable().default(null),
+  createdAt: z28.number().finite(),
+  invalidatedAt: z28.number().finite().nullable().default(null),
+  sourceHash: z28.string().min(1),
+  supersededBy: z28.string().min(1).nullable().default(null)
 }).strict();
 var FactSchema = MemoryBaseSchema.extend({
-  kind: z27.literal("fact"),
-  subject: z27.string().min(1),
-  predicate: z27.string().min(1),
-  object: z27.string().min(1),
-  category: z27.string().min(1).nullable().default(null)
+  kind: z28.literal("fact"),
+  subject: z28.string().min(1),
+  predicate: z28.string().min(1),
+  object: z28.string().min(1),
+  category: z28.string().min(1).nullable().default(null)
 });
 var PreferenceSchema = MemoryBaseSchema.extend({
-  kind: z27.literal("preference"),
-  category: z27.string().min(1),
-  preference: z27.string().min(1),
-  context: z27.string().min(1).nullable().default(null),
-  lastAccessedAt: z27.number().finite().nullable().default(null),
-  accessCount: z27.number().int().min(0).default(0)
+  kind: z28.literal("preference"),
+  category: z28.string().min(1),
+  preference: z28.string().min(1),
+  context: z28.string().min(1).nullable().default(null),
+  lastAccessedAt: z28.number().finite().nullable().default(null),
+  accessCount: z28.number().int().min(0).default(0)
 });
 var EntitySchema = MemoryBaseSchema.extend({
-  kind: z27.literal("entity"),
-  canonicalName: z27.string().min(1),
-  type: z27.string().min(1),
-  aliases: z27.array(z27.string().min(1)).default([])
+  kind: z28.literal("entity"),
+  canonicalName: z28.string().min(1),
+  type: z28.string().min(1),
+  aliases: z28.array(z28.string().min(1)).default([])
 });
 var RelationSchema = MemoryBaseSchema.extend({
-  kind: z27.literal("relation"),
-  from: z27.string().min(1),
-  to: z27.string().min(1),
-  predicate: z27.string().min(1),
-  annotation: z27.string().min(1).nullable().default(null)
+  kind: z28.literal("relation"),
+  from: z28.string().min(1),
+  to: z28.string().min(1),
+  predicate: z28.string().min(1),
+  annotation: z28.string().min(1).nullable().default(null)
 });
-var MemoryRecordSchema = z27.discriminatedUnion("kind", [
+var MemoryRecordSchema = z28.discriminatedUnion("kind", [
   FactSchema,
   PreferenceSchema,
   EntitySchema,
   RelationSchema
 ]);
-var RecallQuerySchema = z27.object({
+var RecallQuerySchema = z28.object({
   ownerKey: OwnerKeySchema,
-  kinds: z27.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
-  asOf: z27.number().finite().nullable().default(null),
-  limit: z27.number().int().positive().default(8),
-  minSimilarity: z27.number().min(0).max(1).default(0.2),
-  includeShared: z27.boolean().default(true)
+  kinds: z28.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z28.number().finite().nullable().default(null),
+  limit: z28.number().int().positive().default(8),
+  minSimilarity: z28.number().min(0).max(1).default(0.2),
+  includeShared: z28.boolean().default(true)
 }).strict();
 
 // src/memory/rank.ts