@jmanuelcorral/openteam 0.25.0 → 0.26.0

package/dist/cli.js

@@ -687,7 +687,8 @@ var LocalRuntimeKindSchema = z2.enum([
   "ollama",
   "lmstudio",
   "foundry-local",
-  "lemonade"
+  "lemonade",
+  "llama-swap"
 ]);
 var LocalRuntimeSchema = z2.object({
   id: z2.string().min(1),
@@ -707,13 +708,26 @@ var LocalRuntimeSchema = z2.object({
     ctx.addIssue({
       code: z2.ZodIssueCode.custom,
       path: ["kind"],
-      message: `local runtime "${runtime.id}" has no resolvable kind: add "kind" ` + "(one of ollama, lmstudio, foundry-local, lemonade), since the id is " + "not itself a runtime kind."
+      message: `local runtime "${runtime.id}" has no resolvable kind: add "kind" ` + "(one of ollama, lmstudio, foundry-local, lemonade, llama-swap), " + "since the id is not itself a runtime kind."
     });
   }
+}).transform((runtime) => {
+  const resolvedKind = runtime.kind ?? runtime.id;
+  if (resolvedKind !== "llama-swap" || runtime.maxConcurrency !== undefined) {
+    return runtime;
+  }
+  return { ...runtime, maxConcurrency: 1 };
 });
 function localRuntimeKind(runtime) {
   return runtime.kind ?? runtime.id;
 }
+function effectiveMaxConcurrency(runtime) {
+  if (runtime.maxConcurrency !== undefined) {
+    return runtime.maxConcurrency;
+  }
+  const kind = runtime.kind ?? (runtime.id !== undefined && LocalRuntimeKindSchema.safeParse(runtime.id).success ? runtime.id : undefined);
+  return kind === "llama-swap" ? 1 : DEFAULT_LOCAL_MAX_CONCURRENCY;
+}
 var MemoryScopeSchema = z2.enum(["project", "user"]);
 var MemoryExtractionModeSchema = z2.enum([
   "local",
@@ -3411,6 +3425,23 @@ var executionSetupMessages = {
 `),
   localOnlyTitle: "Local execution",
   localRequiredError: "local execution requires an enabled local runtime",
+  llamaSwap: {
+    label: "llama-swap",
+    noLoadedModels: "llama-swap has no canonical models verified as ready with no active routing profile. Keep the intended model ready through the operator's existing runtime controls, then rerun setup; manual IDs cannot bypass admission.",
+    modelNotLoaded: (model) => `llama-swap model "${model}" is not positively verified as canonical and ready without an active routing profile. No substitute was selected.`,
+    probeRequired: "llama-swap setup requires a fresh read-only residency probe before writing configuration. Manual model IDs cannot bypass this requirement.",
+    probeFailed: "llama-swap readiness could not be verified. Check the configured /v1/models catalog and origin /running and /api/profiles endpoints; authenticated runtimes are not supported.",
+    endpointMismatch: "llama-swap endpoint/provider mapping differs from the selected runtime. Reconcile the configured origin or /v1 URL and provider; no configuration was written.",
+    modelIdentityUnknown: (model) => `llama-swap model "${model}" has no usable registered physical identity. Fix its model declaration; setup will not guess an alias.`,
+    declaredLimits: "llama-swap context and output limits are operator-declared metadata, not measured per-slot capacities. Missing output metadata uses openteam's client policy default, not a guessed model cap. Unknown context remains 0 and disables automatic compaction. Tool support remains unknown without evidence.",
+    declaredLimitsTitle: "Declared llama-swap limits",
+    outputReduction: (model, previous, ceiling) => `${model}: reducing limit.output from ${previous} to ${ceiling} to respect the declared runtime ceiling. Smaller operator limits are preserved.`,
+    outputReductionTitle: "Declared output ceiling",
+    outputChanged: (model, ceiling) => `${model}: fresh runtime metadata declares an output ceiling of ${ceiling} below the prepared configuration. Rerun setup to review the updated limit; no configuration was written.`
+  },
+  residencyV2Title: "Resident runtime transport compatibility",
+  residencyV2Restriction: (providers) => `Project policies disable opencode's separate native/core V2 transport for resident-only providers: ${providers.join(", ")}. Guarded V1 provider transport remains supported; this does not ban the public SDK v2 client library. Higher-precedence policies can override project restrictions. Readiness preflight is not an atomic no-autoload guarantee.`,
+  retainedResidencyProviderUnprotected: (providerID) => `Cannot safely retain resident-only provider "${providerID}": the effective configuration must retain its matching runtime, disabled when deselected. Reconcile the runtime/provider configuration; no configuration was written.`,
   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.`,
@@ -3425,11 +3456,11 @@ var executionSetupMessages = {
   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) => {
+  lemonadeInventory: (instanceID, providerID, models, runtime = "Lemonade") => {
     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.`;
+    return `${runtime} 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.`,
+  lemonadeAgentResidency: (agent, model, state, runtime = "Lemonade") => `${runtime} 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",
@@ -3533,6 +3564,8 @@ var executionPolicyMessages = {
   primaryLocalMismatchRemedy: (sourceFile) => `      remedy: re-run \`openteam setup\` to regenerate ${sourceFile} and opencode.json from the same primary policy, then re-run \`openteam doctor\`.`
 };
 var doctorMessages = {
+  defaultRuntimeSlots: (slots) => ` · ${slots} slot(s) (default)`,
+  llamaSwapConcurrency: "    llama-swap does not report per-model slots; openteam uses the configured runtime-wide concurrency limit. No per-model capacity was inferred.",
   localModelLimits: {
     section: "  local model limits:",
     healthy: "    ✓ enabled local provider models declare valid output and context limits in opencode.json.",
@@ -3549,7 +3582,7 @@ var doctorMessages = {
     invalidInput: "invalid limit.input (expected a positive integer token count)",
     outputExceedsContext: "limit.output is greater than or equal to limit.context, so the configured context leaves no usable input window",
     outputExceedsInput: "limit.input is less than or equal to the reserved output budget, so compaction would have no usable input threshold",
-    outputRemedy: "    remedy: re-run `openteam setup` to write openteam's 8 192-token local output default, then re-run `openteam doctor`.",
+    outputRemedy: "    remedy: re-run `openteam setup` to write openteam's local output policy (at most 8 192 tokens, narrowed by declared runtime ceilings and smaller context/input budgets), then re-run `openteam doctor`.",
     unconfiguredLimitRemedy: "    remedy: the optional limit block may remain absent; to configure explicit limits, manually add a complete limit object in opencode.json with positive output and non-negative context (0 means unknown), because setup fills an absent limit block only for models the runtime currently discovers. Then re-run `openteam doctor`.",
     detectedContextRemedy: "    remedy: re-run `openteam setup` while the runtime is reachable to copy the detected usable context budget, then re-run `openteam doctor`.",
     unknownContextRemedy: "    remedy: re-run `openteam setup` to write the required context:0 sentinel; automatic compaction remains disabled until a positive context is configured.",
@@ -9183,6 +9216,7 @@ var PROVIDER_LABELS = {
   ollama: "Ollama",
   lmstudio: "LM Studio",
   lemonade: "Lemonade Server",
+  "llama-swap": executionSetupMessages.llamaSwap.label,
   "foundry-local": "Foundry Local"
 };
 function providerLabel(providerID) {
@@ -9404,7 +9438,8 @@ var KNOWN_LOCAL_PROVIDER_IDS = new Set([
   "ollama",
   "lmstudio",
   "foundry-local",
-  "lemonade"
+  "lemonade",
+  "llama-swap"
 ]);
 var KNOWN_FRONTIER_PROVIDER_IDS = new Set([
   "github-copilot",
@@ -16212,6 +16247,7 @@ 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",
+  "authentication-unsupported": "authentication is required but unsupported by this integration",
   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",
@@ -16220,22 +16256,72 @@ var reasons = {
   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."
+  blocked: (reason, runtimeLabel = "Lemonade", detail) => `[openteam] ${runtimeLabel} model request blocked: ${reasons[reason]}${detail === undefined ? "" : ` (${detail})`}.`,
+  providerDisabled: (providerID, runtimeLabel = "Lemonade") => `[openteam] ${runtimeLabel} 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.",
+  extractionRuntimeUnavailableFor: (runtimeLabel) => `[openteam] Memory extraction requires one enabled ${runtimeLabel} local runtime matching the configured extraction provider.`
+};
+var llamaSwapResidencyMessages = {
+  catalogModelDetail: (id, detail) => `catalog model "${id}" ${detail}`,
+  invalidCatalogField: (field) => `declares an invalid ${field}`,
+  catalogEntryMustExposeStringId: "catalog entries must expose a string id",
+  catalogModelIdsMustBeNonEmptyTrimmedStrings: "catalog model ids must be non-empty, trimmed strings",
+  expectedDataArray: (path) => `GET ${path} must return an object with a data array`,
+  duplicateCanonicalModelId: (modelID, path) => `duplicate canonical model id "${modelID}" in ${path}`,
+  httpFailure: (path, status) => `GET ${path} failed with HTTP ${status}`,
+  unverifiableResponse: (path) => `GET ${path} failed before a verifiable response`,
+  expectedProfilesArray: (path) => `GET ${path} must return an object with a profiles array`,
+  activeProfileRewrite: (profile) => `active profile "${profile}" can rewrite canonical model routing`,
+  invalidActiveProfileValue: (path) => `GET ${path} reported an invalid active profile value`,
+  expectedRunningArray: (path) => `GET ${path} must return an object with a running array`,
+  malformedRunningEvidence: (path) => `GET ${path} returned malformed model/state evidence`,
+  duplicateRunningEvidence: (path, modelID) => `GET ${path} returned duplicate evidence for "${modelID}"`
 };
 
-// src/local/lemonadeResidency.ts
+// src/local/residency.ts
 class ModelResidencyError extends Error {
   code;
   statusCode = 400;
   isRetryable = false;
-  constructor(code) {
-    super(modelResidencyMessages.blocked(code));
+  constructor(code, runtimeLabel = "Lemonade", detail) {
+    super(modelResidencyMessages.blocked(code, runtimeLabel, detail));
     this.code = code;
     this.name = "ModelResidencyError";
   }
 }
+async function withResidencyDeadline(operation, options) {
+  const timeoutMs = options.timeoutMs ?? 5000;
+  const runtimeLabel = options.runtimeLabel;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new ModelResidencyError("configuration", runtimeLabel);
+  }
+  const controller = new AbortController;
+  const cancel = () => controller.abort(new ModelResidencyError("cancelled", runtimeLabel));
+  if (options.signal?.aborted)
+    throw new ModelResidencyError("cancelled", runtimeLabel);
+  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", runtimeLabel)), 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();
+  }
+}
+
+// src/local/lemonadeResidency.ts
 var modelName = z22.string().min(1).refine((name) => name === name.trim());
 var LoadedModelSchema = z22.object({
   model_name: modelName,
@@ -16372,36 +16458,6 @@ function lemonadeBaseURL(value) {
   }
   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;
@@ -16705,9 +16761,314 @@ function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/local/llamaSwapResidency.ts
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+function readSupportsTools2(model) {
+  const direct = readBoolean2(model, [
+    "tool_call",
+    "tool_calls",
+    "toolCalling",
+    "supportsToolCalling",
+    "supports_tools",
+    "supportsTools"
+  ]);
+  if (direct !== undefined) {
+    return direct;
+  }
+  const capabilities = readCapabilityBoolean2(model.capabilities);
+  if (capabilities !== undefined) {
+    return capabilities;
+  }
+  const features = readCapabilityBoolean2(model.features);
+  if (features !== undefined) {
+    return features;
+  }
+  const labels = readCapabilityBoolean2(model.labels);
+  if (labels !== undefined) {
+    return labels;
+  }
+  return "unknown";
+}
+function readCapabilityBoolean2(value) {
+  if (Array.isArray(value)) {
+    if (value.some((entry) => typeof entry === "string" && ["tools", "tool_call", "tool-calling", "function_calling"].includes(entry))) {
+      return true;
+    }
+    return;
+  }
+  if (!isObject3(value)) {
+    return;
+  }
+  return readBoolean2(value, [
+    "tools",
+    "tool_call",
+    "tool_calls",
+    "toolCalling",
+    "function_calling",
+    "supportsToolCalling"
+  ]);
+}
+function readBoolean2(value, keys) {
+  for (const key of keys) {
+    if (typeof value[key] === "boolean") {
+      return value[key];
+    }
+  }
+  return;
+}
+function modelDetail(id, detail) {
+  return llamaSwapResidencyMessages.catalogModelDetail(id, detail);
+}
+function llamaSwapBaseURL(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ModelResidencyError("destination", "llama-swap");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "") {
+    throw new ModelResidencyError("destination", "llama-swap");
+  }
+  if (url.pathname === "/" || url.pathname === "") {
+    return `${url.origin}/v1`;
+  }
+  if (url.pathname === "/v1" || url.pathname === "/v1/") {
+    return `${url.origin}/v1`;
+  }
+  throw new ModelResidencyError("destination", "llama-swap");
+}
+function parseCanonicalType(entry, id) {
+  if (!isObject3(entry.meta) || !isObject3(entry.meta.llamaswap)) {
+    return;
+  }
+  const type = entry.meta.llamaswap.type;
+  if (type === undefined) {
+    return;
+  }
+  if (typeof type !== "string" || type.length === 0 || type !== type.trim()) {
+    throw new ModelResidencyError("unknown", "llama-swap", modelDetail(id, llamaSwapResidencyMessages.invalidCatalogField("meta.llamaswap.type")));
+  }
+  return type === "model" ? "model" : undefined;
+}
+function readContextCandidates(entry) {
+  const values = [
+    readPositiveSafeInteger(entry.context_length),
+    readPositiveSafeInteger(entry.context_window),
+    isObject3(entry.meta) ? readPositiveSafeInteger(entry.meta.n_ctx) : undefined
+  ];
+  return values.filter((value) => value !== undefined);
+}
+function readDeclaredMaxOutput(entry, id) {
+  if (!isObject3(entry.meta) || !isObject3(entry.meta.llamaswap)) {
+    return;
+  }
+  if (!Object.hasOwn(entry.meta.llamaswap, "max_output_tokens")) {
+    return;
+  }
+  const maxOutputTokens = readPositiveSafeInteger(entry.meta.llamaswap.max_output_tokens);
+  if (maxOutputTokens === undefined) {
+    throw new ModelResidencyError("unknown", "llama-swap", modelDetail(id, llamaSwapResidencyMessages.invalidCatalogField("meta.llamaswap.max_output_tokens")));
+  }
+  return maxOutputTokens;
+}
+function parseCatalogModel(value) {
+  if (!isObject3(value) || typeof value.id !== "string") {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.catalogEntryMustExposeStringId);
+  }
+  const id = value.id;
+  if (id.length === 0 || id !== id.trim()) {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.catalogModelIdsMustBeNonEmptyTrimmedStrings);
+  }
+  if (parseCanonicalType(value, id) !== "model") {
+    return;
+  }
+  const model = {
+    modelID: id,
+    supportsTools: readSupportsTools2(value)
+  };
+  const contexts = readContextCandidates(value);
+  if (contexts.length > 0) {
+    model.contextWindow = Math.min(...contexts);
+    model.contextWindowProvenance = "declared";
+  }
+  const maxOutputTokens = readDeclaredMaxOutput(value, id);
+  if (maxOutputTokens !== undefined) {
+    model.maxOutputTokens = maxOutputTokens;
+    model.maxOutputTokensProvenance = "declared";
+  }
+  return model;
+}
+function parseCatalog(payload) {
+  if (!isObject3(payload) || !Array.isArray(payload.data)) {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.expectedDataArray("/v1/models"));
+  }
+  const seen = new Set;
+  const models = [];
+  for (const entry of payload.data) {
+    const model = parseCatalogModel(entry);
+    if (model === undefined) {
+      continue;
+    }
+    if (seen.has(model.modelID)) {
+      throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.duplicateCanonicalModelId(model.modelID, "/v1/models"));
+    }
+    seen.add(model.modelID);
+    models.push(model);
+  }
+  return models;
+}
+async function metadata2(url, fetch2, signal, headers) {
+  signal.throwIfAborted();
+  try {
+    const response = await fetch2(url, {
+      method: "GET",
+      headers,
+      signal,
+      redirect: "error",
+      cache: "no-store"
+    });
+    signal.throwIfAborted();
+    if (response.status === 401 || response.status === 403) {
+      throw new ModelResidencyError("authentication-unsupported", "llama-swap");
+    }
+    if (!response.ok || response.redirected || response.url !== "" && response.url !== url) {
+      throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.httpFailure(new URL(url).pathname, response.status));
+    }
+    return await response.json();
+  } catch (error) {
+    signal.throwIfAborted();
+    if (error instanceof ModelResidencyError) {
+      throw error;
+    }
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.unverifiableResponse(new URL(url).pathname));
+  }
+}
+function readProfiles(payload) {
+  if (!isObject3(payload) || !Array.isArray(payload.profiles)) {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.expectedProfilesArray("/api/profiles"));
+  }
+  if (payload.active === null) {
+    return;
+  }
+  if (typeof payload.active === "string" && payload.active.length > 0 && payload.active === payload.active.trim()) {
+    throw new ModelResidencyError("identity", "llama-swap", llamaSwapResidencyMessages.activeProfileRewrite(payload.active));
+  }
+  throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.invalidActiveProfileValue("/api/profiles"));
+}
+function readRunning(payload, modelIDs) {
+  if (!isObject3(payload) || !Array.isArray(payload.running)) {
+    throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.expectedRunningArray("/running"));
+  }
+  const result = new Map;
+  for (const modelID of modelIDs) {
+    result.set(modelID, { loaded: false });
+  }
+  const seen = new Set;
+  for (const entry of payload.running) {
+    if (!isObject3(entry) || typeof entry.model !== "string" || entry.model.length === 0 || entry.model !== entry.model.trim() || typeof entry.state !== "string" || entry.state.length === 0 || entry.state !== entry.state.trim()) {
+      throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.malformedRunningEvidence("/running"));
+    }
+    if (seen.has(entry.model)) {
+      throw new ModelResidencyError("unknown", "llama-swap", llamaSwapResidencyMessages.duplicateRunningEvidence("/running", entry.model));
+    }
+    seen.add(entry.model);
+    if (!modelIDs.has(entry.model)) {
+      continue;
+    }
+    result.set(entry.model, { loaded: entry.state === "ready" });
+  }
+  return result;
+}
+function requestHeaders(headers) {
+  const result = new Headers(headers);
+  result.delete("content-type");
+  result.delete("content-length");
+  result.set("accept", "application/json");
+  result.set("cache-control", "no-cache, no-store");
+  result.delete("if-none-match");
+  result.delete("if-modified-since");
+  return result;
+}
+function llamaSwapResidencyOptions(options) {
+  return { ...options, runtimeLabel: "llama-swap" };
+}
+async function readLlamaSwapCatalog(baseURL, fetch2, options = {}) {
+  const base = llamaSwapBaseURL(baseURL);
+  const headers = requestHeaders(options.headers);
+  return withResidencyDeadline(async (signal) => parseCatalog(await metadata2(`${base}/models`, fetch2, signal, headers)), llamaSwapResidencyOptions(options));
+}
+async function readLlamaSwapResidency(baseURL, fetch2, options = {}) {
+  const base = llamaSwapBaseURL(baseURL);
+  const origin = new URL(base).origin;
+  const headers = requestHeaders(options.headers);
+  return withResidencyDeadline(async (signal) => {
+    const models = await readLlamaSwapCatalog(base, fetch2, {
+      ...llamaSwapResidencyOptions(options),
+      signal
+    });
+    readProfiles(await metadata2(`${origin}/api/profiles`, fetch2, signal, headers));
+    return readRunning(await metadata2(`${origin}/running`, fetch2, signal, headers), new Set(models.map((model) => model.modelID)));
+  }, llamaSwapResidencyOptions(options));
+}
+
+// src/local/llamaSwap.ts
+var LLAMA_SWAP_DEFAULT_BASE_URL = "http://localhost:8080/v1";
+function withLoadedState(models, residency) {
+  return models.map((model) => {
+    const loaded = residency.get(model.modelID)?.loaded;
+    return loaded === undefined ? model : { ...model, loaded };
+  });
+}
+function createLlamaSwapAdapter() {
+  const listModels = async (options) => {
+    const baseURL = llamaSwapBaseURL(options.baseURL ?? LLAMA_SWAP_DEFAULT_BASE_URL);
+    const models = await readLlamaSwapCatalog(baseURL, options.fetch);
+    try {
+      return withLoadedState(models, await readLlamaSwapResidency(baseURL, options.fetch));
+    } catch (error) {
+      if (error instanceof ModelResidencyError && (error.code === "identity" || error.code === "unknown")) {
+        return models;
+      }
+      throw error;
+    }
+  };
+  return {
+    id: "llama-swap",
+    defaultBaseURL: LLAMA_SWAP_DEFAULT_BASE_URL,
+    listModels,
+    async probe(options) {
+      const baseURL = llamaSwapBaseURL(options.baseURL ?? LLAMA_SWAP_DEFAULT_BASE_URL);
+      try {
+        return {
+          id: "llama-swap",
+          baseURL,
+          reachable: true,
+          models: await listModels({ ...options, baseURL }),
+          probedAt: options.probedAt
+        };
+      } catch (error) {
+        return unavailableSnapshot({
+          id: "llama-swap",
+          baseURL,
+          probedAt: options.probedAt,
+          error
+        });
+      }
+    }
+  };
+}
+
 // src/local/modelResidency.ts
+function runtimeRequiresModelResidency(kind) {
+  return kind === "lemonade" || kind === "llama-swap";
+}
 function hasRequiredModelResidency(kind, model) {
-  return kind !== "lemonade" || model?.loaded === true;
+  return !runtimeRequiresModelResidency(kind) || model?.loaded === true;
 }
 
 // src/local/lmstudio.ts
@@ -16762,6 +17123,7 @@ class RuntimeRegistry {
       lmstudio: createLMStudioAdapter(),
       "foundry-local": createFoundryLocalAdapter(),
       lemonade: createLemonadeAdapter(),
+      "llama-swap": createLlamaSwapAdapter(),
       ...options.adapters
     };
     this.clock = options.clock;
@@ -16899,6 +17261,12 @@ var DETECTION_RUNTIMES = [
     baseURL: LEMONADE_DEFAULT_BASE_URL,
     defaultModel: { providerID: "lemonade", modelID: "probe" }
   },
+  {
+    id: "llama-swap",
+    enabled: true,
+    baseURL: LLAMA_SWAP_DEFAULT_BASE_URL,
+    defaultModel: { providerID: "llama-swap", modelID: "probe" }
+  },
   {
     id: "foundry-local",
     enabled: true,
@@ -17397,7 +17765,7 @@ function runtimeLine(snapshot, runtime) {
   const mark = snapshot.reachable ? "✓" : "✗";
   const detail = snapshot.reachable ? `${snapshot.models.length} model(s)` : snapshot.error ?? "unreachable";
   const declared = runtime?.maxConcurrency;
-  const slots = declared === undefined ? ` · ${DEFAULT_LOCAL_MAX_CONCURRENCY} slot(s) (default)` : ` · ${declared} slot(s) (declared)`;
+  const slots = declared === undefined ? doctorMessages.defaultRuntimeSlots(effectiveMaxConcurrency(runtime ?? {})) : ` · ${declared} slot(s) (declared)`;
   return `  ${mark} ${snapshot.id.padEnd(14)} ${snapshot.baseURL || "(no baseURL)"} — ${detail}${slots}`;
 }
 function runtimeModelSlotsLine(runtime, snapshot) {
@@ -17409,6 +17777,8 @@ function runtimeModelSlotsLine(runtime, snapshot) {
   if (runtime === undefined || snapshot === undefined || !snapshot.reachable || snapshot.models.length === 0) {
     return [];
   }
+  if (localRuntimeKind(runtime) === "llama-swap")
+    return [doctorMessages.llamaSwapConcurrency];
   const reported = snapshot.models.flatMap((model) => model.slots === undefined ? [] : [`${model.modelID} ${model.slots} slot(s)`]);
   if (reported.length > 0) {
     return [
@@ -17812,7 +18182,7 @@ function renderDoctor(input) {
       continue;
     }
     const runtime = enabledRuntimes.find((r) => r.id === snapshot.id);
-    const cap = runtime?.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY;
+    const cap = effectiveMaxConcurrency(runtime ?? {});
     lines.push(`  ⚠ ${snapshot.id} is reached over the network: its ${cap}-slot cap is enforced per openteam process, so`, "    two processes at once (an opencode session plus 'openteam console') can together exceed it.");
   }
   lines.push(`  telemetry: ${input.telemetryPath} — ${input.telemetryRecords} record(s)`);
@@ -18215,7 +18585,7 @@ import { posix as pathPosix, win32 as pathWin32 } from "node:path";
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.25.0",
+  version: "0.26.0",
   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",
@@ -18534,14 +18904,25 @@ function frontierModelsForProvider(profiles, providerID) {
 var OPENCODE_GITIGNORE_PATH = ".opencode/.gitignore";
 var DEFAULT_LOCAL_OUTPUT_TOKENS = 8192;
 var MIN_USABLE_INPUT_TOKENS = 1024;
-function computeModelLimit(contextWindow, inputBudget) {
+function computeModelLimit(contextWindow, inputBudget, maxOutputTokens) {
   const context = contextWindow ?? 0;
   const contextBudget = context > 0 ? context : undefined;
   const validInputBudget = inputBudget !== undefined && inputBudget > 0 ? inputBudget : undefined;
   const effectiveBudget = contextBudget === undefined ? validInputBudget : validInputBudget === undefined ? contextBudget : Math.min(contextBudget, validInputBudget);
-  const output = effectiveBudget !== undefined && effectiveBudget - DEFAULT_LOCAL_OUTPUT_TOKENS < MIN_USABLE_INPUT_TOKENS ? Math.max(1, Math.floor(effectiveBudget / 2)) : DEFAULT_LOCAL_OUTPUT_TOKENS;
+  const desired = Math.min(DEFAULT_LOCAL_OUTPUT_TOKENS, positiveInteger3(maxOutputTokens) ?? DEFAULT_LOCAL_OUTPUT_TOKENS);
+  const output = Math.min(desired, effectiveBudget !== undefined && effectiveBudget - desired < MIN_USABLE_INPUT_TOKENS ? Math.max(1, Math.floor(effectiveBudget / 2)) : desired);
   return { context, output };
 }
+function collectMaxOutputTokens(modelInfo, usedModelIDs) {
+  const used = new Set(usedModelIDs);
+  const ceilings = {};
+  for (const model of modelInfo ?? []) {
+    const ceiling = positiveInteger3(model.maxOutputTokens);
+    if (ceiling !== undefined && used.has(model.modelID))
+      ceilings[model.modelID] = ceiling;
+  }
+  return Object.keys(ceilings).length > 0 ? ceilings : undefined;
+}
 function collectContextWindows(modelInfo, usedModelIDs) {
   if (modelInfo === undefined) {
     return;
@@ -18658,6 +19039,12 @@ var KNOWN_RUNTIMES = [
     defaultBaseURL: LEMONADE_DEFAULT_BASE_URL,
     fallbackModelID: "Qwen3-Coder-30B-A3B-Instruct-GGUF"
   },
+  {
+    id: "llama-swap",
+    label: executionSetupMessages.llamaSwap.label,
+    defaultBaseURL: LLAMA_SWAP_DEFAULT_BASE_URL,
+    fallbackModelID: ""
+  },
   {
     id: "foundry-local",
     label: "Foundry Local",
@@ -18665,7 +19052,7 @@ var KNOWN_RUNTIMES = [
     dynamicPort: true
   }
 ];
-var LEMONADE_PROJECT_CONFIG_CANDIDATES = [
+var RESIDENT_PROJECT_CONFIG_CANDIDATES = [
   ".opencode/opencode.jsonc",
   ".opencode/opencode.json",
   "opencode.jsonc",
@@ -18687,6 +19074,19 @@ function choiceKind(choice) {
 function choiceProviderID(choice) {
   return choice.providerID ?? choice.id;
 }
+function residencySetupMessages(kind) {
+  return kind === "llama-swap" ? executionSetupMessages.llamaSwap : {
+    noLoadedModels: executionSetupMessages.lemonadeNoLoadedModels,
+    modelNotLoaded: executionSetupMessages.lemonadeModelNotLoaded,
+    probeRequired: executionSetupMessages.lemonadeProbeRequired,
+    probeFailed: executionSetupMessages.lemonadeProbeFailed,
+    endpointMismatch: executionSetupMessages.lemonadeEndpointMismatch,
+    modelIdentityUnknown: executionSetupMessages.lemonadeModelIdentityUnknown
+  };
+}
+function residencyBaseURL(kind, value) {
+  return kind === "llama-swap" ? llamaSwapBaseURL(value ?? LLAMA_SWAP_DEFAULT_BASE_URL) : lemonadeBaseURL(value ?? LEMONADE_DEFAULT_BASE_URL);
+}
 function selectableModelIDs(models, modelInfo, kind) {
   const byID = new Map(modelInfo?.map((model) => [model.modelID, model]));
   return models.filter((id) => hasRequiredModelResidency(kind, byID.get(id)));
@@ -18704,7 +19104,7 @@ function assertRuntimeResidency(choice, primary) {
       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}`));
+      throw new Error(residencySetupMessages(kind).modelNotLoaded(`${choiceProviderID(choice)}/${id}`));
   }
 }
 function assertSetupResidency(answers) {
@@ -18712,11 +19112,11 @@ function assertSetupResidency(answers) {
     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}`));
+      throw new Error(residencySetupMessages(localRuntimeKind(choice)).modelNotLoaded(`${answers.primaryModel.providerID}/${answers.primaryModel.modelID}`));
     }
   }
 }
-function lemonadeV2Policies(providers) {
+function residentV2Policies(providers) {
   return [...new Set(providers)].sort().map((providerID) => {
     if (providerID.length === 0 || /[*?\\/\s]/.test(providerID))
       throw new Error(executionSetupMessages.lemonadeV2InvalidProvider(providerID));
@@ -18733,7 +19133,7 @@ function buildOpenTeamConfig(answers) {
         providerID: choiceProviderID(choice),
         modelID: choice.defaultModelID
       },
-      maxConcurrency: choice.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY
+      maxConcurrency: effectiveMaxConcurrency(choice)
     };
     if (choice.modelConcurrency !== undefined && Object.keys(choice.modelConcurrency).length > 0) {
       runtime.modelConcurrency = { ...choice.modelConcurrency };
@@ -18748,7 +19148,7 @@ function buildOpenTeamConfig(answers) {
       runtime.kind = choice.kind;
     }
     if (choice.baseURL !== undefined) {
-      runtime.baseURL = choice.baseURL;
+      runtime.baseURL = localRuntimeKind(choice) === "llama-swap" ? llamaSwapBaseURL(choice.baseURL) : choice.baseURL;
     } else if (knownRuntime(choiceKind(choice)).dynamicPort === true) {
       runtime.discovery = "cli";
     }
@@ -18794,7 +19194,7 @@ function orchestratorAgentModel(answers) {
 }
 function buildOpencodeConfig(answers) {
   assertSetupResidency(answers);
-  const policies = lemonadeV2Policies(answers.runtimes.filter((choice) => choice.enabled && choiceKind(choice) === "lemonade").map(choiceProviderID));
+  const policies = residentV2Policies(answers.runtimes.filter((choice) => choice.enabled && runtimeRequiresModelResidency(localRuntimeKind(choice))).map(choiceProviderID));
   const provider = {};
   const providerOwner = new Map;
   for (const choice of answers.runtimes) {
@@ -18802,7 +19202,8 @@ function buildOpencodeConfig(answers) {
       continue;
     }
     const meta = knownRuntime(choiceKind(choice));
-    const baseURL = choice.baseURL ?? meta.defaultBaseURL;
+    const configuredBaseURL = choice.baseURL ?? meta.defaultBaseURL;
+    const baseURL = meta.id === "llama-swap" ? llamaSwapBaseURL(configuredBaseURL ?? LLAMA_SWAP_DEFAULT_BASE_URL) : configuredBaseURL;
     if (baseURL === undefined) {
       continue;
     }
@@ -18821,7 +19222,7 @@ function buildOpencodeConfig(answers) {
     const models = {};
     for (const modelID of modelIDs) {
       const contextWindow = choice.modelContextWindows?.[modelID];
-      const limit = computeModelLimit(contextWindow);
+      const limit = computeModelLimit(contextWindow, undefined, choice.modelMaxOutputTokens?.[modelID]);
       models[modelID] = { name: modelID, limit };
     }
     const owner = providerOwner.get(providerID);
@@ -19002,8 +19403,8 @@ function preferredModelID(models, modelInfo, kind) {
 async function chooseRuntimeModel(prompt, models, meta, modelInfo) {
   const offered = selectableModelIDs(models, modelInfo, meta.id);
   if (offered.length === 0) {
-    if (meta.id === "lemonade")
-      throw new Error(executionSetupMessages.lemonadeNoLoadedModels);
+    if (runtimeRequiresModelResidency(meta.id))
+      throw new Error(residencySetupMessages(meta.id).noLoadedModels);
     return prompt.text({
       message: `Default model for ${meta.label} (no models detected)`,
       placeholder: meta.fallbackModelID,
@@ -19019,8 +19420,8 @@ async function chooseRuntimeModel(prompt, models, meta, modelInfo) {
     opts.initial = first;
   }
   const selected = await prompt.select(opts);
-  if (meta.id === "lemonade" && !offered.includes(selected))
-    throw new Error(executionSetupMessages.lemonadeModelNotLoaded(selected));
+  if (runtimeRequiresModelResidency(meta.id) && !offered.includes(selected))
+    throw new Error(residencySetupMessages(meta.id).modelNotLoaded(selected));
   return selected;
 }
 function remoteBaseURLExample(meta) {
@@ -19076,28 +19477,31 @@ 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);
+    if (runtimeRequiresModelResidency(meta.id) && info?.reachable !== true)
+      throw new Error(info?.error ?? residencySetupMessages(meta.id).probeFailed);
     const baseURL2 = info?.baseURL !== undefined && info.baseURL.length > 0 ? info.baseURL : meta.defaultBaseURL;
-    return { baseURL: baseURL2, ...connectionOf(info) };
+    return {
+      baseURL: meta.id === "llama-swap" ? llamaSwapBaseURL(baseURL2) : baseURL2,
+      ...connectionOf(info)
+    };
   }
   const entered = await deps.prompt.text({
     message: `${meta.label} URL on the network (OpenAI-compatible endpoint)`,
     placeholder: remoteBaseURLExample(meta)
   });
-  const baseURL = normalizeRemoteBaseURL(entered, meta.defaultBaseURL);
+  const baseURL = meta.id === "llama-swap" ? llamaSwapBaseURL(entered) : normalizeRemoteBaseURL(entered, meta.defaultBaseURL);
   let probedRuntime;
-  if (meta.id === "lemonade" && deps.probeRuntime === undefined)
-    throw new Error(executionSetupMessages.lemonadeProbeRequired);
+  if (runtimeRequiresModelResidency(meta.id) && deps.probeRuntime === undefined)
+    throw new Error(residencySetupMessages(meta.id).probeRequired);
   if (deps.probeRuntime !== undefined) {
     try {
       probedRuntime = await deps.probeRuntime(meta.id, baseURL);
     } catch (cause) {
-      if (meta.id === "lemonade")
-        throw new Error(executionSetupMessages.lemonadeProbeFailed, { cause });
+      if (runtimeRequiresModelResidency(meta.id))
+        throw new Error(residencySetupMessages(meta.id).probeFailed, { cause });
     }
-    if (meta.id === "lemonade" && probedRuntime?.reachable !== true)
-      throw new Error(executionSetupMessages.lemonadeProbeFailed);
+    if (runtimeRequiresModelResidency(meta.id) && probedRuntime?.reachable !== true)
+      throw new Error(probedRuntime?.error ?? residencySetupMessages(meta.id).probeFailed);
   }
   return { baseURL, ...connectionOf(probedRuntime) };
 }
@@ -19105,8 +19509,8 @@ async function chooseClassModel(prompt, models, meta, defaultModelID, modelClass
   const label = modelClass === "thinking" ? `Thinking model for ${meta.label} (design, analysis, review reasoning)` : `Coder model for ${meta.label} (writing and editing code)`;
   const offered = selectableModelIDs(models, modelInfo, meta.id);
   if (offered.length === 0) {
-    if (meta.id === "lemonade")
-      throw new Error(executionSetupMessages.lemonadeNoLoadedModels);
+    if (runtimeRequiresModelResidency(meta.id))
+      throw new Error(residencySetupMessages(meta.id).noLoadedModels);
     const raw = await prompt.text({
       message: `${label} — enter to reuse the default`,
       placeholder: defaultModelID,
@@ -19122,8 +19526,8 @@ async function chooseClassModel(prompt, models, meta, defaultModelID, modelClass
     })),
     initial: defaultModelID
   });
-  if (meta.id === "lemonade" && !offered.includes(selected))
-    throw new Error(executionSetupMessages.lemonadeModelNotLoaded(selected));
+  if (runtimeRequiresModelResidency(meta.id) && !offered.includes(selected))
+    throw new Error(residencySetupMessages(meta.id).modelNotLoaded(selected));
   return selected;
 }
 async function resolveEnabledRuntime(deps, meta, info) {
@@ -19160,6 +19564,16 @@ async function resolveEnabledRuntime(deps, meta, info) {
   if (modelContextWindows !== undefined) {
     choice.modelContextWindows = modelContextWindows;
   }
+  const modelMaxOutputTokens = collectMaxOutputTokens(connection.modelInfo, [
+    defaultModelID,
+    thinkingModelID,
+    coderModelID,
+    ...connection.models
+  ]);
+  if (modelMaxOutputTokens !== undefined)
+    choice.modelMaxOutputTokens = modelMaxOutputTokens;
+  if (meta.id === "llama-swap")
+    deps.prompt.note(executionSetupMessages.llamaSwap.declaredLimits, executionSetupMessages.llamaSwap.declaredLimitsTitle);
   return choice;
 }
 function reportedModelSlots(modelInfo, usedModelIDs) {
@@ -19186,11 +19600,11 @@ async function promptSlotCount(prompt, meta, reported) {
   }
   const raw = await prompt.text({
     message: `How many concurrent generation slots does ${meta.label} have? (match its real capacity; leaving one free keeps interactive work responsive)`,
-    placeholder: String(DEFAULT_LOCAL_MAX_CONCURRENCY),
-    initial: String(DEFAULT_LOCAL_MAX_CONCURRENCY)
+    placeholder: String(effectiveMaxConcurrency({ id: meta.id })),
+    initial: String(effectiveMaxConcurrency({ id: meta.id }))
   });
   const parsed = Number.parseInt(raw.trim(), 10);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_LOCAL_MAX_CONCURRENCY;
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : effectiveMaxConcurrency({ id: meta.id });
 }
 function reportedSlotSummary(reported) {
   const entries = Object.entries(reported ?? {});
@@ -19249,6 +19663,29 @@ async function resolveRuntimeInstances(deps, meta, info, usedIds) {
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function setupOutputCeilings(answers, existing) {
+  const result = {};
+  const providers = recordAt2(existing, "provider");
+  for (const choice of answers.runtimes.filter((runtime) => runtime.enabled)) {
+    const physical = choice.modelMaxOutputTokens;
+    if (physical === undefined)
+      continue;
+    const providerID = choiceProviderID(choice);
+    const ceilings = { ...physical };
+    const models = recordAt2(recordAt2(providers, providerID), "models");
+    for (const [alias, value] of Object.entries(models ?? {})) {
+      if (!isRecord6(value))
+        continue;
+      const id = typeof value.id === "string" ? value.id : alias;
+      delete ceilings[alias];
+      const ceiling = physical[id];
+      if (ceiling !== undefined)
+        ceilings[alias] = ceiling;
+    }
+    result[providerID] = ceilings;
+  }
+  return result;
+}
 var LIMIT_FIELDS = [
   "context",
   "input",
@@ -19738,7 +20175,7 @@ function readModelLimitValues(limit) {
 function mergeModelLimitForRerun(input) {
   const target = readModelLimitValues(input.targetLimit);
   const effective = readModelLimitValues(input.effectiveLimit);
-  const computed = computeModelLimit(effective.context ?? input.generatedLimit?.context, effective.input);
+  const computed = computeModelLimit(effective.context ?? input.generatedLimit?.context, effective.input, input.maxOutputTokens);
   const merged = { ...input.targetLimit ?? {} };
   const targetOutputIsGeneratedDefault = target.output === DEFAULT_LOCAL_OUTPUT_TOKENS;
   if (targetOutputIsGeneratedDefault && effective.output !== undefined && effective.output !== DEFAULT_LOCAL_OUTPUT_TOKENS) {
@@ -19752,6 +20189,8 @@ function mergeModelLimitForRerun(input) {
   } else {
     merged.output = computed.output;
   }
+  if (input.maxOutputTokens !== undefined && typeof merged.output === "number")
+    merged.output = Math.min(merged.output, input.maxOutputTokens);
   if (target.context !== undefined) {
     merged.context = target.context;
   } else if (effective.context !== undefined) {
@@ -19771,7 +20210,8 @@ function completePhysicalModelLimit(input) {
   const target = readModelLimitValues(input.targetLimit);
   const effective = readModelLimitValues(input.effectiveLimit);
   const context = target.context ?? effective.context ?? input.generatedLimit?.context ?? 0;
-  const output = target.output ?? effective.output ?? computeModelLimit(context, effective.input).output;
+  const requestedOutput = target.output ?? effective.output ?? computeModelLimit(context, effective.input, input.maxOutputTokens).output;
+  const output = input.maxOutputTokens === undefined ? requestedOutput : Math.min(requestedOutput, input.maxOutputTokens);
   return { ...input.targetLimit, context, output };
 }
 function repairManagedModelLimits(input) {
@@ -19792,16 +20232,18 @@ function repairManagedModelLimits(input) {
     let providerChanged = false;
     const repairedModels = { ...targetModels };
     for (const [modelID, modelValue] of Object.entries(targetModels)) {
-      if (!isRecord6(modelValue) || !hasOwn2(modelValue, "limit")) {
+      const ceiling = input.modelOutputCeilings?.[providerID]?.[modelID];
+      if (!isRecord6(modelValue) || !hasOwn2(modelValue, "limit") && ceiling === undefined) {
         continue;
       }
-      const targetLimit = recordAt2(modelValue, "limit");
+      const targetLimit = recordAt2(modelValue, "limit") ?? (ceiling === undefined ? undefined : {});
       if (targetLimit === undefined) {
         continue;
       }
       const effectiveLimit = recordAt2(recordAt2(effectiveModels, modelID), "limit");
       const generatedLimit = generatedModelLimit(input.generated, providerID, modelID);
       const repairedLimit = completePhysicalModelLimit({
+        maxOutputTokens: ceiling,
         ...generatedLimit !== undefined ? { generatedLimit } : {},
         targetLimit,
         ...effectiveLimit !== undefined ? { effectiveLimit } : {}
@@ -19860,7 +20302,7 @@ function highestExistingPinVersion(files) {
   }
   return highest;
 }
-function reconcileLemonadeV2Policies(raw, denials) {
+function reconcileResidentV2Policies(raw, denials) {
   if (denials.length === 0)
     return raw;
   const experimental = raw.experimental;
@@ -19919,6 +20361,7 @@ function mergeOpencodeConfigForRerun(generated, targetRaw, options) {
       const targetLimit = recordAt2(targetModel, "limit");
       const effectiveLimit = recordAt2(effectiveModel, "limit");
       const mergedLimit = mergeModelLimitForRerun({
+        maxOutputTokens: options.modelOutputCeilings?.[providerID]?.[modelID],
         ...modelConfig.limit !== undefined ? { generatedLimit: modelConfig.limit } : {},
         ...targetLimit !== undefined ? { targetLimit } : {},
         ...effectiveLimit !== undefined ? { effectiveLimit } : {}
@@ -19961,7 +20404,7 @@ function mergeOpencodeConfigForRerun(generated, targetRaw, options) {
   if (managesV2Policies && hasOwn2(targetRaw, "experimental")) {
     result.experimental = targetRaw.experimental;
   }
-  return reconcileLemonadeV2Policies(result, generated.experimental?.policies ?? []);
+  return reconcileResidentV2Policies(result, generated.experimental?.policies ?? []);
 }
 function mergeOpenTeamConfigForRerun(generated, existing) {
   const existingOrch = existing.orchestrator;
@@ -20011,9 +20454,9 @@ function mergeOpenTeamConfigForRerun(generated, existing) {
   assertEffectiveConfigModelDomains(merged);
   return merged;
 }
-function preserveRetainedLemonadeRuntimes(generated, previous, opencode) {
+function preserveRetainedResidentRuntimes(generated, previous, opencode) {
   const providers = recordAt2(opencode, "provider") ?? {};
-  const retained = (previous?.local.runtimes ?? []).filter((runtime) => localRuntimeKind(runtime) === "lemonade" && hasOwn2(providers, runtime.defaultModel.providerID));
+  const retained = (previous?.local.runtimes ?? []).filter((runtime) => runtimeRequiresModelResidency(localRuntimeKind(runtime)) && 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({
@@ -20053,31 +20496,33 @@ 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}`));
+function assertPreviousResidentPrimary(answers, previousConfig) {
+  const priorResidentPrimary = previousConfig?.local.runtimes.find((runtime) => runtime.defaultModel.providerID === answers.primaryModel.providerID && runtimeRequiresModelResidency(localRuntimeKind(runtime)));
+  if (priorResidentPrimary && !answers.runtimes.some((choice) => choice.enabled && choiceProviderID(choice) === answers.primaryModel.providerID)) {
+    throw new Error(residencySetupMessages(localRuntimeKind(priorResidentPrimary)).modelNotLoaded(`${answers.primaryModel.providerID}/${answers.primaryModel.modelID}`));
   }
 }
-async function verifyLemonadeBeforeWrite(deps, answers, config, opencode) {
+async function verifyResidencyBeforeWrite(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);
+    if (choice.enabled && runtimeRequiresModelResidency(localRuntimeKind(choice)) && !config.local.runtimes.some((runtime) => runtime.enabled && runtime.defaultModel.providerID === choiceProviderID(choice) && localRuntimeKind(runtime) === localRuntimeKind(choice)))
+      throw new Error(residencySetupMessages(localRuntimeKind(choice)).endpointMismatch);
   }
   for (const runtime of config.local.runtimes) {
-    if (localRuntimeKind(runtime) !== "lemonade")
+    const kind = localRuntimeKind(runtime);
+    if (!runtimeRequiresModelResidency(kind))
       continue;
+    const messages = residencySetupMessages(kind);
     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 (typeof endpoint !== "string" || residencyBaseURL(kind, endpoint) !== residencyBaseURL(kind, runtime.baseURL) || config.local.runtimes.filter((candidate) => candidate.defaultModel.providerID === providerID).length !== 1)
+      throw new Error(messages.endpointMismatch);
     if (!runtime.enabled)
       continue;
     if (deps.probeRuntime === undefined)
-      throw new Error(executionSetupMessages.lemonadeProbeRequired);
+      throw new Error(messages.probeRequired);
     const references2 = new Set([
       runtime.defaultModel.modelID,
       runtime.thinkingModel,
@@ -20115,21 +20560,30 @@ async function verifyLemonadeBeforeWrite(deps, answers, config, opencode) {
       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}`));
+        throw new Error(messages.modelIdentityUnknown(`${providerID}/${alias}`));
       wireIDs.add(wireID);
     }
     let fresh;
     try {
       fresh = await deps.probeRuntime(localRuntimeKind(runtime), endpoint);
     } catch (cause) {
-      throw new Error(executionSetupMessages.lemonadeProbeFailed, { cause });
+      throw new Error(messages.probeFailed, { cause });
     }
-    if (!fresh.reachable || fresh.id !== localRuntimeKind(runtime) || fresh.baseURL.replace(/\/+$/, "") !== endpoint.replace(/\/+$/, ""))
-      throw new Error(executionSetupMessages.lemonadeProbeFailed);
+    if (!fresh.reachable || fresh.id !== localRuntimeKind(runtime) || residencyBaseURL(kind, fresh.baseURL) !== residencyBaseURL(kind, endpoint))
+      throw new Error(fresh.error ?? messages.probeFailed);
     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}`));
+      if (!hasRequiredModelResidency(kind, info))
+        throw new Error(messages.modelNotLoaded(`${providerID}/${wireID}`));
+    }
+    for (const [alias, declaration] of Object.entries(models ?? {})) {
+      if (!isRecord6(declaration))
+        continue;
+      const wireID = typeof declaration.id === "string" ? declaration.id : alias;
+      const ceiling = fresh.modelInfo?.find((model) => model.modelID === wireID)?.maxOutputTokens;
+      const output = positiveInteger3(recordAt2(declaration, "limit")?.output);
+      if (ceiling !== undefined && output !== undefined && output > ceiling)
+        throw new Error(executionSetupMessages.llamaSwap.outputChanged(`${providerID}/${alias}`, ceiling));
     }
   }
 }
@@ -20144,7 +20598,7 @@ async function runSetup(deps) {
       return {
         value: meta.id,
         label: meta.label,
-        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)",
+        hint: info?.reachable ? runtimeRequiresModelResidency(meta.id) ? 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
       };
     });
@@ -20261,7 +20715,7 @@ async function runSetup(deps) {
     };
     const openTeamConfig = buildOpenTeamConfig(answers);
     const opencodeConfig = buildOpencodeConfig(answers);
-    const opencodeConfigPaths = LEMONADE_PROJECT_CONFIG_CANDIDATES;
+    const opencodeConfigPaths = RESIDENT_PROJECT_CONFIG_CANDIDATES;
     const orchestratorAgent = buildOrchestratorAgent(orchestratorAgentModel(answers), { yolo });
     const slashCommands = buildOpenteamCommands();
     const openTeamPath = DEFAULT_CONFIG_PATH;
@@ -20282,29 +20736,44 @@ async function runSetup(deps) {
       }
       throw error;
     }
