@jmanuelcorral/openteam 0.26.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.",
@@ -5757,7 +5760,7 @@ import { z as z15 } from "zod";
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.26.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",
@@ -5817,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",
@@ -5844,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: {
@@ -6363,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 = `*
@@ -6417,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) {
@@ -6629,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;
@@ -6676,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);
@@ -6742,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;
   }
@@ -6769,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);
@@ -7043,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,
@@ -7114,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,
@@ -7123,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 {
@@ -7860,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]+/, "");
@@ -7894,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}$/);
@@ -10987,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.";
@@ -11967,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);
@@ -13801,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";
@@ -15595,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";
@@ -15605,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";
@@ -15906,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;
@@ -15982,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;
@@ -16017,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, {
@@ -16135,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,
@@ -18037,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);
@@ -18092,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)
   };
 }
@@ -19243,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;
@@ -19722,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",
@@ -20148,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;
@@ -20539,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",
@@ -20547,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;
@@ -20617,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;
       }
@@ -20634,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;
       }
@@ -20646,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());
       }
@@ -21185,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);
@@ -21292,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";
@@ -21408,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,
@@ -21435,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,
@@ -21521,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)"];
   });
@@ -21573,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) => {
@@ -21647,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;
@@ -21681,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;
@@ -21829,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)
@@ -21975,7 +22894,7 @@ function createSessionTracker() {
 }
 
 // src/plugin/toolcalls.ts
-function key(sessionID, callID) {
+function key2(sessionID, callID) {
   return `${sessionID}\x00${callID}`;
 }
 function createToolcallTracker(deps) {
@@ -21983,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();
@@ -22196,7 +23115,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
 }
 
 // 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,
@@ -22206,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)) {
@@ -22230,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)}`);
@@ -22308,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,
@@ -22325,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 {
@@ -22349,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()) {
@@ -22392,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;
@@ -22441,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);
@@ -22464,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");
@@ -22533,7 +23452,7 @@ function parseJson(text, parse2) {
   }
 }
 function issueWriterToken() {
-  return randomUUID3().replaceAll("-", "");
+  return randomUUID4().replaceAll("-", "");
 }
 function createLease(runID, writerToken, input) {
   return parseLifecycleWriterLease({
@@ -22632,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 {
@@ -22654,7 +23573,7 @@ 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();
@@ -23013,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();
   };
@@ -23132,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;
   }
@@ -23264,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 = {}) {
@@ -23308,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);
@@ -23565,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;
@@ -23581,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}`));
@@ -23623,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,
@@ -23652,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;
@@ -23666,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);
     }
   };
@@ -23723,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({
@@ -23759,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;
@@ -23768,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
   });
@@ -23801,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")
   });
@@ -23812,7 +24742,7 @@ var server = async (ctx, rawOptions) => {
     now,
     localRuntimeReachable: async (runtime, signal) => {
       if (localRuntimeKind(runtime) === "llama-swap") {
-        if (ctx.client.config?.providers !== undefined)
+        if (ctx.listConfiguredInventory !== undefined)
           await ensureAvailability();
         signal?.throwIfAborted();
         const target = modelResidency.localTarget(resolveMemorySemantic(config).extraction.model ?? runtime.defaultModel);
@@ -23826,7 +24756,7 @@ var server = async (ctx, rawOptions) => {
         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);
@@ -23841,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);
     },
@@ -23869,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();
@@ -23876,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,
@@ -23913,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 {
@@ -23934,6 +24876,7 @@ export {
   isMissingFile2 as isMissingFile,
   evaluateCutoverGateForBoundary,
   src_default as default,
+  createPluginRuntime,
   createOpencodeVersionReadFailureLogger,
   createLazyOpencodeVersionReader,
   createEventSink,