@jmanuelcorral/openteam 0.25.0 → 0.27.0

package/dist/index.js

@@ -784,6 +784,9 @@ function migrateConfig(raw) {
 
 // src/messages/consoleDetail.ts
 var consoleDetailMessages = {
+  runtimeStateCleanupFailed: "The Console runtime state could not be published and its staging file could not be removed.",
+  requestFailed: "The local opencode request failed.",
+  nativeToolFailed: "The native tool execution failed.",
   follow: "Follow new activity",
   metadataOnly: "Lifecycle and telemetry stay metadata-only.",
   logsDescription: "Current recorded conversations load automatically. Lifecycle and telemetry remain metadata-only; credentials are masked.",
@@ -1049,7 +1052,8 @@ var LocalRuntimeKindSchema = z3.enum([
   "ollama",
   "lmstudio",
   "foundry-local",
-  "lemonade"
+  "lemonade",
+  "llama-swap"
 ]);
 var LocalRuntimeSchema = z3.object({
   id: z3.string().min(1),
@@ -1069,15 +1073,25 @@ var LocalRuntimeSchema = z3.object({
     ctx.addIssue({
       code: z3.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) {
-  return runtime.maxConcurrency ?? DEFAULT_LOCAL_MAX_CONCURRENCY;
+  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 = z3.enum(["project", "user"]);
 var MemoryExtractionModeSchema = z3.enum([
@@ -5746,7 +5760,7 @@ import { z as z15 } from "zod";
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.25.0",
+  version: "0.27.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",
@@ -5806,12 +5820,13 @@ var package_default = {
   scripts: {
     prebuild: "bun run clean",
     build: "bun run build:js && bun run build:cli && bun run build:types && bun run build:certificates",
-    "build:js": "bun build ./src/index.ts --target=node --format=esm --outfile=dist/index.js --external @opencode-ai/plugin --external @opencode-ai/sdk --external zod --external @opentelemetry/api --external @opentelemetry/sdk-trace-base --external @opentelemetry/exporter-trace-otlp-http --external @opentelemetry/resources --external @langchain/langgraph",
-    "build:cli": 'bun build ./src/cli.ts --target=node --format=esm --outfile=dist/cli.js --banner "#!/usr/bin/env node" --external @opencode-ai/plugin --external @opencode-ai/sdk --external zod --external @clack/prompts --external @opentelemetry/api --external @opentelemetry/sdk-trace-base --external @opentelemetry/exporter-trace-otlp-http --external @opentelemetry/resources --external @langchain/langgraph',
+    "build:js": "bun build ./src/index.ts --target=node --format=esm --outfile=dist/index.js --external @opencode-ai/plugin --external @opencode-ai/sdk --external @opencode/schema --external effect --external zod --external @opentelemetry/api --external @opentelemetry/sdk-trace-base --external @opentelemetry/exporter-trace-otlp-http --external @opentelemetry/resources --external @langchain/langgraph",
+    "build:cli": 'bun build ./src/cli.ts --target=node --format=esm --outfile=dist/cli.js --banner "#!/usr/bin/env node" --external @opencode-ai/plugin --external @opencode-ai/sdk --external @opencode/schema --external effect --external zod --external @clack/prompts --external @opentelemetry/api --external @opentelemetry/sdk-trace-base --external @opentelemetry/exporter-trace-otlp-http --external @opentelemetry/resources --external @langchain/langgraph',
     "build:types": "tsc -p tsconfig.build.json",
     clean: `node -e "require('node:fs').rmSync('dist', { recursive: true, force: true })"`,
     test: "bun test",
     "test:cov": "bun test --coverage",
+    "verify:opencode-native": "bun scripts/verify-opencode-native.mjs",
     "certify:shadow": "bun run scripts/certify-artifact.ts shadow",
     "certify:release": "bun run scripts/certify-artifact.ts release",
     "build:certificates": "bun run certify:shadow && bun run certify:release && bun run scripts/bundle-certificates.ts",
@@ -5833,10 +5848,12 @@ var package_default = {
     "@langchain/langgraph": "1.4.12",
     "@opencode-ai/plugin": "1.18.19",
     "@opencode-ai/sdk": "1.18.19",
+    "@opencode/schema": "2.0.3",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/exporter-trace-otlp-http": "0.221.0",
     "@opentelemetry/resources": "2.10.0",
     "@opentelemetry/sdk-trace-base": "2.10.0",
+    effect: "4.0.0-rc.112",
     zod: "4.4.3"
   },
   devDependencies: {
@@ -6103,6 +6120,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.`,
@@ -6117,11 +6151,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",
@@ -6225,6 +6259,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.",
@@ -6241,7 +6277,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.",
@@ -6333,7 +6369,7 @@ var NPM_LATEST_URL = `${NPM_ORIGIN}${NPM_PACKAGE_PATH}/latest`;
 var FETCH_TIMEOUT_MS = 5000;
 var MAX_RESPONSE_BYTES = 64 * 1024;
 var MAX_FETCH_ATTEMPTS = 2;
-var PLUGIN_KEY = "plugin";
+var PLUGIN_KEYS = ["plugin", "plugins"];
 var PRIVATE_DIRECTORY_MODE = 448;
 var PRIVATE_FILE_MODE = 384;
 var UPGRADE_BACKUP_GITIGNORE_CONTENT = `*
@@ -6387,6 +6423,8 @@ function extractSpecString(entry) {
   if (isTuplePluginEntry(entry)) {
     return entry[0];
   }
+  if (isRecord3(entry) && typeof entry.package === "string")
+    return entry.package;
   return;
 }
 function isLocalFileSpec(spec) {
@@ -6599,7 +6637,7 @@ function readJsoncValueEnd(src, start, limit) {
   }
   return i > start ? i : undefined;
 }
-function findTopLevelPluginArray(raw) {
+function findTopLevelPluginArray(raw, pluginKey) {
   let found;
   let i = 0;
   let depth = 0;
@@ -6646,7 +6684,7 @@ function findTopLevelPluginArray(raw) {
       return;
     }
     i = token.end;
-    if (key !== PLUGIN_KEY || depth !== 1) {
+    if (key !== pluginKey || depth !== 1) {
       continue;
     }
     i = skipTrivia(raw, i);
@@ -6712,6 +6750,33 @@ function findEntrySpecStringSpan(raw, element, entry, expectedSpec) {
     const span2 = { start: element.start, end: token2.end };
     return readJsonStringValue(raw, span2) === expectedSpec ? span2 : undefined;
   }
+  if (isRecord3(entry) && typeof entry.package === "string") {
+    let found;
+    let i = skipTrivia(raw, element.start + 1, element.end);
+    while (i < element.end && raw[i] !== "}") {
+      const key = readStringToken(raw, i, element.end);
+      if (key === undefined)
+        return;
+      const name = readJsonStringValue(raw, { start: i, end: key.end });
+      i = skipTrivia(raw, key.end, element.end);
+      if (raw[i] !== ":")
+        return;
+      i = skipTrivia(raw, i + 1, element.end);
+      const end = readJsoncValueEnd(raw, i, element.end);
+      if (end === undefined)
+        return;
+      if (name === "package") {
+        const span2 = { start: i, end };
+        found = readJsonStringValue(raw, span2) === expectedSpec ? span2 : undefined;
+      }
+      i = skipTrivia(raw, end, element.end);
+      if (raw[i] === ",")
+        i = skipTrivia(raw, i + 1, element.end);
+      else if (raw[i] !== "}")
+        return;
+    }
+    return found;
+  }
   if (!isTuplePluginEntry(entry)) {
     return;
   }
@@ -6739,20 +6804,23 @@ function validateEffectivePluginUpdate(path, nextContent, expectedManagedEntries
   if (!parsed.ok) {
     return parsed.error;
   }
-  const pluginValue = parsed.value[PLUGIN_KEY];
-  if (!Array.isArray(pluginValue)) {
-    return upgradeMessages.effectivePluginUpdateMismatch(path);
-  }
   let managedEntries = 0;
   let updatedEntries = 0;
-  for (const entry of pluginValue) {
-    const spec = extractSpecString(entry);
-    if (spec === undefined || !isOurSpec(spec)) {
+  for (const key of PLUGIN_KEYS) {
+    const pluginValue = parsed.value[key];
+    if (pluginValue === undefined)
       continue;
-    }
-    managedEntries += 1;
-    if (spec === nextSpec) {
-      updatedEntries += 1;
+    if (!Array.isArray(pluginValue))
+      return upgradeMessages.effectivePluginUpdateMismatch(path);
+    for (const entry of pluginValue) {
+      const spec = extractSpecString(entry);
+      if (spec === undefined || !isOurSpec(spec)) {
+        continue;
+      }
+      managedEntries += 1;
+      if (spec === nextSpec) {
+        updatedEntries += 1;
+      }
     }
   }
   return managedEntries === expectedManagedEntries && updatedEntries === expectedManagedEntries ? undefined : upgradeMessages.effectivePluginUpdateMismatch(path);
@@ -7013,70 +7081,52 @@ async function analyseConfigFiles(paths, port) {
         parseError: parsed.error
       };
     }
-    const pluginValue = parsed.value[PLUGIN_KEY];
-    if (pluginValue === undefined) {
-      continue;
-    }
-    if (!Array.isArray(pluginValue)) {
-      return {
-        files,
-        foundConfigFile,
-        localOpenteamEntries,
-        parseError: upgradeMessages.pluginFieldMustBeArray(path)
-      };
-    }
-    const managedCandidates = [];
-    for (let index = 0;index < pluginValue.length; index += 1) {
-      const entry = pluginValue[index];
-      const spec = extractSpecString(entry);
-      if (spec === undefined) {
+    const fileReplacements = [];
+    for (const pluginKey of PLUGIN_KEYS) {
+      const pluginValue = parsed.value[pluginKey];
+      if (pluginValue === undefined) {
         continue;
       }
-      if (isLocalFileSpec(spec)) {
-        const localKind = await port.classifyLocalPluginSpec({
-          configPath: path,
+      if (!Array.isArray(pluginValue)) {
+        return {
+          files,
+          foundConfigFile,
+          localOpenteamEntries,
+          parseError: upgradeMessages.pluginFieldMustBeArray(path)
+        };
+      }
+      const managedCandidates = [];
+      for (let index = 0;index < pluginValue.length; index += 1) {
+        const entry = pluginValue[index];
+        const spec = extractSpecString(entry);
+        if (spec === undefined) {
+          continue;
+        }
+        if (isLocalFileSpec(spec)) {
+          const localKind = await port.classifyLocalPluginSpec({
+            configPath: path,
+            spec
+          });
+          if (localKind === "ours") {
+            localOpenteamEntries.push({ path, spec });
+          }
+          continue;
+        }
+        if (!isOurSpec(spec)) {
+          continue;
+        }
+        managedCandidates.push({
+          currentVersion: currentPinnedVersion(spec),
+          entry,
+          index,
           spec
         });
-        if (localKind === "ours") {
-          localOpenteamEntries.push({ path, spec });
-        }
-        continue;
       }
-      if (!isOurSpec(spec)) {
+      if (managedCandidates.length === 0) {
         continue;
       }
-      managedCandidates.push({
-        currentVersion: currentPinnedVersion(spec),
-        entry,
-        index,
-        spec
-      });
-    }
-    if (managedCandidates.length === 0) {
-      continue;
-    }
-    const pluginArray = findTopLevelPluginArray(content);
-    if (pluginArray === undefined) {
-      return {
-        files,
-        foundConfigFile,
-        localOpenteamEntries,
-        parseError: upgradeMessages.pluginArrayEditUnavailable(path)
-      };
-    }
-    const elementSpans = scanTopLevelArrayElements(content, pluginArray.start, pluginArray.end);
-    if (elementSpans === undefined || elementSpans.length !== pluginValue.length) {
-      return {
-        files,
-        foundConfigFile,
-        localOpenteamEntries,
-        parseError: upgradeMessages.pluginArrayEditUnavailable(path)
-      };
-    }
-    const replacements = [];
-    for (const candidate of managedCandidates) {
-      const elementSpan = elementSpans[candidate.index];
-      if (elementSpan === undefined) {
+      const pluginArray = findTopLevelPluginArray(content, pluginKey);
+      if (pluginArray === undefined) {
         return {
           files,
           foundConfigFile,
@@ -7084,8 +7134,8 @@ async function analyseConfigFiles(paths, port) {
           parseError: upgradeMessages.pluginArrayEditUnavailable(path)
         };
       }
-      const specSpan = findEntrySpecStringSpan(content, elementSpan, candidate.entry, candidate.spec);
-      if (specSpan === undefined) {
+      const elementSpans = scanTopLevelArrayElements(content, pluginArray.start, pluginArray.end);
+      if (elementSpans === undefined || elementSpans.length !== pluginValue.length) {
         return {
           files,
           foundConfigFile,
@@ -7093,16 +7143,40 @@ async function analyseConfigFiles(paths, port) {
           parseError: upgradeMessages.pluginArrayEditUnavailable(path)
         };
       }
-      replacements.push({
-        ...specSpan,
-        currentVersion: candidate.currentVersion
-      });
+      const replacements = [];
+      for (const candidate of managedCandidates) {
+        const elementSpan = elementSpans[candidate.index];
+        if (elementSpan === undefined) {
+          return {
+            files,
+            foundConfigFile,
+            localOpenteamEntries,
+            parseError: upgradeMessages.pluginArrayEditUnavailable(path)
+          };
+        }
+        const specSpan = findEntrySpecStringSpan(content, elementSpan, candidate.entry, candidate.spec);
+        if (specSpan === undefined) {
+          return {
+            files,
+            foundConfigFile,
+            localOpenteamEntries,
+            parseError: upgradeMessages.pluginArrayEditUnavailable(path)
+          };
+        }
+        replacements.push({
+          ...specSpan,
+          currentVersion: candidate.currentVersion
+        });
+      }
+      fileReplacements.push(...replacements);
     }
+    if (fileReplacements.length === 0)
+      continue;
     files.push({
-      currentVersions: replacements.map((replacement) => replacement.currentVersion),
+      currentVersions: fileReplacements.map((replacement) => replacement.currentVersion),
       path,
       originalContent: content,
-      replacements
+      replacements: fileReplacements
     });
   }
   return {
@@ -7830,15 +7904,14 @@ function mergeOpencodeConfigs(base, override) {
   return result;
 }
 
-// src/graph/certificate.ts
-import { z as z17 } from "zod";
-
 // src/contract/opencode.ts
 var SUPPORTED_OPENCODE_VERSIONS = [
   "1.17.13",
   "1.18.18",
   "1.18.19"
 ];
+var NATIVE_OPENCODE_VERSION = "2.0.5";
+var NATIVE_CERTIFICATE_DIRECTORY = `opencode-${NATIVE_OPENCODE_VERSION}`;
 var SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)/;
 function parseSemver(version) {
   const normalized = version.trim().replace(/^[=^~v]+/, "");
@@ -7864,12 +7937,15 @@ function isCertificateVersionCompatible(certifiedVersion, liveVersion) {
   } catch {
     return false;
   }
-  if (certified.major !== live.major || certified.minor !== live.minor) {
+  if (certified.major !== 1 || certified.major !== live.major || certified.minor !== live.minor) {
     return false;
   }
   return live.patch >= certified.patch;
 }
 
+// src/graph/certificate.ts
+import { z as z17 } from "zod";
+
 // src/graph/soakLedger.ts
 import { z as z16 } from "zod";
 var Sha256Schema2 = z16.string().regex(/^[0-9a-f]{64}$/);
@@ -9953,14 +10029,12 @@ function ensureFoundryV1BaseURL(endpoint) {
   }
 }
 
-// src/local/lemonadeResidency.ts
-import { z as z19 } 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",
+  "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",
@@ -9969,22 +10043,328 @@ 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: (path2) => `GET ${path2} must return an object with a data array`,
+  duplicateCanonicalModelId: (modelID, path2) => `duplicate canonical model id "${modelID}" in ${path2}`,
+  httpFailure: (path2, status) => `GET ${path2} failed with HTTP ${status}`,
+  unverifiableResponse: (path2) => `GET ${path2} failed before a verifiable response`,
+  expectedProfilesArray: (path2) => `GET ${path2} must return an object with a profiles array`,
+  activeProfileRewrite: (profile) => `active profile "${profile}" can rewrite canonical model routing`,
+  invalidActiveProfileValue: (path2) => `GET ${path2} reported an invalid active profile value`,
+  expectedRunningArray: (path2) => `GET ${path2} must return an object with a running array`,
+  malformedRunningEvidence: (path2) => `GET ${path2} returned malformed model/state evidence`,
+  duplicateRunningEvidence: (path2, modelID) => `GET ${path2} 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, ms) => {
+    const timer = setTimeout(callback, ms);
+    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/llamaSwapResidency.ts
+function isObject2(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 (!isObject2(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 (!isObject2(entry.meta) || !isObject2(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),
+    isObject2(entry.meta) ? readPositiveSafeInteger(entry.meta.n_ctx) : undefined
+  ];
+  return values.filter((value) => value !== undefined);
+}
+function readDeclaredMaxOutput(entry, id) {
+  if (!isObject2(entry.meta) || !isObject2(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 (!isObject2(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 (!isObject2(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 metadata(url, fetch, signal, headers) {
+  signal.throwIfAborted();
+  try {
+    const response = await fetch(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 (!isObject2(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 (!isObject2(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 (!isObject2(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, fetch, options = {}) {
+  const base = llamaSwapBaseURL(baseURL);
+  const headers = requestHeaders(options.headers);
+  return withResidencyDeadline(async (signal) => parseCatalog(await metadata(`${base}/models`, fetch, signal, headers)), llamaSwapResidencyOptions(options));
+}
+async function readLlamaSwapResidency(baseURL, fetch, 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, fetch, {
+      ...llamaSwapResidencyOptions(options),
+      signal
+    });
+    readProfiles(await metadata(`${origin}/api/profiles`, fetch, signal, headers));
+    return readRunning(await metadata(`${origin}/running`, fetch, signal, headers), new Set(models.map((model) => model.modelID)));
+  }, llamaSwapResidencyOptions(options));
+}
+
+// src/local/lemonadeResidency.ts
+import { z as z19 } from "zod";
 var modelName = z19.string().min(1).refine((name) => name === name.trim());
 var LoadedModelSchema = z19.object({
   model_name: modelName,
@@ -10121,37 +10501,7 @@ 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, ms) => {
-    const timer = setTimeout(callback, ms);
-    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, fetch, signal, headers) {
+async function metadata2(url, fetch, signal, headers) {
   signal.throwIfAborted();
   let payload;
   try {
@@ -10184,8 +10534,8 @@ async function readLemonadeResidency(baseURL, fetch, options = {}) {
   headers.delete("if-none-match");
   headers.delete("if-modified-since");
   return withResidencyDeadline(async (signal) => {
-    const aliases = await metadata(`${new URL(base).origin}/internal/aliases`, fetch, signal, headers);
-    const health = await metadata(`${base}/health`, fetch, signal, headers);
+    const aliases = await metadata2(`${new URL(base).origin}/internal/aliases`, fetch, signal, headers);
+    const health = await metadata2(`${base}/health`, fetch, signal, headers);
     return parseResidency(health, aliases);
   }, options);
 }
@@ -10256,11 +10606,11 @@ async function listLemonadeModels(baseURL, fetch) {
 }
 function readNonTextModelIDs(payload) {
   const ids = new Set;
-  if (!isObject2(payload) || !Array.isArray(payload.data)) {
+  if (!isObject3(payload) || !Array.isArray(payload.data)) {
     return ids;
   }
   for (const entry of payload.data) {
-    if (!isObject2(entry) || typeof entry.id !== "string") {
+    if (!isObject3(entry) || typeof entry.id !== "string") {
       continue;
     }
     if (isNonTextModel(entry)) {
@@ -10298,7 +10648,7 @@ function readLoadedContextWindow(entry) {
 }
 function slotsFromLlamacppArgs(entry) {
   const options = entry.recipe_options;
-  if (!isObject2(options) || typeof options.llamacpp_args !== "string") {
+  if (!isObject3(options) || typeof options.llamacpp_args !== "string") {
     return;
   }
   const match = PARALLEL_ARG.exec(options.llamacpp_args);
@@ -10334,7 +10684,7 @@ function slotsFromLaunchCommand(entry) {
 }
 function contextWindowFromRecipeOptions(entry) {
   const options = entry.recipe_options;
-  if (!isObject2(options) || !hasLlamacppEvidence(entry)) {
+  if (!isObject3(options) || !hasLlamacppEvidence(entry)) {
     return;
   }
   const direct = positiveIntegerValue(options.ctx_size);
@@ -10394,7 +10744,7 @@ function hasLlamacppEvidence(entry) {
     return true;
   }
   const options = entry.recipe_options;
-  if (isObject2(options) && typeof options.llamacpp_args === "string") {
+  if (isObject3(options) && typeof options.llamacpp_args === "string") {
     return true;
   }
   return Array.isArray(entry.launch_command) && launchCommandLooksLikeLlamacpp(entry.launch_command);
@@ -10450,10 +10800,57 @@ function enrichWithLoadState(models, loaded) {
     };
   });
 }
-function isObject2(value) {
+function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// 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/lmstudio.ts
 var LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1";
 function createLMStudioAdapter() {
@@ -10506,6 +10903,7 @@ class RuntimeRegistry {
       lmstudio: createLMStudioAdapter(),
       "foundry-local": createFoundryLocalAdapter(),
       lemonade: createLemonadeAdapter(),
+      "llama-swap": createLlamaSwapAdapter(),
       ...options.adapters
     };
     this.clock = options.clock;
@@ -10635,6 +11033,28 @@ function withReportedModelSlots(runtime, reported, aliases) {
   };
 }
 
+// src/messages/nativeHost.ts
+var nativeHostMessages = {
+  invalidNativeConfig: "The existing native opencode plugins/providers configuration cannot be safely merged. Correct its object and plugin declaration shapes before running setup.",
+  setupPolicyQuestion: (paths, providers) => `Remove exact project-local provider.use deny rules for ${providers.join(", ")} from ${paths.join(", ")}? Older setup added these rules, but they may also be operator limits. Confirm only if you intend to enable the guarded native transport.`,
+  setupPolicyPreserved: "Setup stopped. Provider-denial rules were preserved and no files were written.",
+  setupPolicyNotice: "Only the explicitly reviewed project rules were removed. Wildcard, scoped, unrelated and global provider denials remain authoritative.",
+  unsupportedVersion: (version) => `openteam has not verified the native plugin contract for opencode ${version}. The supported native host is 2.0.5.`,
+  missingBindings: "The native opencode execution context is unavailable. No child session or privileged operation was started.",
+  missingVersion: "The opencode host did not provide an authoritative version or server endpoint.",
+  workspaceMismatch: "The native opencode session does not belong to this workspace.",
+  noCompletedResponse: "The native opencode session stopped without a completed assistant response.",
+  executionFailed: "The native opencode session failed.",
+  executionInterrupted: "The native opencode session was interrupted.",
+  unknownAgent: "The native opencode session has no available agent.",
+  noAvailableModel: "The native opencode host has no model available in the configured execution domain.",
+  executionDomainBlocked: "The native opencode request is outside the configured execution domain.",
+  transportUnavailable: "This local runtime requires the guarded @ai-sdk/openai-compatible transport. Native and WebSocket transports are not admitted.",
+  missingAdmission: "The native local request has no matching model authorization. No inference was sent.",
+  toolFailed: "The openteam tool failed in the native opencode host.",
+  eventCaptureFailed: "Native opencode event capture failed. The console may be missing activity; reload the plugin after resolving the host error."
+};
+
 // src/messages/orchestration.ts
 var HOST_SESSION_REQUIRED = "Orchestration requires a nonempty host ToolContext sessionID.";
 var PARENT_OVERRIDE_IGNORED = "parentSessionID override ignored: the trusted host ToolContext session owns this orchestration and its children. Programmatic callers must supply their parent as the ToolContext sessionID.";
@@ -10972,7 +11392,7 @@ var TRUNCATED_REASON_SUFFIX = "…[truncated]";
 var MAX_SERIALIZED_ARRAY_ITEMS = 20;
 var MAX_SERIALIZED_OBJECT_PROPERTIES = 25;
 var MAX_SERIALIZED_DEPTH = 4;
-function isObject3(value) {
+function isObject4(value) {
   return typeof value === "object" && value !== null;
 }
 function isError(value) {
@@ -11002,7 +11422,7 @@ function stringProperty(value, key) {
 }
 function nestedMessage(value, key) {
   const container = safeGet(value, key);
-  if (!isObject3(container)) {
+  if (!isObject4(container)) {
     return;
   }
   const message = stringProperty(container, "message");
@@ -11086,7 +11506,7 @@ function errorReason(error) {
       return message;
     }
   }
-  if (isObject3(error)) {
+  if (isObject4(error)) {
     const message = stringProperty(error, "message");
     if (message !== undefined) {
       return message;
@@ -11104,7 +11524,7 @@ function errorReason(error) {
   return safeToString(error);
 }
 function isNormalizedSessionFailure(value) {
-  return isObject3(value) && safeGet(value, "kind") === "normalized-session-failure" && typeof safeGet(value, "failureClass") === "string" && typeof safeGet(value, "retryable") === "boolean";
+  return isObject4(value) && safeGet(value, "kind") === "normalized-session-failure" && typeof safeGet(value, "failureClass") === "string" && typeof safeGet(value, "retryable") === "boolean";
 }
 function createArgs(req) {
   const body = {};
@@ -11231,7 +11651,7 @@ async function confirmSessionStopped(client, sessionID, directory, deps, deadlin
       return { confirmed: false, cause: "status-error" };
     }
     const statuses = statusOutcome.value;
-    if (!isObject3(statuses)) {
+    if (!isObject4(statuses)) {
       return { confirmed: false, cause: "status-error" };
     }
     if (safeGet(statuses, "error") !== undefined) {
@@ -11381,8 +11801,11 @@ async function runSubsession(client, req, deps) {
 }
 
 // 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/plugin/availability.ts
@@ -11391,9 +11814,9 @@ function modelKey2(model) {
 }
 function availabilityMetadata({
   apiModelID: _apiModelID,
-  ...metadata2
+  ...metadata3
 }) {
-  return metadata2;
+  return metadata3;
 }
 function compareAvailableModels(left, right) {
   const kindOrder = Number(left.kind === "frontier") - Number(right.kind === "frontier");
@@ -11413,7 +11836,7 @@ function isConfiguredLocalModel(config, model) {
   return config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === model.providerID);
 }
 function requiresModelResidency(config, model) {
-  return config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === model.providerID && !hasRequiredModelResidency(localRuntimeKind(runtime), undefined));
+  return config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === model.providerID && runtimeRequiresModelResidency(localRuntimeKind(runtime)));
 }
 function configuredFrontierProviderIDs(config) {
   const providerIDs = new Set([config.baseline.hardDefault.providerID]);
@@ -11612,6 +12035,10 @@ function createAvailabilityCache(options) {
       ref: { ...profile.ref },
       costPer1M: { ...profile.costPer1M }
     })),
+    waitForRefresh: async () => {
+      while (inFlight !== undefined)
+        await inFlight;
+    },
     refresh: () => {
       if (inFlight === undefined) {
         cached = cached.map((model) => requiresModelResidency(options.config, model) ? { ...model, available: false } : model);
@@ -12039,6 +12466,7 @@ var PROVIDER_LABELS = {
   ollama: "Ollama",
   lmstudio: "LM Studio",
   lemonade: "Lemonade Server",
+  "llama-swap": executionSetupMessages.llamaSwap.label,
   "foundry-local": "Foundry Local"
 };
 function providerLabel(providerID) {
@@ -12260,7 +12688,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",
@@ -12606,7 +13035,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) {
@@ -12618,6 +13047,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 [
@@ -13021,7 +13452,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)`);
@@ -13442,6 +13873,16 @@ function renderMigration(report) {
 // src/commands/purge.ts
 import * as path3 from "node:path";
 
+// src/config/fieldProjection.ts
+function only(keys) {
+  return (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      return value;
+    const record = value;
+    return Object.fromEntries(keys.filter((key) => Object.hasOwn(record, key)).map((key) => [key, record[key]]));
+  };
+}
+
 // src/storage/graph/soakRecorder.ts
 var SOAK_EVIDENCE_DIR = ".opencode/soak";
 var SOAK_RECORDER_BASE_DIR = ".opencode";
@@ -13633,6 +14074,38 @@ function missingGeneratedStateRules(gitignore) {
   const present = new Set(activeGitignoreRules(gitignore));
   return OPENCODE_GITIGNORE_GENERATED_STATE_RULES.filter((rule) => !present.has(rule));
 }
+var KNOWN_RUNTIMES = [
+  {
+    id: "ollama",
+    label: "Ollama",
+    defaultBaseURL: "http://localhost:11434/v1",
+    fallbackModelID: "qwen3:8b"
+  },
+  {
+    id: "lmstudio",
+    label: "LM Studio",
+    defaultBaseURL: "http://localhost:1234/v1",
+    fallbackModelID: "qwen2.5-coder"
+  },
+  {
+    id: "lemonade",
+    label: "Lemonade Server",
+    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",
+    fallbackModelID: "Phi-4-mini-instruct",
+    dynamicPort: true
+  }
+];
 
 // src/commands/purge.ts
 var PURGE_CATEGORY_IDS = [
@@ -14661,7 +15134,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]))
       } : {}
     });
@@ -14991,9 +15464,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))
@@ -15004,7 +15477,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 {
@@ -15204,7 +15677,7 @@ function createCommandTool(deps) {
 // src/plugin/consoleTool.ts
 import { spawn as nodeSpawn } from "node:child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-import { mkdir as mkdir4, open as open3 } from "node:fs/promises";
+import { mkdir as mkdir4, open as open3, stat as stat3 } from "node:fs/promises";
 import { dirname as dirname6, join as join13, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { tool as tool2 } from "@opencode-ai/plugin";
@@ -15214,8 +15687,8 @@ import {
   mkdir as mkdir3,
   open as open2,
   readFile as readFile4,
-  unlink,
-  writeFile as writeFile2
+  rename as rename2,
+  unlink
 } from "node:fs/promises";
 import { dirname as dirname5, join as join12, resolve as resolve7 } from "node:path";
 import { z as z22 } from "zod";
@@ -15515,10 +15988,17 @@ async function acquireLaunchLockOrWait(workspaceRoot, paths, launchId, deps) {
     currentLock = await readConsoleLaunchLock(paths.launchLockPath);
   } catch (error) {
     if (error instanceof ConsoleRuntimeStateFileError) {
-      await removeConsoleLaunchLock(paths.launchLockPath);
-      const retry = await acquireConsoleLaunchLock(paths.launchLockPath, attemptLock);
-      if (retry !== "busy") {
-        return { kind: "acquired", release: retry.release };
+      const info = await stat3(paths.launchLockPath).catch((error2) => {
+        if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
+          return;
+        throw error2;
+      });
+      if (info === undefined || deps.now() - info.mtimeMs > LAUNCH_LOCK_STALE_MS) {
+        await removeConsoleLaunchLock(paths.launchLockPath);
+        const retry = await acquireConsoleLaunchLock(paths.launchLockPath, attemptLock);
+        if (retry !== "busy") {
+          return { kind: "acquired", release: retry.release };
+        }
       }
     } else {
       throw error;
@@ -15591,7 +16071,8 @@ async function spawnDetachedConsole(workspaceRoot, paths, launchId, deps) {
     ], {
       cwd: workspaceRoot,
       detached: true,
-      stdio: ["ignore", logHandle.fd, logHandle.fd]
+      stdio: ["ignore", logHandle.fd, logHandle.fd],
+      ...deps.environment === undefined ? {} : { env: deps.environment() }
     });
     child.unref?.();
     return child;
@@ -15626,7 +16107,8 @@ function createConsoleTool(deps = {}) {
         sendSignal,
         sleep,
         resolveCliEntrypoint,
-        spawn
+        spawn,
+        ...deps.environment === undefined ? {} : { environment: deps.environment }
       };
       if (args.action === "status") {
         return summaryFromProbe(await readRuntimeProbe(workspaceRoot, {
@@ -15744,10 +16226,7 @@ function createConsoleTool(deps = {}) {
           });
         }
         await removeConsoleRuntimeState(paths.runtimeStatePath);
-        const child = await spawnDetachedConsole(workspaceRoot, paths, launchId, {
-          resolveCliEntrypoint: runtimeDeps.resolveCliEntrypoint,
-          spawn: runtimeDeps.spawn
-        });
+        const child = await spawnDetachedConsole(workspaceRoot, paths, launchId, runtimeDeps);
         const probe = await waitForHealthyRuntime(workspaceRoot, START_TIMEOUT_MS, {
           fetch: runtimeDeps.fetch,
           processExists: runtimeDeps.processExists,
@@ -17234,6 +17713,84 @@ function createLemonadeGuardedFetch(options) {
   });
 }
 
+// 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/plugin/modelResidency.ts
 function isFetch(value) {
   return typeof value === "function";
@@ -17273,20 +17830,29 @@ function providerRoutes(provider) {
     npm: model?.provider?.npm ?? provider.npm
   }));
 }
-function wireID(key, model) {
+function wireID(key, model, runtimeLabel = "Lemonade") {
   const id = model?.id ?? key;
   if (id.length === 0 || id !== id.trim())
-    throw new ModelResidencyError("identity");
+    throw new ModelResidencyError("identity", runtimeLabel);
   return id;
 }
 function nativeEligibleID(id) {
   return id === "openai" || id === "anthropic" || id.startsWith("opencode");
 }
+function normalizedBase(kind, baseURL) {
+  return kind === "llama-swap" ? llamaSwapBaseURL(baseURL) : lemonadeBaseURL(baseURL);
+}
+function runtimeBase(runtime) {
+  return runtime.baseURL ?? (localRuntimeKind(runtime) === "llama-swap" ? LLAMA_SWAP_DEFAULT_BASE_URL : LEMONADE_DEFAULT_BASE_URL);
+}
+function residencyRuntimeLabel(config, providerID) {
+  return config.local.runtimes.some((runtime) => runtime.defaultModel.providerID === providerID && localRuntimeKind(runtime) === "llama-swap") ? "llama-swap" : "Lemonade";
+}
 function configuredRuntime(config, providerID) {
   const runtimes = config.local.runtimes.filter((runtime2) => runtime2.defaultModel.providerID === providerID);
   const runtime = runtimes[0];
   if (runtimes.length !== 1 || runtime === undefined || !runtime.enabled) {
-    throw new ModelResidencyError("destination");
+    throw new ModelResidencyError("destination", residencyRuntimeLabel(config, providerID));
   }
   return runtime;
 }
@@ -17295,8 +17861,9 @@ function createModelResidencyGuard(config, options) {
   const blocked = new Set;
   let hostConfig;
   const readEnv = options.readEnv ?? ((name) => process.env[name]);
-  const lemonadeRuntimes = () => config.local.runtimes.filter((runtime) => localRuntimeKind(runtime) === "lemonade");
-  const protects = (providerID, baseURL) => lemonadeRuntimes().some((runtime) => {
+  const failure = (code, providerID) => new ModelResidencyError(code, residencyRuntimeLabel(config, providerID));
+  const residentRuntimes = () => config.local.runtimes.filter((runtime) => runtimeRequiresModelResidency(localRuntimeKind(runtime)));
+  const protects = (providerID, baseURL) => residentRuntimes().some((runtime) => {
     if (runtime.defaultModel.providerID === providerID)
       return true;
     if (baseURL === undefined)
@@ -17304,13 +17871,13 @@ function createModelResidencyGuard(config, options) {
     const binding = endpointBinding(baseURL, readEnv);
     if (binding.ambiguous)
       return true;
-    return binding.origin !== undefined && binding.origin === origin(runtime.baseURL ?? LEMONADE_DEFAULT_BASE_URL);
+    return binding.origin !== undefined && binding.origin === origin(runtimeBase(runtime));
   });
   const resolvedWireID = (model, declaredID) => {
     const id = options.resolveApiModelID === undefined ? declaredID : options.resolveApiModelID(model);
     if (id === undefined)
-      throw new ModelResidencyError("identity");
-    return wireID(id, undefined);
+      throw failure("identity", model.providerID);
+    return wireID(id, undefined, residencyRuntimeLabel(config, model.providerID));
   };
   const configHook = async (host) => {
     hostConfig = host;
@@ -17330,21 +17897,22 @@ function createModelResidencyGuard(config, options) {
         ...new Set([...host.disabled_providers ?? [], providerID])
       ];
       const reject = Object.assign(async () => {
-        throw new ModelResidencyError("transport");
+        throw failure("transport", providerID);
       }, { preconnect: () => {} });
       provider.options = { ...provider.options, fetch: reject };
       try {
         const runtime = configuredRuntime(config, providerID);
-        const baseURL = lemonadeBaseURL(runtime.baseURL ?? LEMONADE_DEFAULT_BASE_URL);
-        if (localRuntimeKind(runtime) !== "lemonade" || routes.some((route) => route.baseURL === undefined || lemonadeBaseURL(route.baseURL) !== baseURL))
-          throw new ModelResidencyError("destination");
+        const kind = localRuntimeKind(runtime);
+        const baseURL = normalizedBase(kind, runtimeBase(runtime));
+        if (!runtimeRequiresModelResidency(kind) || routes.some((route) => route.baseURL === undefined || normalizedBase(kind, route.baseURL) !== baseURL))
+          throw failure("destination", providerID);
         if (routes.some((route) => route.npm !== "@ai-sdk/openai-compatible") || nativeEligibleID(providerID) || !isFetch(originalFetch))
-          throw new ModelResidencyError("transport");
+          throw failure("transport", providerID);
         const modelKeys = new Map;
         for (const [key, model] of Object.entries(provider.models ?? {})) {
-          if (model.options?.fetch !== undefined || model.options?.baseURL !== undefined && (typeof model.options.baseURL !== "string" || lemonadeBaseURL(model.options.baseURL) !== baseURL))
-            throw new ModelResidencyError("transport");
-          modelKeys.set(key, wireID(key, model));
+          if (model.options?.fetch !== undefined || model.options?.baseURL !== undefined && (typeof model.options.baseURL !== "string" || normalizedBase(kind, model.options.baseURL) !== baseURL))
+            throw failure("transport", providerID);
+          modelKeys.set(key, wireID(key, model, residencyRuntimeLabel(config, providerID)));
         }
         if (!modelKeys.has(runtime.defaultModel.modelID))
           modelKeys.set(runtime.defaultModel.modelID, undefined);
@@ -17353,11 +17921,12 @@ function createModelResidencyGuard(config, options) {
           for (const [modelID2, declaredID] of modelKeys) {
             const id = options.resolveApiModelID === undefined ? declaredID : options.resolveApiModelID({ providerID, modelID: modelID2 });
             if (id !== undefined)
-              ids.add(wireID(id, undefined));
+              ids.add(wireID(id, undefined, residencyRuntimeLabel(config, providerID)));
           }
           return ids;
         };
-        const fetch = createLemonadeGuardedFetch({
+        const guardFetch = kind === "llama-swap" ? createLlamaSwapGuardedFetch : createLemonadeGuardedFetch;
+        const fetch = guardFetch({
           ...options,
           baseURL,
           modelIDs: async () => {
@@ -17368,7 +17937,10 @@ function createModelResidencyGuard(config, options) {
           healthFetch: options.fetch
         });
         provider.options.fetch = fetch;
+        if (kind === "llama-swap")
+          provider.options.baseURL = baseURL;
         guarded.set(providerID, {
+          kind,
           baseURL,
           fetch,
           originalFetch,
@@ -17382,7 +17954,7 @@ function createModelResidencyGuard(config, options) {
       } catch (error) {
         if (!(error instanceof ModelResidencyError))
           throw error;
-        (options.warn ?? console.warn)(modelResidencyMessages.providerDisabled(providerID));
+        (options.warn ?? console.warn)(modelResidencyMessages.providerDisabled(providerID, residencyRuntimeLabel(config, providerID)));
       }
     }
   };
@@ -17392,48 +17964,52 @@ function createModelResidencyGuard(config, options) {
       return;
     const provider = guarded.get(input.model.providerID);
     if (provider === undefined || blocked.has(input.model.providerID) || input.provider.options.fetch !== provider.fetch || input.model.api.npm !== "@ai-sdk/openai-compatible" || nativeEligibleID(input.model.providerID))
-      throw new ModelResidencyError("transport");
-    if (lemonadeBaseURL(base) !== provider.baseURL) {
-      throw new ModelResidencyError("destination");
+      throw failure("transport", input.model.providerID);
+    if (normalizedBase(provider.kind, base) !== provider.baseURL) {
+      throw failure("destination", input.model.providerID);
     }
+    if (input.model.options.fetch !== undefined || input.model.options.baseURL !== undefined && (typeof input.model.options.baseURL !== "string" || normalizedBase(provider.kind, input.model.options.baseURL) !== provider.baseURL))
+      throw failure("transport", input.model.providerID);
     const id = resolvedWireID({ providerID: input.model.providerID, modelID: input.model.id }, provider.modelKeys.get(input.model.id));
     if (id !== input.model.api.id)
-      throw new ModelResidencyError("identity");
+      throw failure("identity", input.model.providerID);
     if (!provider.modelKeys.has(input.model.id))
       provider.modelKeys.set(input.model.id, undefined);
   };
   const localTarget = (model) => {
     const runtime = configuredRuntime(config, model.providerID);
+    const kind = localRuntimeKind(runtime);
+    const needsResidency = runtimeRequiresModelResidency(kind);
     if (hostConfig?.disabled_providers?.includes(model.providerID)) {
-      throw new ModelResidencyError("transport");
+      throw failure("transport", model.providerID);
     }
     if (runtime.baseURL === undefined)
-      throw new ModelResidencyError("destination");
+      throw failure("destination", model.providerID);
     const provider = hostConfig?.provider?.[model.providerID];
     const entry = Object.hasOwn(provider?.models ?? {}, model.modelID) ? provider?.models?.[model.modelID] : undefined;
     const configuredURL = provider === undefined ? undefined : providerBase(provider, entry);
-    if (configuredURL !== undefined && new URL(configuredURL).href.replace(/\/$/, "") !== new URL(runtime.baseURL).href.replace(/\/$/, "")) {
-      throw new ModelResidencyError("destination");
+    if (configuredURL !== undefined && (needsResidency ? normalizedBase(kind, configuredURL) !== normalizedBase(kind, runtime.baseURL) : new URL(configuredURL).href.replace(/\/$/, "") !== new URL(runtime.baseURL).href.replace(/\/$/, ""))) {
+      throw failure("destination", model.providerID);
     }
-    const modelID2 = resolvedWireID(model, entry === undefined && localRuntimeKind(runtime) === "lemonade" ? undefined : wireID(model.modelID, entry));
+    const modelID2 = resolvedWireID(model, entry === undefined && needsResidency ? undefined : wireID(model.modelID, entry, residencyRuntimeLabel(config, model.providerID)));
     let fetch = options.fetch;
-    if (localRuntimeKind(runtime) === "lemonade") {
+    if (needsResidency) {
       const installed = guarded.get(model.providerID);
       if (installed === undefined || blocked.has(model.providerID)) {
-        throw new ModelResidencyError("transport");
+        throw failure("transport", model.providerID);
       }
-      if (installed.baseURL !== lemonadeBaseURL(runtime.baseURL)) {
-        throw new ModelResidencyError("destination");
+      if (installed.baseURL !== normalizedBase(kind, runtime.baseURL)) {
+        throw failure("destination", model.providerID);
       }
       if (!installed.modelKeys.has(model.modelID))
         installed.modelKeys.set(model.modelID, undefined);
       if (!installed.modelIDs().has(modelID2))
-        throw new ModelResidencyError("identity");
+        throw failure("identity", model.providerID);
       fetch = installed.fetch;
     }
     const configuredHeaders = z25.record(z25.string(), z25.string()).safeParse(provider?.options?.headers ?? {});
     if (!configuredHeaders.success)
-      throw new ModelResidencyError("configuration");
+      throw failure("configuration", model.providerID);
     const headers = new Headers(configuredHeaders.data);
     if (typeof provider?.options?.apiKey === "string" && !headers.has("authorization")) {
       headers.set("authorization", `Bearer ${provider.options.apiKey}`);
@@ -17442,7 +18018,7 @@ function createModelResidencyGuard(config, options) {
       headers.set(name, value);
     const upstream = fetch;
     return {
-      baseURL: runtime.baseURL,
+      baseURL: needsResidency ? normalizedBase(kind, runtime.baseURL) : runtime.baseURL,
       modelID: modelID2,
       fetch: [...headers].length === 0 ? fetch : Object.assign(async (input, init) => {
         const request = new Request(input, init);
@@ -17549,8 +18125,8 @@ function createChatMessageHook(config, getAvailable, options = {}) {
       await injectMemoryBestEffort(options.injectMemory, prompt, output);
       return;
     }
-    await options.beforeRoute?.();
     const role = await roleForAgentName(config, input.agent ?? output.message.agent, options.resolveAgentRole);
+    await options.beforeRoute?.();
     const derivedSignals = deriveTaskSignals(input, output);
     const signals = role === undefined ? derivedSignals : withoutExplicitOverride(derivedSignals);
     const executionPolicy = role === undefined ? config.orchestrator?.primary : agentExecutionPolicyForRole(role);
@@ -17604,8 +18180,8 @@ function createChatMessageHook(config, getAvailable, options = {}) {
 function createHooks(config, getAvailable, options = {}) {
   const residency = options.modelResidency ?? createModelResidencyGuard(config, { fetch: globalThis.fetch });
   return {
-    config: residency.config,
-    "chat.params": residency.beforeInference,
+    ...residency.config === undefined ? {} : { config: residency.config },
+    ...residency.beforeInference === undefined ? {} : { "chat.params": residency.beforeInference },
     "chat.message": createChatMessageHook(config, getAvailable, options)
   };
 }
@@ -18565,7 +19141,7 @@ var memoryToolMessages = {
   scribeOnly: (actualRoleID) => `openteam memory: refused — memory records may only be written by the "scribe" role, not "${actualRoleID}".`,
   disabled: "openteam memory: semantic memory is disabled; nothing was recorded.",
   frontierDomainRefusal: 'openteam memory: refused — memory extraction requires local model execution, but router.executionMode is "frontier". Set router.executionMode to "local" or "mixed" and configure a reachable local runtime.',
-  localRuntimeUnavailable: "openteam memory: memory extraction requires a local runtime that is reachable and will not fall back to a frontier provider. Configure Ollama, LM Studio, Lemonade, or Foundry Local and run `openteam doctor`.",
+  localRuntimeUnavailable: "openteam memory: memory extraction requires a local runtime that is reachable and will not fall back to a frontier provider. Configure Ollama, LM Studio, Lemonade, llama-swap, or Foundry Local and run `openteam doctor`.",
   localRuntimeBaseURLMissing: "openteam memory: refused — no local runtime with a base URL is configured and enabled; memory extraction is local-only.",
   extractionFailure: (reason) => `openteam memory: extraction failed; nothing was recorded (${reason}).`,
   noRecords: "openteam memory: no records were extracted; nothing was recorded.",
@@ -18635,14 +19211,16 @@ function createMemoryTool(deps) {
         if (runtime?.baseURL === undefined || runtime.baseURL.length === 0) {
           return memoryToolMessages.localRuntimeBaseURLMissing;
         }
-        const baseURL = runtime.baseURL;
+        const kind = localRuntimeKind(runtime);
+        const baseURL = kind === "llama-swap" ? llamaSwapBaseURL(runtime.baseURL) : runtime.baseURL;
         const model = configuredModel ?? runtime.defaultModel;
         const selectedRuntime = runtime;
         const deadline = {
           ...deps.residencyOptions,
+          ...kind === "llama-swap" ? { runtimeLabel: "llama-swap" } : {},
           ...signal === undefined ? {} : { signal }
         };
-        const reachable = localRuntimeKind(runtime) === "lemonade" ? await withResidencyDeadline((signal2) => deps.localRuntimeReachable(selectedRuntime, signal2), deadline) : await deps.localRuntimeReachable(runtime);
+        const reachable = runtimeRequiresModelResidency(kind) ? await withResidencyDeadline((signal2) => deps.localRuntimeReachable(selectedRuntime, signal2), deadline) : await deps.localRuntimeReachable(runtime);
         throwIfAborted();
         if (!reachable)
           return memoryToolMessages.localRuntimeUnavailable;
@@ -18650,7 +19228,7 @@ function createMemoryTool(deps) {
         const target = resolveTarget ? await withResidencyDeadline(async () => resolveTarget(model), deadline) : {
           baseURL,
           modelID: model.modelID,
-          fetch: localRuntimeKind(runtime) === "lemonade" ? createLemonadeGuardedFetch({
+          fetch: runtimeRequiresModelResidency(kind) ? (kind === "llama-swap" ? createLlamaSwapGuardedFetch : createLemonadeGuardedFetch)({
             baseURL,
             fetch: deps.fetch,
             modelIDs: new Set([model.modelID]),
@@ -18753,12 +19331,841 @@ function createOrchestratedModelOwnership() {
   };
 }
 
+// src/plugin/nativeHost.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { execFile as execFile3 } from "node:child_process";
+import { resolve as resolve10 } from "node:path";
+import { Model as Model2 } from "@opencode/schema/model";
+import { Session as Session2 } from "@opencode/schema/session";
+import { Tool } from "@opencode/schema/tool";
+import { tool as legacyTool } from "@opencode-ai/plugin/tool";
+import { Clock, Effect, Option, Stream } from "effect";
+import { z as z30 } from "zod";
+
+// src/plugin/nativeHostContext.ts
+import {
+  Context
+} from "effect";
+
+class NativeSessions extends Context.Service()("@opencode/Session") {
+}
+
+class NativePermissions extends Context.Service()("@opencode/Permission") {
+}
+
+class NativeAgents extends Context.Service()("@opencode/Agent") {
+}
+
+class NativeLocations extends Context.Service()("@opencode/example/LocationServiceMap") {
+}
+
+class NativeServerInfo extends Context.Service()("@opencode/server/ServerInfo") {
+}
+
+class NativeServerAuth extends Context.Service()("@opencode/ServerAuthConfig") {
+}
+
+// src/plugin/nativeInventory.ts
+function nativeConfiguredInventory(models, config) {
+  const local = new Set(config.local.runtimes.map((runtime) => runtime.defaultModel.providerID));
+  const enabled = models.filter((model) => model.enabled);
+  const catalog = new Map;
+  for (const model of enabled) {
+    if (local.has(model.providerID))
+      continue;
+    const provider = catalog.get(model.providerID) ?? { models: [] };
+    provider.models.push({
+      id: model.id,
+      name: model.name,
+      limit: model.limit,
+      cost: model.cost.find((tier) => tier.tier === undefined),
+      status: model.status,
+      tool_call: model.capabilities.tools,
+      modalities: { input: model.capabilities.input },
+      reasoning: model.capabilities.output.includes("reasoning")
+    });
+    catalog.set(model.providerID, provider);
+  }
+  return {
+    models: enabled.map((model) => ({
+      providerID: model.providerID,
+      modelID: model.id,
+      apiModelID: model.modelID,
+      ...local.has(model.providerID) ? {} : {
+        supportsTools: model.capabilities.tools,
+        ...model.limit.context > 0 ? { contextWindow: model.limit.context } : {}
+      }
+    })),
+    profiles: normalizeModelsDevCatalog(Object.fromEntries(catalog))
+  };
+}
+
+// src/plugin/nativeResidency.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { z as z29 } from "zod";
+var NATIVE_RESIDENCY_PROVIDER_PACKAGE = "aisdk:@ai-sdk/openai-compatible@2.0.75";
+var NATIVE_ADMISSION_HEADER = "x-openteam-local-admission";
+var MAX_ADMISSIONS = 2048;
+var compatiblePackages = new Set([
+  "@ai-sdk/openai-compatible",
+  "aisdk:@ai-sdk/openai-compatible",
+  "@opencode/ai/providers/openai-compatible",
+  NATIVE_RESIDENCY_PROVIDER_PACKAGE
+]);
+function key(ref) {
+  return `${ref.providerID}\x00${ref.modelID}`;
+}
+function label(runtime) {
+  return localRuntimeKind(runtime) === "llama-swap" ? "llama-swap" : "Lemonade";
+}
+function runtimeBase2(runtime) {
+  return localRuntimeKind(runtime) === "llama-swap" ? llamaSwapBaseURL(runtime.baseURL ?? LLAMA_SWAP_DEFAULT_BASE_URL) : lemonadeBaseURL(runtime.baseURL ?? LEMONADE_DEFAULT_BASE_URL);
+}
+function createNativeModelResidencyGuard(config, options) {
+  const admissions = new Map;
+  const localTargets = new Map;
+  let disposed = false;
+  const residentRuntimes = config.local.runtimes.filter((runtime) => runtimeRequiresModelResidency(localRuntimeKind(runtime)));
+  const globalMode = () => resolveExecutionMode({
+    routerMode: config.router.executionMode,
+    legacyLocalOnly: config.router.localOnly,
+    legacyFrontierOnly: config.router.frontierOnly
+  });
+  function allowed(providerID, mode) {
+    const local = config.local.runtimes.filter((runtime) => runtime.defaultModel.providerID === providerID);
+    return local.length > 0 ? mode !== "frontier" && local.some((runtime) => runtime.enabled) : mode !== "local";
+  }
+  function protects(providerID, url) {
+    return residentRuntimes.some((runtime) => {
+      if (runtime.defaultModel.providerID === providerID)
+        return true;
+      if (url === undefined)
+        return false;
+      if (!URL.canParse(url))
+        return true;
+      return new URL(url).origin === new URL(runtimeBase2(runtime)).origin;
+    });
+  }
+  function bind(model) {
+    const runtimes = config.local.runtimes.filter((runtime2) => runtime2.defaultModel.providerID === model.providerID);
+    const runtime = runtimes[0];
+    const runtimeLabel = runtime === undefined ? undefined : label(runtime);
+    if (runtimes.length !== 1 || runtime === undefined || !runtime.enabled)
+      throw new ModelResidencyError("destination", runtimeLabel);
+    const baseURL = runtimeBase2(runtime);
+    const base = model.settings?.baseURL;
+    const normalized = typeof base !== "string" ? undefined : localRuntimeKind(runtime) === "llama-swap" ? llamaSwapBaseURL(base) : lemonadeBaseURL(base);
+    if (normalized !== baseURL)
+      throw new ModelResidencyError("destination", runtimeLabel);
+    if (model.package !== NATIVE_RESIDENCY_PROVIDER_PACKAGE || model.transport === "websocket" || model.settings?.fetch !== undefined || model.settings?.queryParams !== undefined || model.settings?.transformRequestBody !== undefined)
+      throw new ModelResidencyError("transport", runtimeLabel);
+    if (!model.modelID || model.modelID !== model.modelID.trim() || model.body?.model !== undefined && model.body.model !== model.modelID)
+      throw new ModelResidencyError("identity", runtimeLabel);
+    return { runtime, model, baseURL };
+  }
+  function guardedFetch(binding, send, authorized = () => true) {
+    const create = localRuntimeKind(binding.runtime) === "llama-swap" ? createLlamaSwapGuardedFetch : createLemonadeGuardedFetch;
+    return create({
+      ...options,
+      fetch: Object.assign((input, init) => {
+        if (disposed || !authorized())
+          throw new Error(nativeHostMessages.missingAdmission);
+        return send(input, init);
+      }, {
+        preconnect: (...args) => send.preconnect?.(...args)
+      }),
+      healthFetch: options.fetch,
+      baseURL: binding.baseURL,
+      modelIDs: new Set([binding.model.modelID])
+    });
+  }
+  function target(model, send, baseURL) {
+    const headers = new Headers(z29.record(z29.string(), z29.string()).parse(model.headers ?? {}));
+    if (typeof model.settings?.apiKey === "string" && !headers.has("authorization"))
+      headers.set("authorization", `Bearer ${model.settings.apiKey}`);
+    return {
+      baseURL,
+      modelID: model.modelID,
+      fetch: Object.assign(async (input, init) => {
+        if (disposed)
+          throw new Error(nativeHostMessages.missingAdmission);
+        const request = new Request(input, init);
+        for (const [name, value] of headers)
+          if (!request.headers.has(name))
+            request.headers.set(name, value);
+        return send(request);
+      }, {
+        preconnect: (...args) => send.preconnect?.(...args)
+      })
+    };
+  }
+  function observeModels(models) {
+    localTargets.clear();
+    return models.map((model) => {
+      if (!allowed(model.providerID, globalMode()))
+        return { ...model, enabled: false };
+      if (!model.enabled)
+        return model;
+      const ref = { providerID: model.providerID, modelID: model.id };
+      const base = model.settings?.baseURL;
+      if (!protects(model.providerID, typeof base === "string" ? base : undefined)) {
+        if (config.local.runtimes.some((runtime) => runtime.enabled && runtime.defaultModel.providerID === model.providerID) && typeof base === "string")
+          localTargets.set(key(ref), target(model, options.fetch, base));
+        return model;
+      }
+      try {
+        const binding = bind(model);
+        localTargets.set(key(ref), target(model, guardedFetch(binding, options.fetch), binding.baseURL));
+        return model;
+      } catch (error) {
+        if (!(error instanceof ModelResidencyError) && !(error instanceof z29.ZodError))
+          throw error;
+        (options.warn ?? console.warn)(modelResidencyMessages.providerDisabled(model.providerID, residentRuntimes.find((runtime) => runtime.defaultModel.providerID === model.providerID)?.kind === "llama-swap" ? "llama-swap" : "Lemonade"));
+        return { ...model, enabled: false };
+      }
+    });
+  }
+  return {
+    providers(editor) {
+      for (const record of editor.list())
+        if (!allowed(record.provider.id, globalMode()))
+          editor.remove(record.provider.id);
+    },
+    transform(editor) {
+      for (const model of editor.list()) {
+        const provider = editor.provider.get(model.providerID)?.provider;
+        const base = model.settings?.baseURL ?? provider?.settings?.baseURL;
+        const pkg = model.package ?? provider?.package;
+        if (protects(model.providerID, typeof base === "string" ? base : undefined) && pkg !== undefined && compatiblePackages.has(pkg))
+          editor.update(model.providerID, model.id, (draft) => {
+            draft.package = NATIVE_RESIDENCY_PROVIDER_PACKAGE;
+          });
+      }
+    },
+    observeModels,
+    sdk(event) {
+      if (!protects(event.model.providerID, typeof event.options.baseURL === "string" ? event.options.baseURL : undefined))
+        return;
+      const factory = bind(event.model);
+      if (event.package !== NATIVE_RESIDENCY_PROVIDER_PACKAGE.slice("aisdk:".length) || typeof event.options.fetch !== "function")
+        throw new Error(nativeHostMessages.transportUnavailable);
+      const upstream = event.options.fetch;
+      const transport = Object.assign((input, init) => {
+        const request = new Request(input, init);
+        return upstream(request, {
+          signal: request.signal,
+          redirect: "error"
+        });
+      }, {
+        preconnect: (...args) => upstream.preconnect?.(...args)
+      });
+      event.options.fetch = Object.assign(async (input, init) => {
+        let request = new Request(input, init);
+        const token = request.headers.get(NATIVE_ADMISSION_HEADER);
+        const admission = token === null ? undefined : admissions.get(token);
+        if (token === null || admission === undefined || admission.model.providerID !== factory.model.providerID || admission.baseURL !== factory.baseURL)
+          throw new Error(nativeHostMessages.missingAdmission);
+        request.headers.delete(NATIVE_ADMISSION_HEADER);
+        if (factory.model.body !== undefined) {
+          let body;
+          try {
+            body = await request.json();
+          } catch {
+            throw new ModelResidencyError("request", label(factory.runtime));
+          }
+          if (body === null || typeof body !== "object" || Array.isArray(body))
+            throw new ModelResidencyError("request", label(factory.runtime));
+          request = new Request(request, {
+            body: JSON.stringify(mergeConfigInputs(body, factory.model.body))
+          });
+        }
+        return guardedFetch(admission, transport, () => admissions.get(token) === admission)(request);
+      }, {
+        preconnect: (...args) => upstream.preconnect?.(...args)
+      });
+    },
+    async modelRequest(event) {
+      if (disposed)
+        throw new Error(nativeHostMessages.missingAdmission);
+      const roleID = await options.resolveAgentRole?.(event.agent) ?? event.agent;
+      const role = isKnownNonWorkerRole(roleID) ? undefined : getRoleProfile(roleID, config.orchestrator?.roles);
+      const policy = role === undefined ? config.orchestrator?.primary : agentExecutionPolicyForRole(role);
+      const mode = resolveExecutionMode({
+        routerMode: globalMode(),
+        agentMode: policy?.executionMode
+      });
+      if (!allowed(event.model.providerID, mode))
+        throw new Error(nativeHostMessages.executionDomainBlocked);
+      if (!protects(event.model.providerID, event.baseURL))
+        return;
+      const model = (await options.readModels()).find((candidate) => candidate.providerID === event.model.providerID && candidate.id === event.model.id && candidate.enabled);
+      if (model === undefined)
+        throw new Error(nativeHostMessages.transportUnavailable);
+      const variant = model.variants.find((candidate) => candidate.id === event.model.variant);
+      const effective = variant === undefined ? model : {
+        ...model,
+        settings: { ...model.settings, ...variant.settings },
+        headers: { ...model.headers, ...variant.headers },
+        body: { ...model.body, ...variant.body }
+      };
+      const binding = bind(effective);
+      if (disposed)
+        throw new Error(nativeHostMessages.missingAdmission);
+      const token = (options.newRequestID ?? randomUUID2)();
+      admissions.set(token, {
+        ...binding,
+        sessionID: event.sessionID,
+        kind: event.kind
+      });
+      const oldest = admissions.keys().next().value;
+      if (admissions.size > MAX_ADMISSIONS && oldest !== undefined)
+        admissions.delete(oldest);
+      event.headers[NATIVE_ADMISSION_HEADER] = token;
+    },
+    async http(event) {
+      if (protects(event.model.providerID, event.request.url))
+        throw new Error(nativeHostMessages.transportUnavailable);
+    },
+    websocket(event) {
+      const url = new URL(event.url);
+      if (url.protocol === "ws:")
+        url.protocol = "http:";
+      if (url.protocol === "wss:")
+        url.protocol = "https:";
+      if (protects(event.model.providerID, url.href))
+        throw new Error(nativeHostMessages.transportUnavailable);
+    },
+    finished(sessionID) {
+      for (const [token, admission] of admissions)
+        if (admission.sessionID === sessionID)
+          admissions.delete(token);
+    },
+    dispose() {
+      disposed = true;
+      admissions.clear();
+      localTargets.clear();
+    },
+    localTarget(ref) {
+      const value = localTargets.get(key(ref));
+      if (value === undefined)
+        throw new Error(nativeHostMessages.transportUnavailable);
+      return value;
+    }
+  };
+}
+
+// src/plugin/nativeSessions.ts
+import { resolve as resolve9 } from "node:path";
+import { Agent } from "@opencode/schema/agent";
+import { Model } from "@opencode/schema/model";
+import { Session } from "@opencode/schema/session";
+import { DateTime } from "effect";
+function sameNativeWorkspace(actual, expected) {
+  return resolve9(actual.directory) === resolve9(expected.directory) && actual.workspaceID === expected.workspaceID;
+}
+function nativeAssistantResponse(sessionID, message) {
+  return {
+    info: {
+      id: message.id,
+      sessionID,
+      role: "assistant",
+      mode: message.agent,
+      providerID: message.model.providerID,
+      modelID: message.model.id,
+      ...message.cost === undefined ? {} : { cost: message.cost },
+      ...message.tokens === undefined ? {} : { tokens: message.tokens },
+      ...message.error === undefined ? {} : { error: message.error },
+      time: {
+        created: DateTime.toEpochMillis(message.time.created),
+        ...message.time.completed === undefined ? {} : { completed: DateTime.toEpochMillis(message.time.completed) }
+      }
+    },
+    parts: message.content.flatMap((part) => part.type === "text" ? [{ type: "text", text: part.text }] : [])
+  };
+}
+function createNativeSessionClient(deps) {
+  const directory = resolve9(deps.directory);
+  const location = {
+    directory,
+    ...deps.workspaceID === undefined ? {} : { workspaceID: deps.workspaceID }
+  };
+  function assertDirectory(candidate) {
+    if (candidate !== undefined && resolve9(candidate) !== directory)
+      throw new Error(nativeHostMessages.workspaceMismatch);
+  }
+  async function ownedSession(id, signal) {
+    const info = await deps.run(deps.sessions().get(id), signal === undefined ? undefined : { signal });
+    if (!sameNativeWorkspace(info.location, location))
+      throw new Error(nativeHostMessages.workspaceMismatch);
+    return info;
+  }
+  return {
+    async create(args) {
+      const signal = deps.signal?.();
+      signal?.throwIfAborted();
+      assertDirectory(args.query?.directory);
+      if (args.body?.parentID === undefined)
+        throw new Error(nativeHostMessages.missingBindings);
+      const parentID = Session.ID.make(args.body.parentID);
+      await ownedSession(parentID, signal);
+      const child = await deps.run(deps.sessions().create({
+        parentID,
+        ...args.body.title === undefined ? {} : { title: args.body.title }
+      }));
+      if (!sameNativeWorkspace(child.location, location))
+        throw new Error(nativeHostMessages.workspaceMismatch);
+      if (child.parentID !== parentID)
+        throw new Error(nativeHostMessages.missingBindings);
+      signal?.throwIfAborted();
+      return { data: { id: child.id }, error: undefined };
+    },
+    async prompt(args) {
+      const parentSignal = deps.signal?.();
+      const signal = parentSignal === undefined ? args.signal : args.signal === undefined ? parentSignal : AbortSignal.any([parentSignal, args.signal]);
+      const sessionID = Session.ID.make(args.path.id);
+      await ownedSession(sessionID, signal);
+      const run = (effect) => deps.run(effect, signal === undefined ? undefined : { signal });
+      const sessions = deps.sessions();
+      try {
+        if (args.body.agent !== undefined)
+          await run(sessions.switchAgent({
+            sessionID,
+            agent: Agent.ID.make(args.body.agent)
+          }));
+        if (args.body.model !== undefined)
+          await run(sessions.switchModel({
+            sessionID,
+            model: Model.Ref.parse(`${args.body.model.providerID}/${args.body.model.modelID}`)
+          }));
+        if (args.body.system !== undefined)
+          deps.systemPrompts.set(sessionID, args.body.system);
+        await run(sessions.prompt({
+          sessionID,
+          text: args.body.parts.map((part) => part.text).join(`
+`)
+        }));
+        await run(sessions.wait(sessionID));
+        const final = await ownedSession(sessionID, signal);
+        const messages = await run(sessions.messages({ sessionID, limit: 100 }));
+        const assistant = [...messages].reverse().find((message) => message.type === "assistant");
+        if (final.outcome === "interrupted")
+          throw new Error(nativeHostMessages.executionInterrupted);
+        if (final.outcome !== "succeeded" || assistant?.error !== undefined)
+          throw new Error(nativeHostMessages.executionFailed);
+        if (assistant?.time.completed === undefined)
+          throw new Error(nativeHostMessages.noCompletedResponse);
+        return {
+          data: nativeAssistantResponse(sessionID, assistant),
+          error: undefined
+        };
+      } finally {
+        if (signal?.aborted)
+          await deps.run(sessions.interrupt(sessionID, { resume: false }));
+      }
+    },
+    async abort(args) {
+      assertDirectory(args.query?.directory);
+      const id = Session.ID.make(args.path.id);
+      await ownedSession(id, args.signal);
+      const options = args.signal === undefined ? undefined : { signal: args.signal };
+      await deps.run(deps.sessions().interrupt(id, { resume: false }), options);
+      const active = await deps.run(deps.sessions().active, options);
+      return { data: !active.has(id), error: undefined };
+    },
+    async status(args) {
+      assertDirectory(args?.query?.directory);
+      const options = args?.signal == null ? undefined : { signal: args.signal };
+      const sessions = deps.sessions();
+      const active = await deps.run(sessions.active, options);
+      const entries = [];
+      for (const id of active) {
+        const info = await deps.run(sessions.get(id), options);
+        if (sameNativeWorkspace(info.location, location))
+          entries.push([id, { type: "busy" }]);
+      }
+      return { data: Object.fromEntries(entries), error: undefined };
+    }
+  };
+}
+
+// src/plugin/nativeHost.ts
+var executionEvent = z30.preprocess(only(["type", "location", "data"]), z30.object({
+  type: z30.enum([
+    "session.created",
+    "session.deleted",
+    "session.execution.started",
+    "session.execution.succeeded",
+    "session.execution.failed",
+    "session.execution.interrupted",
+    "session.step.ended",
+    "session.step.failed"
+  ]),
+  location: z30.preprocess(only(["directory", "workspaceID"]), z30.object({
+    directory: z30.string(),
+    workspaceID: z30.string().optional()
+  }).strict()).optional(),
+  data: z30.preprocess(only(["sessionID", "assistantMessageID"]), z30.object({
+    sessionID: z30.string(),
+    assistantMessageID: z30.string().optional()
+  }).strict())
+}).strict());
+var nativeBindings = Effect.fn("openteam.nativeBindings")(function* () {
+  const sessions = yield* Effect.serviceOption(NativeSessions);
+  const permissions = yield* Effect.serviceOption(NativePermissions);
+  const agents = yield* Effect.serviceOption(NativeAgents);
+  const locations = yield* Effect.serviceOption(NativeLocations);
+  if (Option.isNone(sessions) || Option.isNone(permissions) || Option.isNone(agents) || Option.isNone(locations))
+    return yield* Effect.die(new Error(nativeHostMessages.missingBindings));
+  const server = yield* Effect.serviceOption(NativeServerInfo);
+  const auth = yield* Effect.serviceOption(NativeServerAuth);
+  return {
+    sessions: sessions.value,
+    permissions: permissions.value,
+    agents: agents.value,
+    locations: locations.value,
+    ...Option.isNone(server) ? {} : { server: server.value },
+    ...Option.isNone(auth) ? {} : { auth: auth.value }
+  };
+});
+function nativeExec(directory) {
+  return (command, args) => new Promise((resolveOutput, reject) => {
+    execFile3(command, [...args], { cwd: directory }, (error, stdout, stderr) => {
+      if (error !== null && typeof error.code !== "number") {
+        reject(error);
+        return;
+      }
+      resolveOutput({
+        exitCode: typeof error?.code === "number" ? error.code : 0,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+function legacyModel(ref) {
+  return { providerID: ref.providerID, modelID: ref.id };
+}
+function createNativePluginEffect(factory) {
+  return Effect.fn("openteam.native")(function* (ctx) {
+    if (ctx.app.version !== NATIVE_OPENCODE_VERSION)
+      return yield* Effect.die(new Error(nativeHostMessages.unsupportedVersion(ctx.app.version)));
+    const version = ctx.app.version;
+    const effectContext = yield* Effect.context();
+    const directory = resolve10(ctx.location.directory);
+    let bindings;
+    const run = (effect, options) => {
+      const current = bindings;
+      const bound = current === undefined ? effect : effect.pipe(Effect.provideService(NativeSessions, current.sessions), Effect.provideService(NativePermissions, current.permissions), Effect.provideService(NativeAgents, current.agents), Effect.provideService(NativeLocations, current.locations));
+      return Effect.runPromiseWith(effectContext)(bound, options);
+    };
+    let config;
+    let residency;
+    const systemPrompts = new Map;
+    const toolSignals = new AsyncLocalStorage;
+    const remember = (next) => {
+      bindings = { ...bindings, ...next };
+    };
+    const requiredBindings = () => {
+      if (bindings === undefined)
+        throw new Error(nativeHostMessages.missingBindings);
+      return bindings;
+    };
+    const assertWorkspace = (candidate) => {
+      if (!sameNativeWorkspace(candidate, ctx.location))
+        throw new Error(nativeHostMessages.workspaceMismatch);
+    };
+    const session = createNativeSessionClient({
+      directory,
+      ...ctx.location.workspaceID === undefined ? {} : { workspaceID: ctx.location.workspaceID },
+      sessions: () => requiredBindings().sessions,
+      run,
+      systemPrompts,
+      signal: () => toolSignals.getStore()
+    });
+    const client = {
+      session,
+      app: {
+        async agents() {
+          const result = await run(ctx.agent.list());
+          return {
+            data: result.data.map((agent) => ({ name: agent.id })),
+            error: undefined
+          };
+        },
+        async log(input) {
+          const message = input.body?.message ?? nativeHostMessages.toolFailed;
+          await run(input.body?.level === "error" ? Effect.logError(message) : input.body?.level === "warn" ? Effect.logWarning(message) : Effect.logInfo(message));
+        }
+      },
+      instance: {
+        async dispose(input) {
+          assertWorkspace({
+            ...ctx.location,
+            directory: input.query?.directory ?? directory
+          });
+          await run(requiredBindings().locations.invalidate({
+            directory: ctx.location.directory,
+            ...ctx.location.workspaceID === undefined ? {} : { workspaceID: ctx.location.workspaceID }
+          }), input.signal == null ? undefined : { signal: input.signal });
+          return { data: true, error: undefined };
+        }
+      }
+    };
+    const hooks = yield* Effect.promise(() => factory({
+      directory,
+      worktree: ctx.location.project.directory,
+      client,
+      exec: nativeExec(directory),
+      serverUrl: () => {
+        const url = bindings?.server?.urls().find((value) => {
+          if (!URL.canParse(value))
+            return false;
+          return ["127.0.0.1", "localhost", "[::1]"].includes(new URL(value).hostname);
+        });
+        return url === undefined ? undefined : new URL(url);
+      },
+      opencodeVersion: async () => version,
+      listConfiguredInventory: async () => {
+        if (config === undefined || residency === undefined)
+          throw new Error(nativeHostMessages.missingBindings);
+        const models = residency.observeModels((await run(ctx.model.list())).data);
+        return nativeConfiguredInventory(models, config);
+      },
+      consoleEnvironment: () => {
+        const auth = bindings?.auth;
+        return {
+          ...process.env,
+          BUN_BE_BUN: "1",
+          OPENCODE_SERVER_USERNAME: auth?.username,
+          OPENCODE_SERVER_PASSWORD: auth && Option.isSome(auth.password) ? auth.password.value : undefined
+        };
+      },
+      createResidencyGuard: (runtimeConfig, options) => {
+        config = runtimeConfig;
+        residency = createNativeModelResidencyGuard(runtimeConfig, {
+          ...options,
+          readModels: async () => (await run(ctx.model.list())).data
+        });
+        return residency;
+      }
+    }, ctx.options));
+    const guard = residency;
+    if (guard === undefined)
+      return yield* Effect.die(new Error(nativeHostMessages.missingBindings));
+    const chatMessage = hooks["chat.message"];
+    const tools = hooks.tool;
+    if (chatMessage === undefined || tools === undefined)
+      return yield* Effect.die(new Error(nativeHostMessages.missingBindings));
+    yield* Effect.addFinalizer(() => Effect.promise(async () => {
+      guard.dispose();
+      systemPrompts.clear();
+      await hooks.dispose?.();
+    }));
+    yield* ctx.provider.transform(guard.providers);
+    yield* ctx.model.transform(guard.transform);
+    yield* ctx.aisdk.hook("sdk", (event) => Effect.sync(() => guard.sdk(event)));
+    yield* ctx.session.hook("model.request", (event) => Effect.promise(() => guard.modelRequest(event)));
+    yield* ctx.session.hook("http.request", (event) => Effect.promise(() => guard.http(event)));
+    yield* ctx.session.hook("experimental.ws.handshake", (event) => Effect.sync(() => guard.websocket(event)));
+    yield* ctx.session.hook("context", (event) => Effect.sync(() => {
+      const system = systemPrompts.get(event.sessionID);
+      if (system !== undefined)
+        event.system.push({ type: "text", text: system });
+    }));
+    yield* ctx.session.hook("prompt", Effect.fn("openteam.nativePrompt")(function* (event) {
+      const currentBindings = yield* nativeBindings();
+      const current = yield* ctx.session.get({ sessionID: event.sessionID }).pipe(Effect.orDie);
+      assertWorkspace(current.location);
+      remember(currentBindings);
+      const agent = yield* currentBindings.agents.resolve(current.agent).pipe(Effect.orDie);
+      if (agent === undefined)
+        return yield* Effect.die(new Error(nativeHostMessages.unknownAgent));
+      const selected = current.model ?? (yield* ctx.model.default().pipe(Effect.orDie)).data ?? (yield* ctx.model.list().pipe(Effect.orDie)).data[0];
+      if (selected === undefined)
+        return yield* Effect.die(new Error(nativeHostMessages.noAvailableModel));
+      const created = yield* Clock.currentTimeMillis;
+      const output = {
+        message: {
+          id: event.messageID,
+          sessionID: event.sessionID,
+          role: "user",
+          time: { created },
+          agent: agent.id,
+          model: legacyModel(selected)
+        },
+        parts: [
+          {
+            id: event.messageID,
+            sessionID: event.sessionID,
+            messageID: event.messageID,
+            type: "text",
+            text: event.prompt.text
+          }
+        ]
+      };
+      yield* Effect.promise(() => chatMessage({
+        sessionID: event.sessionID,
+        messageID: event.messageID,
+        agent: agent.id,
+        ...current.model === undefined ? {} : { model: legacyModel(current.model) }
+      }, output));
+      const routed = output.message.model;
+      yield* ctx.session.switchModel({
+        sessionID: event.sessionID,
+        model: {
+          ...Model2.Ref.parse(`${routed.providerID}/${routed.modelID}`),
+          ...current.model?.providerID === routed.providerID && current.model.id === routed.modelID && current.model.variant !== undefined ? { variant: current.model.variant } : {}
+        }
+      }).pipe(Effect.orDie);
+      const part = output.parts[0];
+      if (part?.type === "text")
+        event.prompt.text = part.text;
+    }));
+    yield* ctx.tool.transform((editor) => {
+      for (const [name, definition] of Object.entries(tools)) {
+        const input = legacyTool.schema.object(definition.args);
+        editor.add({
+          name,
+          description: definition.description,
+          input: legacyTool.schema.toJSONSchema(input, { io: "input" }),
+          options: { codemode: false },
+          execute: Effect.fn("openteam.nativeTool")(function* (_input, toolContext) {
+            const current = requiredBindings();
+            const parent = yield* current.sessions.get(toolContext.sessionID).pipe(Effect.orDie);
+            assertWorkspace(parent.location);
+            remember(current);
+            return yield* Effect.tryPromise(async (signal) => {
+              const progress = [];
+              const context = {
+                sessionID: toolContext.sessionID,
+                messageID: toolContext.messageID,
+                agent: toolContext.agent,
+                directory,
+                worktree: ctx.location.project.directory,
+                abort: signal,
+                metadata: (update) => {
+                  progress.push(run(toolContext.progress({
+                    ...update.metadata,
+                    ...update.title === undefined ? {} : { title: update.title }
+                  }), { signal }).then(() => ({}), (error) => ({ error })));
+                },
+                ask: async (request) => {
+                  await run(current.permissions.assert({
+                    sessionID: toolContext.sessionID,
+                    agent: toolContext.agent,
+                    action: request.permission,
+                    resources: request.patterns,
+                    save: request.always,
+                    metadata: request.metadata,
+                    source: {
+                      type: "tool",
+                      messageID: toolContext.messageID,
+                      id: toolContext.id
+                    }
+                  }), { signal });
+                }
+              };
+              const result = await toolSignals.run(signal, () => definition.execute(input.parse(_input), context));
+              const failed = (await Promise.all(progress)).find((entry) => entry.error !== undefined);
+              if (failed)
+                throw failed.error;
+              if (typeof result === "string")
+                return { content: result };
+              return {
+                content: [
+                  { type: "text", text: result.output },
+                  ...(result.attachments ?? []).map((attachment) => ({
+                    type: "file",
+                    uri: attachment.url,
+                    mime: attachment.mime,
+                    ...attachment.filename === undefined ? {} : { name: attachment.filename }
+                  }))
+                ],
+                metadata: {
+                  ...result.metadata,
+                  ...result.title === undefined ? {} : { title: result.title }
+                }
+              };
+            }).pipe(Effect.mapError(() => new Tool.Error({ message: nativeHostMessages.toolFailed })));
+          })
+        });
+      }
+    });
+    yield* ctx.tool.hook("execute.before", (event) => Effect.promise(() => hooks["tool.execute.before"]?.({ tool: event.tool, sessionID: event.sessionID, callID: event.id }, { args: event.input }) ?? Promise.resolve()));
+    yield* ctx.tool.hook("execute.after", (event) => Effect.promise(() => hooks["tool.execute.after"]?.({
+      tool: event.tool,
+      sessionID: event.sessionID,
+      callID: event.id,
+      args: event.input
+    }, { title: event.tool, output: "", metadata: {} }) ?? Promise.resolve()));
+    yield* ctx.event.subscribe().pipe(Stream.runForEach((event) => Effect.tryPromise(async () => {
+      const parsed = executionEvent.safeParse(event);
+      if (!parsed.success)
+        return;
+      const value = parsed.data;
+      if (value.location !== undefined) {
+        if (!sameNativeWorkspace(value.location, ctx.location))
+          return;
+      } else if (value.type !== "session.deleted") {
+        const info = await run(ctx.session.get({
+          sessionID: Session2.ID.make(value.data.sessionID)
+        }));
+        if (!sameNativeWorkspace(info.location, ctx.location))
+          return;
+      } else
+        return;
+      const sessionID = value.data.sessionID;
+      if (value.type === "session.deleted") {
+        guard.finished(sessionID);
+        systemPrompts.delete(sessionID);
+      }
+      let mapped;
+      if (value.type === "session.created" || value.type === "session.deleted") {
+        mapped = {
+          type: value.type,
+          properties: { info: { id: sessionID } }
+        };
+      } else if (value.type === "session.execution.started") {
+        mapped = {
+          type: "session.status",
+          properties: { sessionID, status: { type: "busy" } }
+        };
+      } else if (value.type === "session.step.ended" || value.type === "session.step.failed") {
+        if (bindings === undefined)
+          return;
+        const messages = await run(bindings.sessions.messages({
+          sessionID: Session2.ID.make(sessionID),
+          limit: 100
+        }));
+        const message = messages.find((candidate) => candidate.id === value.data.assistantMessageID);
+        if (message?.type !== "assistant")
+          return;
+        mapped = {
+          type: "message.updated",
+          properties: {
+            info: nativeAssistantResponse(sessionID, message).info
+          }
+        };
+      } else {
+        systemPrompts.delete(sessionID);
+        guard.finished(sessionID);
+        if (value.type !== "session.execution.succeeded")
+          await hooks.event?.({
+            event: { type: "session.error", properties: { sessionID } }
+          });
+        mapped = { type: "session.idle", properties: { sessionID } };
+      }
+      await hooks.event?.({ event: mapped });
+    }).pipe(Effect.catch(() => Effect.logError(nativeHostMessages.eventCaptureFailed)))), Effect.tapCause(() => Effect.logError(nativeHostMessages.eventCaptureFailed)), Effect.forkScoped);
+  });
+}
+
 // src/plugin/orchestrateTool.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
-import { z as z30 } from "zod";
+import { z as z32 } from "zod";
 
 // src/orchestrator/coordinator.ts
-import { z as z29 } from "zod";
+import { z as z31 } from "zod";
 
 // src/orchestrator/nodeIteration.ts
 var DEFAULT_MAX_RETRIES = 2;
@@ -19232,7 +20639,7 @@ function buildRecord(input, decision2, subsession, deps, decisionID, batchID) {
   }
   return record;
 }
-var TelemetryFailureClassSchema = z29.enum([
+var TelemetryFailureClassSchema = z31.enum([
   "create-rejected",
   "create-no-id",
   "prompt-rejected",
@@ -19658,10 +21065,10 @@ function uniqueModels(models) {
   const seen = new Set;
   const unique = [];
   for (const model of models) {
-    const key = modelKey4(model);
-    if (seen.has(key))
+    const key2 = modelKey4(model);
+    if (seen.has(key2))
       continue;
-    seen.add(key);
+    seen.add(key2);
     unique.push(model);
   }
   return unique;
@@ -20049,7 +21456,7 @@ async function runRoleTasks(inputs, deps, options = {}) {
 var _pluginWarnedRoles = new Set;
 var EMPTY_ROLE_ID_SET = new Set;
 var SAFE_ROLE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
-var RoleIDSchema = z30.string().min(1).superRefine((roleID, ctx) => {
+var RoleIDSchema = z32.string().min(1).superRefine((roleID, ctx) => {
   if (!SAFE_ROLE_ID.test(roleID)) {
     ctx.addIssue({
       code: "custom",
@@ -20057,16 +21464,16 @@ var RoleIDSchema = z30.string().min(1).superRefine((roleID, ctx) => {
     });
   }
 });
-var RoleAssignmentSchema = z30.object({
+var RoleAssignmentSchema = z32.object({
   roleID: RoleIDSchema.describe("Role identifier from the roster"),
-  prompt: z30.string().min(1).describe("Work prompt for this role"),
-  title: z30.string().min(1).optional().describe("Human-readable title"),
-  dependsOn: z30.array(RoleIDSchema).optional().describe("Role IDs this assignment depends on (DAG edges)")
+  prompt: z32.string().min(1).describe("Work prompt for this role"),
+  title: z32.string().min(1).optional().describe("Human-readable title"),
+  dependsOn: z32.array(RoleIDSchema).optional().describe("Role IDs this assignment depends on (DAG edges)")
 }).strict();
-var OrchestratePayloadSchema = z30.object({
-  assignments: z30.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
-  parentSessionID: z30.string().min(1).optional().describe(PARENT_SESSION_DESCRIPTION),
-  directory: z30.string().min(1).optional().describe("Working directory override")
+var OrchestratePayloadSchema = z32.object({
+  assignments: z32.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
+  parentSessionID: z32.string().min(1).optional().describe(PARENT_SESSION_DESCRIPTION),
+  directory: z32.string().min(1).optional().describe("Working directory override")
 }).strict();
 function validateAssignmentDependencies(assignments) {
   const ids = new Set;
@@ -20127,14 +21534,14 @@ function validateAssignmentDependencies(assignments) {
 function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function nestedRecord2(value, key) {
-  const nested = value[key];
+function nestedRecord2(value, key2) {
+  const nested = value[key2];
   return isRecord7(nested) ? nested : undefined;
 }
 function numberField(records, keys) {
   for (const record of records) {
-    for (const key of keys) {
-      const value = record[key];
+    for (const key2 of keys) {
+      const value = record[key2];
       if (typeof value === "number" && Number.isInteger(value)) {
         return value;
       }
@@ -20144,8 +21551,8 @@ function numberField(records, keys) {
 }
 function booleanField(records, keys) {
   for (const record of records) {
-    for (const key of keys) {
-      const value = record[key];
+    for (const key2 of keys) {
+      const value = record[key2];
       if (typeof value === "boolean") {
         return value;
       }
@@ -20156,8 +21563,8 @@ function booleanField(records, keys) {
 function boundedErrorTokens(records) {
   const tokens = [];
   for (const record of records) {
-    for (const key of ["name", "code", "type", "message"]) {
-      const value = record[key];
+    for (const key2 of ["name", "code", "type", "message"]) {
+      const value = record[key2];
       if (typeof value === "string" && value.length <= 100) {
         tokens.push(value.toLowerCase());
       }
@@ -20695,6 +22102,8 @@ function createOrchestrateTool(deps) {
       }
       const parentOverrideIgnored = parsed.data.parentSessionID !== undefined && parsed.data.parentSessionID !== context.sessionID;
       parsed.data.parentSessionID = context.sessionID;
+      if (parsed.data.directory === undefined && context.directory !== undefined)
+        parsed.data.directory = context.directory;
       const depError = validateAssignmentDependencies(parsed.data.assignments);
       if (depError !== undefined) {
         return dependencyValidationError(depError.code, depError.detail);
@@ -20802,7 +22211,7 @@ ${advisory}`;
 
 // src/plugin/registerCastTool.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
-import { z as z31 } from "zod";
+import { z as z33 } from "zod";
 
 // src/messages/rosterSummary.ts
 var ROSTER_SUMMARY_HEADING = "Registered team model policies";
@@ -20918,12 +22327,12 @@ function createTeamPreparation(deps) {
       OpenTeamConfigSchema.parse(migrateConfig(baseRaw));
       const overlay = overlayBefore === undefined ? undefined : parseConfigFileJson(DEFAULT_LOCAL_OVERLAY_PATH, overlayBefore);
       const options = configOptionsFromPluginOptions(deps.options);
-      const resolve9 = (raw) => {
+      const resolve11 = (raw) => {
         const config = validateConfigInput(TEAM_PREPARATION_CONFIG, mergeConfigInputs(mergeConfigInputs(raw, options), overlay));
         assertEffectiveConfigModelDomains(config);
         return config;
       };
-      const current = resolve9(baseRaw);
+      const current = resolve11(baseRaw);
       const live = liveConfig ?? current;
       if (resolveExecutionMode({
         routerMode: current.router.executionMode,
@@ -20945,9 +22354,9 @@ function createTeamPreparation(deps) {
           ]))
         }
       });
-      const effective = resolve9(candidate);
+      const effective = resolve11(candidate);
       const requestedProfiles = new Set(roster.entries.filter((entry) => !isKnownNonWorkerRole(entry.roleID) && getRoleProfile(entry.roleID, live.orchestrator?.roles) === undefined).map((entry) => getRoleProfile(entry.roleID, effective.orchestrator?.roles)));
-      const additions = Object.fromEntries(Object.entries(effective.orchestrator?.roles ?? {}).filter(([key, profile]) => requestedProfiles.has(profile) && !Object.hasOwn(live.orchestrator?.roles ?? {}, key)));
+      const additions = Object.fromEntries(Object.entries(effective.orchestrator?.roles ?? {}).filter(([key2, profile]) => requestedProfiles.has(profile) && !Object.hasOwn(live.orchestrator?.roles ?? {}, key2)));
       const hasAdditions = Object.keys(additions).length > 0;
       const next = hasAdditions ? validateConfigInput(TEAM_PREPARATION_CONFIG, {
         ...live,
@@ -21031,19 +22440,19 @@ async function persistPreparedTeam(storage, files) {
 }
 
 // src/plugin/registerCastTool.ts
-var CastEntrySchema = z31.object({
-  roleID: z31.string().min(1).describe("Stable role identifier, e.g. scribe or guardian"),
-  agentName: z31.string().min(1).describe("Themed character name assigned to the role")
+var CastEntrySchema = z33.object({
+  roleID: z33.string().min(1).describe("Stable role identifier, e.g. scribe or guardian"),
+  agentName: z33.string().min(1).describe("Themed character name assigned to the role")
 }).strict();
-var RegisterCastPayloadSchema = z31.object({
-  universe: z31.string().min(1).describe("Casting universe for this roster"),
-  entries: z31.array(CastEntrySchema).min(1).describe("Role-to-name mappings")
+var RegisterCastPayloadSchema = z33.object({
+  universe: z33.string().min(1).describe("Casting universe for this roster"),
+  entries: z33.array(CastEntrySchema).min(1).describe("Role-to-name mappings")
 }).strict();
 function offendingFields(error) {
   const fields = error.issues.flatMap((issue) => {
     const base = issue.path.map((segment) => String(segment));
     if (issue.code === "unrecognized_keys") {
-      return issue.keys.map((key) => [...base, key].join("."));
+      return issue.keys.map((key2) => [...base, key2].join("."));
     }
     return [base.join(".") || "(root)"];
   });
@@ -21083,12 +22492,12 @@ function markdownCell(value) {
 }
 function modelPolicyLabel(policy) {
   const model = policy?.model;
-  const label = model === undefined || model === "auto" ? ROSTER_AUTO_MODEL : `${model.providerID}/${model.modelID}`;
+  const label2 = model === undefined || model === "auto" ? ROSTER_AUTO_MODEL : `${model.providerID}/${model.modelID}`;
   if (policy?.fallbacks === undefined || policy.fallbacks.length === 0) {
-    return label;
+    return label2;
   }
   const fallbacks = policy.fallbacks.map((fallback) => `${fallback.providerID}/${fallback.modelID}`);
-  return `${label}; ${rosterOrderedFallbacks(fallbacks)}`;
+  return `${label2}; ${rosterOrderedFallbacks(fallbacks)}`;
 }
 function registeredTeamTable(roster, deps) {
   const rows = roster.entries.map((entry) => {
@@ -21157,7 +22566,7 @@ function createRegisterCastTool(deps) {
 }
 
 // src/plugin/reloadTool.ts
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve11 } from "node:path";
 import { tool as tool7 } from "@opencode-ai/plugin/tool";
 var WAIT_MS = 30000;
 var SDK_TIMEOUT_MS = 5000;
@@ -21191,7 +22600,7 @@ function createReloadController(deps) {
       return () => clearTimeout(timer);
     }
   };
-  const directory = resolve9(deps.directory);
+  const directory = resolve11(deps.directory);
   let pending;
   let authorizing;
   let closed = false;
@@ -21339,7 +22748,7 @@ function createReloadController(deps) {
       const parsed = schema.safeParse(args);
       if (!parsed.success)
         return reloadMessages.invalid;
-      if (context.agent !== "openteam" || resolve9(context.directory) !== directory || context.sessionID.trim().length === 0)
+      if (context.agent !== "openteam" || resolve11(context.directory) !== directory || context.sessionID.trim().length === 0)
         return reloadMessages.denied;
       if (parsed.data.action === "cancel") {
         if ((pending?.sessionID ?? authorizing?.sessionID) !== context.sessionID)
@@ -21485,7 +22894,7 @@ function createSessionTracker() {
 }
 
 // src/plugin/toolcalls.ts
-function key(sessionID, callID) {
+function key2(sessionID, callID) {
   return `${sessionID}\x00${callID}`;
 }
 function createToolcallTracker(deps) {
@@ -21493,10 +22902,10 @@ function createToolcallTracker(deps) {
   const started = new Map;
   return {
     before(input) {
-      started.set(key(input.sessionID, input.callID), now());
+      started.set(key2(input.sessionID, input.callID), now());
     },
     after(input) {
-      const mapKey = key(input.sessionID, input.callID);
+      const mapKey = key2(input.sessionID, input.callID);
       const start = started.get(mapKey);
       started.delete(mapKey);
       const end = now();
@@ -21569,6 +22978,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/storage/index/bunSqlite.ts
 async function createBunSqliteDatabase(path4) {
   const mod = await import("bun:sqlite");
@@ -21652,7 +23068,14 @@ 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;
   }
@@ -21661,15 +23084,22 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
   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: modelID2 }, { fetch: fetchImpl });
+    const embedder = makeEmbedder({ baseURL, modelID: modelID2 }, { fetch: guardedFetch });
     await ensureMemoryEmbeddings({ index, embedder, model: modelID2, warn });
     return {
       index,
@@ -21679,12 +23109,13 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
       semantic
     };
   } catch {
+    warn(memoryRuntimeMessages.unavailable);
     return;
   }
 }
 
 // src/storage/lifecycle/fsLifecycleJournal.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import {
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync3,
@@ -21694,22 +23125,22 @@ import {
   statSync,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join15, resolve as resolve11 } from "node:path";
+import { join as join15, resolve as resolve13 } from "node:path";
 import { ZodError } from "zod";
 
 // src/storage/lifecycle/codec.ts
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 var LIFECYCLE_CODEC_VERSION = 1;
 var LIFECYCLE_GENESIS_DIGEST = sha256Hex("openteam/lifecycle-journal/genesis/v1");
 var NUL5 = "\x00";
 var NEWLINE2 = `
 `;
-var frameSchema = z32.object({
-  v: z32.literal(LIFECYCLE_CODEC_VERSION),
-  seq: z32.number().int().nonnegative(),
-  prev: z32.string().min(1),
-  sum: z32.string().min(1),
-  event: z32.unknown()
+var frameSchema = z34.object({
+  v: z34.literal(LIFECYCLE_CODEC_VERSION),
+  seq: z34.number().int().nonnegative(),
+  prev: z34.string().min(1),
+  sum: z34.string().min(1),
+  event: z34.unknown()
 }).strict();
 function canonical2(value) {
   if (Array.isArray(value)) {
@@ -21718,7 +23149,7 @@ function canonical2(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
   }
-  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key2, child]) => `${JSON.stringify(key2)}:${canonical2(child)}`).join(",")}}`;
+  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key3, child]) => `${JSON.stringify(key3)}:${canonical2(child)}`).join(",")}}`;
 }
 function lifecycleFrameDigest(previousDigest, event) {
   return sha256Hex(`${previousDigest}${NUL5}${canonical2(event)}`);
@@ -21796,7 +23227,7 @@ function decodeLifecycleJournal(text) {
 }
 
 // src/storage/lifecycle/fsLifecycleSupport.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import {
   appendFileSync,
   closeSync as closeSync2,
@@ -21813,7 +23244,7 @@ import {
   unlinkSync,
   writeSync as writeSync2
 } from "node:fs";
-import { basename as basename3, dirname as dirname7, join as join14, relative as relative3, resolve as resolve10 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join14, relative as relative3, resolve as resolve12 } from "node:path";
 var SAFE_RUN_ID = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,126}[A-Za-z0-9])?$/u;
 
 class LifecycleFsError extends Error {
@@ -21837,7 +23268,7 @@ function validateRunID(runID) {
 }
 function resolvedLifecycleRoot(root) {
   try {
-    const absolute = resolve10(root);
+    const absolute = resolve12(root);
     mkdirSync2(absolute, { recursive: true });
     const rootStat = lstatSync2(absolute);
     if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
@@ -21880,7 +23311,7 @@ function assertExistingSafeRun(root, runID) {
     throw new LifecycleFsError("unavailable");
   }
   const child = relative3(root, real);
-  if (child === "" || child.startsWith("..") || resolve10(root, child) !== real || dirname7(real) !== root) {
+  if (child === "" || child.startsWith("..") || resolve12(root, child) !== real || dirname7(real) !== root) {
     throw new LifecycleFsError("corrupt");
   }
   return real;
@@ -21929,7 +23360,7 @@ function appendDurable2(path4, content) {
   }
 }
 function writeDurableAtomically(path4, content) {
-  const temporary = join14(dirname7(path4), `.${basename3(path4)}.${randomUUID2()}.next`);
+  const temporary = join14(dirname7(path4), `.${basename3(path4)}.${randomUUID3()}.next`);
   try {
     writeDurable2(temporary, content);
     renameSync(temporary, path4);
@@ -21952,7 +23383,7 @@ function readLockContents(path4) {
 }
 function withRunMutationLock(runDir, mutate) {
   const lockPath = join14(runDir, ".mutation-lock");
-  const lockToken = randomUUID2();
+  const lockToken = randomUUID3();
   let descriptor;
   try {
     descriptor = openSync2(lockPath, "wx");
@@ -22021,7 +23452,7 @@ function parseJson(text, parse2) {
   }
 }
 function issueWriterToken() {
-  return randomUUID3().replaceAll("-", "");
+  return randomUUID4().replaceAll("-", "");
 }
 function createLease(runID, writerToken, input) {
   return parseLifecycleWriterLease({
@@ -22049,8 +23480,8 @@ function readRun(runDir, runID) {
   if (metadataText === undefined || eventsText === undefined) {
     throw new LifecycleFsError("corrupt");
   }
-  const metadata2 = parseJson(metadataText, parseLifecycleRunMetadata);
-  if (metadata2.runID !== runID) {
+  const metadata3 = parseJson(metadataText, parseLifecycleRunMetadata);
+  if (metadata3.runID !== runID) {
     throw new LifecycleFsError("corrupt");
   }
   let decoded;
@@ -22065,10 +23496,10 @@ function readRun(runDir, runID) {
     }
   }
   const first = decoded.events[0];
-  if (first === undefined || first.type !== "run.started" || first.source !== metadata2.source || first.executionAuthority !== metadata2.executionAuthority || first.root.operationID !== metadata2.root.operationID || first.root.taskID !== metadata2.root.taskID) {
+  if (first === undefined || first.type !== "run.started" || first.source !== metadata3.source || first.executionAuthority !== metadata3.executionAuthority || first.root.operationID !== metadata3.root.operationID || first.root.taskID !== metadata3.root.taskID) {
     throw new LifecycleFsError("corrupt");
   }
-  return { metadata: metadata2, decoded };
+  return { metadata: metadata3, decoded };
 }
 function terminalOutcome(events) {
   const last = events.at(-1);
@@ -22120,7 +23551,7 @@ function canDeleteTerminalRun(runDir, runID, now) {
   return now >= lease.expiresAt;
 }
 var createFsLifecycleJournal = (options) => {
-  const configuredRoot = resolve11(options.root);
+  const configuredRoot = resolve13(options.root);
   const now = options.now ?? Date.now;
   const mutateRun = options.withMutationLock ?? withRunMutationLock;
   return {
@@ -22142,11 +23573,11 @@ var createFsLifecycleJournal = (options) => {
             throw error;
           }
         }
-        stagingPath = join15(root, `.start-${runID}-${randomUUID3()}`);
+        stagingPath = join15(root, `.start-${runID}-${randomUUID4()}`);
         mkdirSync3(stagingPath);
         const writerToken = issueWriterToken();
         const eventAt = now();
-        const metadata2 = parseLifecycleRunMetadata({
+        const metadata3 = parseLifecycleRunMetadata({
           ...parsedInput,
           version: 1,
           createdAt: eventAt
@@ -22162,7 +23593,7 @@ var createFsLifecycleJournal = (options) => {
           executionAuthority: parsedInput.executionAuthority,
           root: parsedInput.root
         });
-        writeDurable2(join15(stagingPath, METADATA_FILE), `${JSON.stringify(metadata2)}
+        writeDurable2(join15(stagingPath, METADATA_FILE), `${JSON.stringify(metadata3)}
 `);
         writeDurable2(join15(stagingPath, EVENTS_FILE), encodeLifecycleJournal([event]));
         writeDurable2(join15(stagingPath, OWNER_FILE2), `${JSON.stringify(lease)}
@@ -22178,7 +23609,7 @@ var createFsLifecycleJournal = (options) => {
         stagingPath = undefined;
         return ok({
           handle: { runID, writerToken },
-          metadata: metadata2,
+          metadata: metadata3,
           event,
           lease,
           head: 1
@@ -22501,8 +23932,8 @@ async function initSpanEmit(connection, config) {
   const tracer = provider.getTracer(DEFAULT_SERVICE_NAME);
   return (record) => {
     const span = tracer.startSpan(record.name);
-    for (const [key2, value] of Object.entries(record.attributes)) {
-      span.setAttribute(key2, value);
+    for (const [key3, value] of Object.entries(record.attributes)) {
+      span.setAttribute(key3, value);
     }
     span.end();
   };
@@ -22620,7 +24051,8 @@ var RELEASE_CERT_PATH = "artifacts/graph-release-certificate.json";
 var SOAK_CERT_PATH = "artifacts/graph-soak-certificate.json";
 async function readPackagedCertificate(path4) {
   try {
-    return await readFile5(new URL(`./certificates/${basename4(path4)}`, import.meta.url), "utf8");
+    const hostDirectory = basename4(dirname8(path4)) === NATIVE_CERTIFICATE_DIRECTORY ? `${NATIVE_CERTIFICATE_DIRECTORY}/` : "";
+    return await readFile5(new URL(`./certificates/${hostDirectory}${basename4(path4)}`, import.meta.url), "utf8");
   } catch {
     return;
   }
@@ -22752,8 +24184,8 @@ async function readOpencodeVersion(serverUrl, options = {}) {
 }
 var DEFAULT_OPENCODE_VERSION_BACKOFF_MS = [50, 250];
 function defaultSleep(ms) {
-  return new Promise((resolve12) => {
-    setTimeout(resolve12, ms);
+  return new Promise((resolve14) => {
+    setTimeout(resolve14, ms);
   });
 }
 function createLazyOpencodeVersionReader(serverUrl, options = {}) {
@@ -22796,9 +24228,10 @@ function createLazyOpencodeVersionReader(serverUrl, options = {}) {
   };
 }
 async function buildGateInput(config, storage, opencodeVersion, warn, packagedRead = readPackagedCertificate) {
-  const shadow = await readAndParseCertificate(storage, SHADOW_CERT_PATH, (raw) => parseShadowCertificate(raw, opencodeVersion), (cert) => shadowCertificateBindingDigest(cert.evidence), packagedRead);
+  const hostPath = (path4) => opencodeVersion === NATIVE_OPENCODE_VERSION ? `${dirname8(path4)}/${NATIVE_CERTIFICATE_DIRECTORY}/${basename4(path4)}` : path4;
+  const shadow = await readAndParseCertificate(storage, hostPath(SHADOW_CERT_PATH), (raw) => parseShadowCertificate(raw, opencodeVersion), (cert) => shadowCertificateBindingDigest(cert.evidence), packagedRead);
   const shadowDigest = shadow.status === "valid" ? shadow.digest : "0".repeat(64);
-  const release = await readAndParseCertificate(storage, RELEASE_CERT_PATH, (raw) => parseReleaseCertificate(raw, opencodeVersion, shadowDigest), (cert) => cert.digest, packagedRead);
+  const release = await readAndParseCertificate(storage, hostPath(RELEASE_CERT_PATH), (raw) => parseReleaseCertificate(raw, opencodeVersion, shadowDigest), (cert) => cert.digest, packagedRead);
   let soakLedgerDigest = "0".repeat(64);
   try {
     const recorderPorts = recorderPortsFromStorage(storage);
@@ -23053,14 +24486,17 @@ async function listConfiguredOpencodeInventory(ctx) {
     profiles: normalizeModelsDevCatalog(Object.fromEntries(providers.map((provider) => [provider.id, provider]))).filter((profile) => profile.costPer1M.inputUSD > 0 && profile.costPer1M.outputUSD > 0)
   };
 }
-var server = async (ctx, rawOptions) => {
+async function createPluginRuntime(ctx, rawOptions) {
   const now = () => Date.now();
   const diagnostics = createPluginDiagnosticChannel({
     client: ctx.client,
     directory: ctx.directory,
     now
   });
-  logOpencodeServerUrl(ctx.serverUrl, diagnostics.info("opencode-server-url", { persist: false, toast: false }));
+  const initialServerUrl = ctx.serverUrl();
+  if (initialServerUrl !== undefined) {
+    logOpencodeServerUrl(initialServerUrl, diagnostics.info("opencode-server-url", { persist: false, toast: false }));
+  }
   const storage = createFsStorageProvider(ctx.directory || ctx.worktree || process.cwd());
   const runtimeConfig = await loadRuntimeOpenTeamConfig(storage, rawOptions);
   const config = runtimeConfig.config;
@@ -23069,20 +24505,19 @@ var server = async (ctx, rawOptions) => {
   const registry = new RuntimeRegistry({
     fetch: globalThis.fetch,
     clock: () => new Date().toISOString(),
-    foundryDiscovery: foundryDiscoveryFromExec(createShellExec(ctx.$))
+    foundryDiscovery: foundryDiscoveryFromExec(ctx.exec)
   });
   const cache = createAvailabilityCache({
     config,
     registry,
-    ...ctx.client.config?.providers === undefined ? {} : {
-      listConfiguredInventory: () => listConfiguredOpencodeInventory(ctx)
-    },
+    ...ctx.listConfiguredInventory === undefined ? {} : { listConfiguredInventory: ctx.listConfiguredInventory },
     onRefreshError: (error) => logAvailabilityRefreshError(error, diagnostics.warn("availability-refresh-failed", { toast: false }))
   });
   let availabilityReady;
-  const ensureAvailability = () => {
+  const ensureAvailability = async () => {
     availabilityReady ??= cache.refresh();
-    return availabilityReady;
+    await availabilityReady;
+    await cache.waitForRefresh();
   };
   const capabilityProfiles = () => {
     const availableModelKeys = new Set(cache.get().filter((model) => model.available).map((model) => `${model.providerID}\x00${model.modelID}`));
@@ -23111,17 +24546,19 @@ var server = async (ctx, rawOptions) => {
   const injectMemory = await buildMemoryInjectorFromConfig(config, storage, diagnostics.warn("memory-runtime-warning", { toast: false }));
   const sessionTracker = createSessionTracker();
   const orchestratedModelOwnership = createOrchestratedModelOwnership();
-  const modelResidency = createModelResidencyGuard(config, {
+  const resolveAgentRole = async (agentName) => {
+    const entry = (await readRoutingRosterEntries(storage)).find((candidate) => candidate.agentName === agentName);
+    return entry?.roleID;
+  };
+  const residencyOptions = {
     fetch: globalThis.fetch,
-    ...ctx.client.config?.providers === undefined ? {} : {
+    resolveAgentRole,
+    ...ctx.listConfiguredInventory === undefined ? {} : {
       resolveApiModelID: cache.resolveApiModelID,
       modelInventoryReady: ensureAvailability
     }
-  });
-  const resolveAgentRole = async (agentName) => {
-    const entry = (await readRoutingRosterEntries(storage)).find((candidate) => candidate.agentName === agentName);
-    return entry?.roleID;
   };
+  const modelResidency = (ctx.createResidencyGuard ?? createModelResidencyGuard)(config, residencyOptions);
   const hooks = createHooks(config, cache.get, injectMemory === undefined ? {
     sink,
     modelResidency,
@@ -23140,10 +24577,12 @@ var server = async (ctx, rawOptions) => {
     resolveAgentRole,
     onRoute: (sid, model) => sessionTracker.trackRoutedModel(sid, model)
   });
-  const getOpencodeVersion = createLazyOpencodeVersionReader(ctx.serverUrl, {
+  const getOpencodeVersion = ctx.opencodeVersion ?? (initialServerUrl === undefined ? async () => {
+    throw new Error(nativeHostMessages.missingVersion);
+  } : createLazyOpencodeVersionReader(initialServerUrl, {
     client: ctx.client,
     onFailure: createOpencodeVersionReadFailureLogger(MAX_LOGGED_OPENCODE_VERSION_FAILURE_CAUSES, diagnostics.warn("opencode-version-read-failed", { toast: false }))
-  });
+  }));
   const cliDeps = createCliDeps(config, registry, telemetryPath, sessionsDir, storage, runtimeConfig.source, rawOptions, async () => {
     const version = await getOpencodeVersion();
     return version === "unknown" ? undefined : version;
@@ -23154,12 +24593,15 @@ var server = async (ctx, rawOptions) => {
     if (sessionID === undefined || announcedSessions.has(sessionID)) {
       return;
     }
-    announcedSessions.add(sessionID);
-    const endpoint = sessionEndpointEventFrom(sessionID, ctx.serverUrl, now, {
+    const serverUrl = ctx.serverUrl();
+    if (serverUrl === undefined)
+      return;
+    const endpoint = sessionEndpointEventFrom(sessionID, serverUrl, now, {
       directory: ctx.directory,
       worktree: ctx.worktree
     });
     if (endpoint !== undefined) {
+      announcedSessions.add(sessionID);
       sink.emit(endpoint);
     }
   };
@@ -23211,7 +24653,7 @@ var server = async (ctx, rawOptions) => {
     holder: "openteam-plugin",
     lifecycleSource: "plugin",
     lifecycleRecorder,
-    exec: createShellExec(ctx.$),
+    exec: ctx.exec,
     repoRoot: ctx.directory
   });
   const graphSurface = createGraphTool({
@@ -23247,8 +24689,8 @@ var server = async (ctx, rawOptions) => {
     rememberReportedSlots(snapshots);
     return reachableRuntimeIds(snapshots);
   };
-  const runtimeById = (key2) => {
-    const runtimeId = slotPoolRuntimeID(key2);
+  const runtimeById = (key3) => {
+    const runtimeId = slotPoolRuntimeID(key3);
     const runtime = config.local.runtimes.find((candidate) => candidate.id === runtimeId);
     if (runtime === undefined) {
       return;
@@ -23256,13 +24698,13 @@ var server = async (ctx, rawOptions) => {
     return withReportedModelSlots(runtime, reportedSlotsByRuntime.get(runtimeId), localModelAliases(runtime.defaultModel.providerID, cache.get()));
   };
   const runtimeLimiter = createRuntimeConcurrencyLimiter({
-    capacityFor: (key2) => {
-      const runtime = runtimeById(key2);
-      return runtime === undefined ? unknownPoolCapacity() : slotPoolCapacity(runtime, slotPoolModelID(key2));
+    capacityFor: (key3) => {
+      const runtime = runtimeById(key3);
+      return runtime === undefined ? unknownPoolCapacity() : slotPoolCapacity(runtime, slotPoolModelID(key3));
     },
-    reservedInteractiveFor: (key2) => {
-      const runtime = runtimeById(key2);
-      return runtime === undefined ? 0 : slotPoolReservedInteractive(runtime, slotPoolModelID(key2));
+    reservedInteractiveFor: (key3) => {
+      const runtime = runtimeById(key3);
+      return runtime === undefined ? 0 : slotPoolReservedInteractive(runtime, slotPoolModelID(key3));
     },
     now
   });
@@ -23289,8 +24731,8 @@ var server = async (ctx, rawOptions) => {
     lifecycleRecorder,
     abortGraceMs: DEFAULT_ABORT_GRACE_MS,
     statusPollMs: DEFAULT_STATUS_POLL_MS,
-    delay: (ms) => new Promise((resolve12) => {
-      setTimeout(resolve12, ms);
+    delay: (ms) => new Promise((resolve14) => {
+      setTimeout(resolve14, ms);
     }),
     warn: diagnostics.warn("unknown-role")
   });
@@ -23299,8 +24741,22 @@ var server = async (ctx, rawOptions) => {
     storage,
     now,
     localRuntimeReachable: async (runtime, signal) => {
+      if (localRuntimeKind(runtime) === "llama-swap") {
+        if (ctx.listConfiguredInventory !== undefined)
+          await ensureAvailability();
+        signal?.throwIfAborted();
+        const target = modelResidency.localTarget(resolveMemorySemantic(config).extraction.model ?? runtime.defaultModel);
+        const residency = await readLlamaSwapResidency(target.baseURL, globalThis.fetch, {
+          ...signal === undefined ? {} : { signal }
+        });
+        if (!residency.has(target.modelID))
+          throw new ModelResidencyError("identity", "llama-swap");
+        if (residency.get(target.modelID)?.loaded !== true)
+          throw new ModelResidencyError("inactive", "llama-swap");
+        return true;
+      }
       if (localRuntimeKind(runtime) === "lemonade") {
-        if (ctx.client.config?.providers !== undefined)
+        if (ctx.listConfiguredInventory !== undefined)
           await ensureAvailability();
         signal?.throwIfAborted();
         const target = modelResidency.localTarget(resolveMemorySemantic(config).extraction.model ?? runtime.defaultModel);
@@ -23315,7 +24771,7 @@ var server = async (ctx, rawOptions) => {
       return anyRuntimeReachable(snapshots);
     },
     resolveExtractionTarget: async (model) => {
-      if (ctx.client.config?.providers !== undefined)
+      if (ctx.listConfiguredInventory !== undefined)
         await ensureAvailability();
       return modelResidency.localTarget(model);
     },
@@ -23343,6 +24799,7 @@ var server = async (ctx, rawOptions) => {
     "chat.message": async (input, output) => {
       reload.userTurn(input.sessionID);
       await hooks["chat.message"]?.(input, output);
+      announceEndpoint(input.sessionID);
     },
     dispose: async () => {
       reload.dispose();
@@ -23350,7 +24807,7 @@ var server = async (ctx, rawOptions) => {
     },
     tool: {
       openteam: createCommandTool(cliDeps),
-      "openteam-console": createConsoleTool(),
+      "openteam-console": createConsoleTool(ctx.consoleEnvironment === undefined ? {} : { environment: ctx.consoleEnvironment }),
       "openteam-graph": graphSurface.definition,
       "openteam-orchestrate": orchestrateTool,
       "openteam-memory": memoryTool,
@@ -23387,10 +24844,21 @@ var server = async (ctx, rawOptions) => {
       }
     }
   };
-};
+}
+var server = (ctx, rawOptions) => createPluginRuntime({
+  directory: ctx.directory,
+  worktree: ctx.worktree,
+  client: ctx.client,
+  exec: createShellExec(ctx.$),
+  serverUrl: () => ctx.serverUrl,
+  ...ctx.client.config?.providers === undefined ? {} : {
+    listConfiguredInventory: () => listConfiguredOpencodeInventory(ctx)
+  }
+}, rawOptions);
 var plugin = {
   id: "openteam",
-  server
+  server,
+  effect: createNativePluginEffect(createPluginRuntime)
 };
 var src_default = plugin;
 export {
@@ -23408,6 +24876,7 @@ export {
   isMissingFile2 as isMissingFile,
   evaluateCutoverGateForBoundary,
   src_default as default,
+  createPluginRuntime,
   createOpencodeVersionReadFailureLogger,
   createLazyOpencodeVersionReader,
   createEventSink,