-    assertPreviousLemonadePrimary(answers, existingOpenTeamConfig);
+    assertPreviousResidentPrimary(answers, existingOpenTeamConfig);
     const effectiveExistingOpencode = mergeExistingOpencodeConfigFiles(existingOpencodeFiles, opencodeConfigPaths);
+    const modelOutputCeilings = setupOutputCeilings(answers, effectiveExistingOpencode);
+    const reductions = new Set;
+    for (const file of existingOpencodeFiles) {
+      for (const [providerID, ceilings] of Object.entries(modelOutputCeilings)) {
+        const models = recordAt2(recordAt2(recordAt2(file.raw, "provider"), providerID), "models");
+        for (const [modelID, ceiling] of Object.entries(ceilings)) {
+          const output = positiveInteger3(recordAt2(recordAt2(models, modelID), "limit")?.output);
+          if (output !== undefined && output > ceiling)
+            reductions.add(executionSetupMessages.llamaSwap.outputReduction(`${providerID}/${modelID}`, output, ceiling));
+        }
+      }
+    }
+    if (reductions.size > 0)
+      prompt.note([...reductions].join(`
+`), executionSetupMessages.llamaSwap.outputReductionTitle);
     const {
       config: finalOpenTeamConfig,
-      providerIDs: retainedLemonadeProviderIDs
-    } = preserveRetainedLemonadeRuntimes(existingOpenTeamConfig !== undefined ? mergeOpenTeamConfigForRerun(openTeamConfig, existingOpenTeamConfig) : openTeamConfig, existingOpenTeamConfig, effectiveExistingOpencode);
+      providerIDs: retainedResidentProviderIDs
+    } = preserveRetainedResidentRuntimes(existingOpenTeamConfig !== undefined ? mergeOpenTeamConfigForRerun(openTeamConfig, existingOpenTeamConfig) : openTeamConfig, existingOpenTeamConfig, effectiveExistingOpencode);
     assertEffectiveConfigModelDomains(finalOpenTeamConfig);
     const effectiveOpenTeamConfig = await effectiveSetupConfig(finalOpenTeamConfig, existingOpencodeFiles, deps);
     assertEffectiveConfigModelDomains(effectiveOpenTeamConfig);
-    for (const providerID of retainedLemonadeProviderIDs) {
+    for (const providerID of retainedResidentProviderIDs) {
       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));
+      if (matches.length !== 1 || matches[0] === undefined || !runtimeRequiresModelResidency(localRuntimeKind(matches[0])))
+        throw new Error(finalOpenTeamConfig.local.runtimes.some((runtime) => runtime.defaultModel.providerID === providerID && localRuntimeKind(runtime) === "lemonade") ? executionSetupMessages.lemonadeRetainedProviderUnprotected(providerID) : executionSetupMessages.retainedResidencyProviderUnprotected(providerID));
     }
-    const v2Denials = lemonadeV2Policies([
+    const v2Denials = residentV2Policies([
       ...opencodeConfig.experimental?.policies.map((policy) => policy.resource) ?? [],
-      ...effectiveOpenTeamConfig.local.runtimes.filter((runtime) => localRuntimeKind(runtime) === "lemonade").map((runtime) => runtime.defaultModel.providerID)
+      ...effectiveOpenTeamConfig.local.runtimes.filter((runtime) => runtimeRequiresModelResidency(localRuntimeKind(runtime))).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;
+    const v2Notice = v2Denials.length > 0 ? executionSetupMessages.residencyV2Restriction(v2Denials.map((policy) => policy.resource)) : undefined;
     if (v2Notice !== undefined)
-      prompt.note(v2Notice, executionSetupMessages.lemonadeV2Title);
+      prompt.note(v2Notice, executionSetupMessages.residencyV2Title);
     const relevantProviderIDs = relevantLocalProviderIDs(opencodeConfig, existingOpenTeamConfig);
     for (const file of existingOpencodeFiles) {
       assertRelevantLimitNumbers(file, relevantProviderIDs);
@@ -20335,12 +20804,14 @@ async function runSetup(deps) {
     const includePluginInDataFile = pluginOwnerPath === opencodeDataPath;
     const dataTargetRaw = opencodeFileAt(existingOpencodeFiles, opencodeDataPath)?.raw ?? {};
     const mergedOpencodeRaw = mergeOpencodeConfigForRerun(opencodeConfig, dataTargetRaw, {
+      modelOutputCeilings,
       ...effectiveExistingOpencode !== undefined ? { effectiveRaw: effectiveExistingOpencode } : {},
       includePlugin: includePluginInDataFile,
       ...includePluginInDataFile ? { pluginEntries: pluginPlan.plugins } : {},
       yolo
     });
     const repairedDataTarget = repairManagedModelLimits({
+      modelOutputCeilings,
       raw: mergedOpencodeRaw,
       effectiveRaw: effectiveExistingOpencode,
       generated: opencodeConfig,
@@ -20354,12 +20825,13 @@ async function runSetup(deps) {
         continue;
       }
       const repaired = repairManagedModelLimits({
+        modelOutputCeilings,
         raw: file.raw,
         effectiveRaw: effectiveExistingOpencode,
         generated: opencodeConfig,
         providerIDs: relevantProviderIDs
       });
-      let plannedRaw = reconcileLemonadeV2Policies(repaired.raw, v2Denials);
+      let plannedRaw = reconcileResidentV2Policies(repaired.raw, v2Denials);
       let changed = repaired.changed || plannedRaw !== repaired.raw;
       if (file.path === pluginOwnerPath && !includePluginInDataFile && pluginPlan.changed) {
         plannedRaw = { ...plannedRaw, plugin: [...pluginPlan.plugins] };
@@ -20433,7 +20905,7 @@ async function runSetup(deps) {
     const effectivePlannedOpencode = mergeExistingOpencodeConfigFiles(existingOpencodeFiles, opencodeConfigPaths, opencodeWritePlan);
     if (effectivePlannedOpencode === undefined)
       throw new Error(executionSetupMessages.lemonadeEndpointMismatch);
-    await verifyLemonadeBeforeWrite(deps, answers, effectiveOpenTeamConfig, effectivePlannedOpencode);
+    await verifyResidencyBeforeWrite(deps, answers, effectiveOpenTeamConfig, effectivePlannedOpencode);
     await deps.writeFile(openTeamPath, serializeOpenTeamConfig(finalOpenTeamConfig));
     for (const [path2, contents] of opencodeWritePlan) {
       await deps.writeFile(path2, serializeOpencodeConfig(contents));
@@ -22816,7 +23288,7 @@ function liveModelsFromSnapshots(snapshots, config) {
     map.set(runtime.defaultModel.providerID, {
       reachable: snapshot.reachable,
       modelIDs: new Set(snapshot.models.filter((model) => hasRequiredModelResidency(kind, model)).map((model) => model.modelID)),
-      ...kind === "lemonade" ? {
+      ...runtimeRequiresModelResidency(kind) ? {
         residency: new Map(snapshot.models.map((model) => [model.modelID, model.loaded]))
       } : {}
     });
@@ -23146,9 +23618,9 @@ async function runCli(argv, deps) {
       const inventoryNotes = [];
       const readySnapshots = snapshots.map((snapshot) => {
         const runtime = config.local.runtimes.find((runtime2) => runtime2.id === snapshot.id);
-        if (runtime === undefined || localRuntimeKind(runtime) !== "lemonade")
+        if (runtime === undefined || !runtimeRequiresModelResidency(localRuntimeKind(runtime)))
           return snapshot;
-        inventoryNotes.push(executionSetupMessages.lemonadeInventory(runtime.id, runtime.defaultModel.providerID, snapshot.models));
+        inventoryNotes.push(executionSetupMessages.lemonadeInventory(runtime.id, runtime.defaultModel.providerID, snapshot.models, localRuntimeKind(runtime) === "llama-swap" ? "llama-swap" : "Lemonade"));
         return {
           ...snapshot,
           models: snapshot.models.filter((model) => hasRequiredModelResidency(localRuntimeKind(runtime), model))
@@ -23159,7 +23631,7 @@ async function runCli(argv, deps) {
         if (agent.model === undefined || live !== "not-loaded" && live !== "residency-unknown")
           return [];
         return [
-          executionSetupMessages.lemonadeAgentResidency(agent.name, `${agent.model.providerID}/${agent.model.modelID}`, live)
+          executionSetupMessages.lemonadeAgentResidency(agent.name, `${agent.model.providerID}/${agent.model.modelID}`, live, config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === agent.model?.providerID && localRuntimeKind(runtime) === "llama-swap") ? "llama-swap" : "Lemonade")
         ];
       });
       return {
@@ -24981,6 +25453,159 @@ var realCacheAdapter = {
   isReparsePath
 };
 
+// src/local/lemonadeRequestGuard.ts
+var inferencePaths = new Set([
+  "/chat/completions",
+  "/completions",
+  "/embeddings",
+  "/responses"
+]);
+function modelID(payload) {
+  if (typeof payload !== "object" || payload === null || !("model" in payload) || typeof payload.model !== "string" || payload.model.length === 0 || payload.model !== payload.model.trim()) {
+    throw new ModelResidencyError("request");
+  }
+  if (payload.model.endsWith(":latest"))
+    throw new ModelResidencyError("identity");
+  return payload.model;
+}
+function createLemonadeGuardedFetch(options) {
+  const base = lemonadeBaseURL(options.baseURL);
+  const upstream = options.fetch;
+  const healthFetch = options.healthFetch ?? upstream;
+  return Object.assign(async (input, init) => {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    if (url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !request.url.startsWith(`${base}/`)) {
+      throw new ModelResidencyError("destination");
+    }
+    const path4 = request.url.slice(base.length);
+    const metadataOnly = request.method === "GET" && (path4 === "/health" || /^\/models(?:\/[^/]+)?$/.test(path4));
+    if (!metadataOnly && (request.method !== "POST" || !inferencePaths.has(path4))) {
+      throw new ModelResidencyError("request");
+    }
+    if (!metadataOnly) {
+      await withResidencyDeadline(async (signal) => {
+        signal.throwIfAborted();
+        let payload;
+        try {
+          payload = await request.clone().json();
+        } catch {
+          signal.throwIfAborted();
+          throw new ModelResidencyError("request");
+        }
+        signal.throwIfAborted();
+        const model = modelID(payload);
+        const modelIDs = typeof options.modelIDs === "function" ? await options.modelIDs() : options.modelIDs;
+        signal.throwIfAborted();
+        if (modelIDs !== undefined && !modelIDs.has(model)) {
+          throw new ModelResidencyError("identity");
+        }
+        const residency = await readLemonadeResidency(base, healthFetch, {
+          ...options,
+          signal,
+          headers: request.headers
+        });
+        signal.throwIfAborted();
+        const entry = residency.get(model);
+        if (entry?.loaded !== true) {
+          throw new ModelResidencyError(entry?.loaded === undefined && entry !== undefined ? "unknown" : "inactive");
+        }
+      }, { ...options, signal: request.signal });
+    }
+    if (request.signal.aborted)
+      throw new ModelResidencyError("cancelled");
+    const {
+      body: _body,
+      headers: _headers,
+      method: _method,
+      signal: _signal,
+      redirect: _redirect,
+      ...transportOptions
+    } = init ?? {};
+    return upstream(request, { ...transportOptions, redirect: "error" });
+  }, {
+    preconnect: (...args) => upstream.preconnect?.(...args)
+  });
+}
+
+// src/local/llamaSwapRequestGuard.ts
+var inferencePaths2 = new Set([
+  "/chat/completions",
+  "/completions",
+  "/embeddings",
+  "/responses"
+]);
+async function validatedModelID(payload, modelIDs) {
+  if (typeof payload !== "object" || payload === null || !("model" in payload) || typeof payload.model !== "string" || payload.model.length === 0 || payload.model !== payload.model.trim()) {
+    throw new ModelResidencyError("request", "llama-swap");
+  }
+  if (modelIDs === undefined) {
+    return payload.model;
+  }
+  const ids = typeof modelIDs === "function" ? await modelIDs() : modelIDs;
+  if (ids.has(payload.model)) {
+    return payload.model;
+  }
+  throw new ModelResidencyError("identity", "llama-swap");
+}
+function createLlamaSwapGuardedFetch(options) {
+  const base = llamaSwapBaseURL(options.baseURL);
+  const upstream = options.fetch;
+  const healthFetch = options.healthFetch ?? upstream;
+  return Object.assign(async (input, init) => {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    if (url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !request.url.startsWith(`${base}/`)) {
+      throw new ModelResidencyError("destination", "llama-swap");
+    }
+    const path4 = request.url.slice(base.length);
+    const metadataOnly = request.method === "GET" && /^\/models(?:\/[^/]+)?$/.test(path4);
+    if (!metadataOnly && (request.method !== "POST" || !inferencePaths2.has(path4))) {
+      throw new ModelResidencyError("request", "llama-swap");
+    }
+    if (!metadataOnly) {
+      await withResidencyDeadline(async (signal) => {
+        signal.throwIfAborted();
+        let payload;
+        try {
+          payload = await request.clone().json();
+        } catch {
+          signal.throwIfAborted();
+          throw new ModelResidencyError("request", "llama-swap");
+        }
+        signal.throwIfAborted();
+        const model = await validatedModelID(payload, options.modelIDs);
+        const residency = await readLlamaSwapResidency(base, healthFetch, {
+          ...options,
+          signal,
+          headers: request.headers
+        });
+        signal.throwIfAborted();
+        if (!residency.has(model)) {
+          throw new ModelResidencyError("identity", "llama-swap");
+        }
+        if (residency.get(model)?.loaded !== true) {
+          throw new ModelResidencyError("inactive", "llama-swap");
+        }
+      }, { ...options, signal: request.signal, runtimeLabel: "llama-swap" });
+    }
+    if (request.signal.aborted) {
+      throw new ModelResidencyError("cancelled", "llama-swap");
+    }
+    const {
+      body: _body,
+      headers: _headers,
+      method: _method,
+      signal: _signal,
+      redirect: _redirect,
+      ...transportOptions
+    } = init ?? {};
+    return upstream(request, { ...transportOptions, redirect: "error" });
+  }, {
+    preconnect: (...args) => upstream.preconnect?.(...args)
+  });
+}
+
 // src/memory/types.ts
 import { z as z28 } from "zod";
 var SHARED_OWNER_KEY = "*";
@@ -25645,6 +26270,13 @@ function createLocalEmbedder(request, deps) {
   return (texts) => embedTexts({ ...request, texts }, deps);
 }
 
+// src/messages/memoryRuntime.ts
+var memoryRuntimeMessages = {
+  providerUnavailable: "[openteam] Semantic memory requires exactly one enabled local runtime matching the configured embeddings provider. No embedding request was sent.",
+  unavailable: "[openteam] Semantic memory initialization failed; recall and memory injection are unavailable.",
+  rejectedLines: (count) => `[openteam] memory log rejected ${count} line(s); semantic memory may be incomplete.`
+};
+
 // src/memory/embedText.ts
 function normalize3(parts) {
   return parts.map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
@@ -25722,25 +26354,39 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
   if (options.requireInjectionEnabled === true && !semantic.injection.enabled) {
     return;
   }
-  const runtime = config.local.runtimes.find((rt) => rt.enabled && rt.baseURL !== undefined);
+  const warn = deps.warn ?? console.warn;
+  const configuredModel = semantic.embeddings.model;
+  const candidates = configuredModel == null ? config.local.runtimes.filter((rt) => rt.enabled && rt.baseURL !== undefined) : config.local.runtimes.filter((rt) => rt.defaultModel.providerID === configuredModel.providerID);
+  const runtime = candidates[0];
+  if (configuredModel != null && (candidates.length !== 1 || runtime?.enabled !== true)) {
+    warn(memoryRuntimeMessages.providerUnavailable);
+    return;
+  }
   if (runtime?.baseURL === undefined) {
     return;
   }
-  const modelID = semantic.embeddings.model?.modelID ?? runtime.defaultModel.modelID;
+  const modelID2 = semantic.embeddings.model?.modelID ?? runtime.defaultModel.modelID;
   const openDatabase = deps.openDatabase ?? createBunSqliteDatabase;
   const makeEmbedder = deps.createEmbedder ?? createLocalEmbedder;
   const fetchImpl = deps.fetch ?? globalThis.fetch;
   const now = deps.now ?? (() => Date.now());
-  const warn = deps.warn ?? console.warn;
+  const kind = localRuntimeKind(runtime);
   try {
+    const baseURL = kind === "llama-swap" ? llamaSwapBaseURL(runtime.baseURL) : runtime.baseURL;
+    const guardedFetch = runtimeRequiresModelResidency(kind) ? (kind === "llama-swap" ? createLlamaSwapGuardedFetch : createLemonadeGuardedFetch)({
+      baseURL,
+      fetch: fetchImpl,
+      healthFetch: fetchImpl,
+      modelIDs: new Set([modelID2])
+    }) : fetchImpl;
     const db = await openDatabase(semantic.indexPath);
     const index = createMemoryIndex(db, warn);
     const rebuildResult = await rebuildMemoryIndexFromStorage(index, semantic.logPath, { storage: deps.storage });
     if (rebuildResult.rejectedLines > 0) {
-      warn(`[openteam] memory log rejected ${rebuildResult.rejectedLines} line(s); semantic memory may be incomplete.`);
+      warn(memoryRuntimeMessages.rejectedLines(rebuildResult.rejectedLines));
     }
-    const embedder = makeEmbedder({ baseURL: runtime.baseURL, modelID }, { fetch: fetchImpl });
-    await ensureMemoryEmbeddings({ index, embedder, model: modelID, warn });
+    const embedder = makeEmbedder({ baseURL, modelID: modelID2 }, { fetch: guardedFetch });
+    await ensureMemoryEmbeddings({ index, embedder, model: modelID2, warn });
     return {
       index,
       embedder,
@@ -25749,6 +26395,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
       semantic
     };
   } catch {
+    warn(memoryRuntimeMessages.unavailable);
     return;
   }
 }