@jmanuelcorral/openteam 0.23.0 → 0.24.1

package/dist/index.js

@@ -4103,6 +4103,28 @@ import { z as z13 } from "zod";
 // src/telemetry/events.ts
 import { z as z11 } from "zod";
 
+// src/messages/reload.ts
+var reloadMessages = {
+  description: "Queue a project-instance reload only after the user explicitly answers the fresh /create_roster reload question affirmatively. General tool approval, YOLO and earlier project-description answers are not consent. End this turn after queuing; do not dispatch work. Cancel withdraws a pending request.",
+  action: "Request a confirmed reload or cancel this session's queued request.",
+  confirmed: "True only for an unambiguous affirmative human answer to the current reload question, after successful preparation and the full Agent/Role/Model and file summaries. This field records consent; it does not independently prove a human answered.",
+  invalid: "Reload not queued: provide only action (request or cancel) and explicit boolean confirmed. No target directory or other arguments are accepted.",
+  declined: "Reload not queued: explicit affirmative consent to the current reload question is required. No files or policies were changed.",
+  denied: "Reload is restricted to the openteam primary in this plugin's project.",
+  closed: "This reload controller is no longer active. Check the current opencode instance before requesting another reload; agent discovery has not been verified.",
+  other: "A reload request is already pending for another session. This call does not replace or extend its confirmation.",
+  authorizing: "Host permission for this project's reload is still pending. This call queues nothing and does not extend the confirmation deadline.",
+  none: "There is no queued reload for this session to cancel.",
+  "reload-queued": "Reload queued, not completed. Waiting up to 30 seconds for this tool and confirming turn to finish and for all project sessions to be idle. End this turn now; no project work or agent readiness is implied.",
+  "reload-waiting": "Reload is still waiting: project sessions are busy or retrying. They will not be aborted; the original 30-second deadline is unchanged.",
+  "reload-accepted": "opencode accepted the project-instance reload request. Agent discovery and readiness have not been verified; existing discovery safeguards still apply.",
+  "reload-cancelled": "The pending reload was cancelled before disposal was requested. Prepared files, history and policies are unchanged.",
+  "reload-timeout": "Reload was not requested: the 30-second idle deadline expired. A new explicit confirmation is required; nothing will retry automatically.",
+  "reload-status-failed": "Reload was not requested: project activity was missing, malformed, unavailable or did not respond within 5 seconds. No idle state was assumed and no automatic retry is armed.",
+  "reload-dispose-failed": "opencode did not confirm acceptance of the reload request. No automatic retry is armed; check the current instance before trying again. Agent readiness is unverified.",
+  "reload-unconfirmed": "Reload acceptance is unconfirmed because the request timed out, was cancelled or the instance was disposed while it was in flight. The host may still finish it; no automatic retry is armed. Check the current instance and agent discovery."
+};
+
 // src/telemetry/diagnostics.ts
 var DIAGNOSTIC_CODES = [
   "availability-refresh-failed",
@@ -4115,6 +4137,14 @@ var DIAGNOSTIC_CODES = [
   "opencode-server-url",
   "opencode-version-read-failed",
   "privacy-inert",
+  "reload-queued",
+  "reload-waiting",
+  "reload-accepted",
+  "reload-cancelled",
+  "reload-timeout",
+  "reload-status-failed",
+  "reload-dispose-failed",
+  "reload-unconfirmed",
   "soak-evidence-rejected",
   "telemetry-warning",
   "telemetry-write-failed",
@@ -4142,6 +4172,15 @@ function diagnosticDescription(code) {
       return "openteam could not read the live opencode version; graph gates fail closed when this happens.";
     case "privacy-inert":
       return routingMessages.privacyModeDeprecated;
+    case "reload-queued":
+    case "reload-waiting":
+    case "reload-accepted":
+    case "reload-cancelled":
+    case "reload-timeout":
+    case "reload-status-failed":
+    case "reload-dispose-failed":
+    case "reload-unconfirmed":
+      return reloadMessages[code];
     case "soak-evidence-rejected":
       return "Graph soak evidence contained rejected observation lines; cutover gate evidence may be incomplete.";
     case "telemetry-warning":
@@ -4894,6 +4933,48 @@ function withDeterministicGitLocale(env) {
   };
 }
 
+// src/opencodeArtifacts/createRosterReload.ts
+var CREATE_ROSTER_RELOAD_INSTRUCTIONS = [
+  "## Reload confirmation — /create_roster only",
+  "",
+  "Only after successful persisted registration and verified agent files may you offer reload:",
+  "read back the parseable persisted roster, including guaranteed roles; actually create each missing",
+  "subagent file and verify every required existing or created file.",
+  "First show the complete Agent/Role/Model table returned by `openteam-register-cast`,",
+  "including primary, guaranteed and preserved agents with their unchanged tool-returned policy values.",
+  "Then show the created-versus-preserved file summary and any warnings. Both must be visible",
+  "BEFORE asking a fresh explicit reload question in this opencode conversation.",
+  "If registration, file creation or verification failed or is partial, do not ask the reload question:",
+  "report the exact blocker and do not claim readiness. If registration succeeded, still show its",
+  "complete table even when file preparation later fails.",
+  "",
+  "Ask whether to reload this project's opencode agent definitions now, explaining the request is",
+  "queued/waiting until the requesting turn completes and all project sessions are idle.",
+  "Use the host question tool when available; otherwise ask a normal conversational question",
+  "in opencode and WAIT for the user's answer. Never use a terminal wizard, tool permission",
+  "approval or YOLO permission as reload consent. A greenfield project-description reply is NOT reload consent.",
+  "Only an explicit affirmative answer to this specific reload question authorizes",
+  '`openteam-reload` with `{ action: "request", confirmed: true }`.',
+  "False, no, cancel, an ambiguous answer or no reply means no reload request.",
+  "A decline before anything is queued needs no tool call; do not turn ambiguity into confirmation.",
+  "To cancel an already queued request at the user's direction, use",
+  '`openteam-reload` with `{ action: "cancel", confirmed: false }` and report its actual result.',
+  "",
+  "This internal tool is restricted to the product primary `openteam` and its bound project.",
+  "Do not supply a directory, project, session or other model-selected target.",
+  "Report queued/waiting honestly and end the confirming turn immediately.",
+  "Do not await your own idle state, poll or hold the turn open. Do not start work or call",
+  "`task` or `openteam-orchestrate`; do not rewrite/recast files or change models, permissions",
+  "or execution policies. The idle wait has a finite timeout; surface timeout and failure results",
+  "when the runtime reports them, including rejected requests, rather than promising success or silently retrying.",
+  "SDK acceptance is not verified discovery or readiness. Preserve all existing discovery guards:",
+  "if new agents remain undiscovered, surface the reload/discovery blocker;",
+  "do not dispatch through a generic substitute or claim readiness.",
+  "This workflow and all its replies remain composition only. After completion, decline or cancellation,",
+  "wait for a separate work request; neither a reload answer nor queued acceptance starts project work."
+].join(`
+`);
+
 // src/opencodeArtifacts/rosterSummary.ts
 var ROSTER_SUMMARY_INSTRUCTIONS = [
   "After every successful cast creation, repair or extension, show the complete Agent/Role/Model table",
@@ -4926,6 +5007,20 @@ var TEAM_PREPARATION_INSTRUCTIONS = [
   "machine bindings stay unchanged; do not require a terminal or manually edit policy to finish hiring.",
   "Never infer execution domains from prose, relax permissions, or invent a concrete auto model.",
   "Registration/review is idempotent: a capable configured team needs no extra members or file rewrites.",
+  "`agentName`, not `roleID`, determines each worker filename.",
+  "Create `.opencode/agent/<agentName>.md` only for registered roster entries.",
+  "A built-in role profile is not an extra agent.",
+  "Do not create a parallel `<roleID>.md` when the roster maps that role to another alias.",
+  "An existing roster alias equal to its roleID is still valid; do not rename it.",
+  "Do not run `openteam setup` to hire workers or repair their files.",
+  "Preserve unrelated and legacy generic files; do not delete, overwrite or silently register them.",
+  "Registration writes roster/profile state, not worker Markdown.",
+  "Report only verified file changes; do not call pre-existing files newly created.",
+  "When creating a scribe worker, put the following memory instructions in its charter:",
+  "Use `openteam-memory` for durable, reusable facts, entities and typed relations.",
+  "Send only redacted knowledge messages, never raw conversations, prompts or credentials.",
+  "Honor operator permissions and memory settings; do not broaden them.",
+  "A disabled-memory or nothing-recorded result is expected; do not retry it.",
   "Create only missing agent definitions; preserve customized files. Show the registration table",
   "and verify preparation before dispatch. If opencode cannot discover a new agent, surface",
   "the reload/discovery blocker; do not dispatch through a generic substitute or claim readiness."
@@ -4967,33 +5062,43 @@ function buildOrchestratorAgent(model, options = {}) {
     "primary agent: there is no pre-created team. You **build the team of",
     "subagents on demand** according to the goal of the user and the repository.",
     "",
-    "## Golden rule: check the team on EVERY request",
-    "",
-    "Before answering or delegating **any** request, your **first action",
-    "always** is to check whether a team already exists, even if the user does not",
-    "explicitly ask you to create it. Never assume there is a team or that there is not:",
-    `verify it by looking at \`${OPENTEAM_ROSTER_PATH}\` and the \`.opencode/agent/*.md\``,
-    "files with `mode: subagent` (use `read`/`glob`/`list`).",
-    "",
-    ROSTER_SUMMARY_INSTRUCTIONS,
-    "",
-    TEAM_PREPARATION_INSTRUCTIONS,
-    "",
     "## Roster composition takes precedence",
     "",
     "For `/create_roster`, including replies to its pending questions, follow",
     "the command's roster-only workflow: do not distribute tasks or start implementation.",
+    "These rules override the ordinary golden rule and capability checks below.",
+    "A bare yes to a pending reload question continues only reload confirmation:",
+    "do not restart roster reads, capability preparation or registration.",
     "Reuse or conservatively extend the existing cast and preserve customized agent files.",
     "Use a supplied description; otherwise inspect real project source read-only.",
     "If there is no meaningful source and no description, ask what the user wants to",
     "build in this conversation and wait before any writes or cast registration.",
     "Register through `openteam-register-cast`, create missing subagent files, verify",
-    "the persisted roster and files, then stop. Do not call `openteam-orchestrate` or",
+    "the persisted roster and files, then follow the reload confirmation below.",
+    "Do not call `openteam-orchestrate` or",
     "`task` for this workflow. A later answer to your question continues composition",
     "only until it completes or the user cancels; it is not an implementation request.",
     "",
+    CREATE_ROSTER_RELOAD_INSTRUCTIONS,
+    "",
+    "## Golden rule: check the team on EVERY request",
+    "",
+    "The roster composition and pending reload-reply rules above take precedence.",
+    "Before answering or delegating **any ordinary work** request, your **first action",
+    "always** is to check whether a team already exists, even if the user does not",
+    "explicitly ask you to create it. Never assume there is a team or that there is not:",
+    `verify it by looking at \`${OPENTEAM_ROSTER_PATH}\` and the \`.opencode/agent/*.md\``,
+    "files with `mode: subagent` (use `read`/`glob`/`list`).",
+    "",
+    ROSTER_SUMMARY_INSTRUCTIONS,
+    "",
+    TEAM_PREPARATION_INSTRUCTIONS,
+    "",
     "## For work requests, including analysis, review and documentation",
     "",
+    "Ordinary automatic hiring must NOT ask for reload or automatically reset the project.",
+    "If discovery is blocked, surface the blocker and preserve the discovery guards instead.",
+    "",
     "- **If the team ALREADY exists** → review capability coverage, reuse suitable",
     "  members and extend only for uncovered needs. Complete any existing member's",
     "  profile through `openteam-register-cast`; do not hire for a configuration gap.",
@@ -5368,8 +5473,10 @@ function buildCreateRosterCommand() {
     "required agent file exists. If anything failed, report the incomplete state and exact",
     "blocker; do not delete preserved state or claim the team is ready.",
     "Summarize the cast, role rationale/evidence, preserved versus newly created files, and",
-    "any warnings. New subagents may require an opencode reload before discovery.",
-    "Stop after composition; wait for a separate request before starting project work.",
+    "any warnings. Continue only to the reload confirmation below, including its pending replies;",
+    "do not restart preparation when the user answers that reload question.",
+    "",
+    CREATE_ROSTER_RELOAD_INSTRUCTIONS,
     "",
     "## Project description (user input)",
     "",
@@ -5636,7 +5743,7 @@ import { z as z15 } from "zod";
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.23.0",
+  version: "0.24.1",
   packageManager: "bun@1.3.14",
   description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
   license: "MIT",
@@ -5993,6 +6100,25 @@ var executionSetupMessages = {
 `),
   localOnlyTitle: "Local execution",
   localRequiredError: "local execution requires an enabled local runtime",
+  lemonadeDetectedHint: (loaded, advertised) => `detected - ${loaded} confirmed loaded of ${advertised} advertised text model(s)`,
+  lemonadeNoLoadedModels: "Lemonade has no text models verified as loaded and ready. Keep the intended model active in Lemonade and rerun setup; inactive or unknown models cannot be selected or entered manually.",
+  lemonadeModelNotLoaded: (model) => `Lemonade model "${model}" is not positively verified as loaded and ready. Keep that exact text model active and rerun setup; no substitute was selected and no implicit loading is allowed.`,
+  lemonadeProbeRequired: "Lemonade setup requires a fresh read-only residency probe before writing configuration. Use the CLI with its runtime probe enabled; manual model IDs cannot bypass this requirement.",
+  lemonadeProbeFailed: "Lemonade residency could not be verified at the configured endpoint. Check connectivity and the read-only /models, /health, and /internal/aliases responses, then rerun setup with the intended text models already active.",
+  lemonadeEndpointMismatch: "Lemonade endpoint/provider mapping differs from the selected runtime. Reconcile the configured base URL and provider before rerunning setup; no model was substituted.",
+  lemonadeModelIdentityUnknown: (model) => `Lemonade model "${model}" has no usable registered wire identity in the effective opencode configuration. Fix its model declaration before rerunning setup; setup will not replace or guess an alias.`,
+  lemonadeEffectiveConfigLabel: "effective setup configuration",
+  lemonadeEffectiveConfigAmbiguous: "Cannot establish one effective openteam configuration from the configured plugin loaders. Reconcile their options before rerunning setup; no provider identity was guessed.",
+  lemonadeRetainedProviderUnprotected: (providerID) => `Cannot safely keep retained Lemonade provider "${providerID}": the effective configuration must retain one matching Lemonade runtime, disabled when deselected. Reconcile the plugin options or machine overlay, or explicitly remove the provider registration before rerunning setup; no configuration was written.`,
+  lemonadeV2InvalidProvider: (providerID) => `Lemonade provider ${JSON.stringify(providerID)} cannot be represented as an exact native V2 policy resource. Choose a non-empty provider ID without wildcards, slashes, backslashes, or whitespace; setup will not broaden a deny rule.`,
+  lemonadeV2InvalidPolicies: "Cannot safely preserve experimental.policies: experimental must be an object and policies must be an array of provider.use statements with a string resource and allow/deny effect. Fix the project configuration before rerunning setup.",
+  lemonadeV2Title: "Lemonade transport compatibility",
+  lemonadeV2Restriction: (providers) => `Project policies disable native V2 Lemonade access for: ${providers.join(", ")}. Ordinary guarded V1 configuration remains supported; V2 is not an openteam-hook execution path. Higher-precedence or global policies can override this project restriction; it is not a server-atomic no-autoload guarantee.`,
+  lemonadeInventory: (instanceID, providerID, models) => {
+    const inventory = models.map((model) => `${model.modelID} (${model.loaded === true ? "loaded" : model.loaded === false ? "inactive" : "residency unknown"})`).join(", ");
+    return `Lemonade inventory ${instanceID} (provider ${providerID}): ${inventory || "no advertised text models"}. Only confirmed loaded text models count as ready.`;
+  },
+  lemonadeAgentResidency: (agent, model, state) => `Lemonade readiness: ${agent} (${model}): ${state === "not-loaded" ? "inactive (not ready)" : "residency unknown"}; advertised inventory is not loaded readiness. Keep this exact model active and verify residency before use; requests without verified readiness are blocked.`,
   mixedPrimaryQuestion: "Primary coordinator model",
   mixedPrimaryLocal: (model) => `Use local thinking model ${model}`,
   mixedPrimaryFrontier: "Choose a frontier model",
@@ -6015,12 +6141,14 @@ var executionSetupMessages = {
     `Local runtimes: ${params.localRuntimes}`,
     `YOLO mode: ${params.yolo ? "enabled (auto-approves permissions)" : "disabled"}`,
     "Web Console: launched separately with 'openteam console' (multi-session, loopback)",
-    `Wrote: ${params.opencodePath}, ${params.configPath}, ${params.agentPath}, ${params.agentDir}/*.md (${params.roleAgentCount} standard subagents), ${params.commandDir}/*.md (${params.commandCount} commands); ensured ${params.gitignorePath}`,
+    `Wrote: ${params.opencodePath}, ${params.configPath}, ${params.agentPath}, ${params.commandDir}/*.md (${params.commandCount} commands); ensured ${params.gitignorePath}`,
+    "Worker files are created through conversational roster preparation, not setup; existing worker files were left untouched.",
     "",
     "Next steps:",
     params.executionMode === "local" ? "  1. No frontier authentication is required while local execution is active" : "  1. Authenticate the frontier provider: opencode auth login",
     params.executionMode === "local" ? executionSetupMessages.localRuntimeNextStep : params.executionMode === "mixed" ? executionSetupMessages.mixedNextStep : executionSetupMessages.frontierNextStep,
-    "  3. Press Tab and pick the 'openteam' agent, or type / and pick an /openteam… command"
+    "  3. Press Tab and pick the 'openteam' agent, or type / and pick an /openteam… command",
+    "  4. Use /create_roster to compose the team without starting project work, or describe a task to prepare the team and begin work"
   ],
   configuredTitle: "openteam configured",
   complete: (paths) => `openteam setup complete: ${paths}`,
@@ -9822,6 +9950,243 @@ 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",
+  destination: "the request destination does not match its configured runtime",
+  transport: "this provider execution path cannot enforce the residency guard",
+  request: "this is not a supported, explicit model inference request",
+  cancelled: "the request was cancelled before residency could be verified",
+  timeout: "the residency metadata deadline expired",
+  configuration: "the residency guard configuration is invalid"
+};
+var modelResidencyMessages = {
+  blocked: (reason) => `[openteam] Lemonade model request blocked: ${reasons[reason]}.`,
+  providerDisabled: (providerID) => `[openteam] Lemonade provider "${providerID}" is disabled because its configured transport or runtime mapping cannot enforce loaded-only requests.`,
+  extractionRuntimeUnavailable: "[openteam] Memory extraction requires one enabled local runtime matching the configured extraction provider."
+};
+
+// src/local/lemonadeResidency.ts
+class ModelResidencyError extends Error {
+  code;
+  statusCode = 400;
+  isRetryable = false;
+  constructor(code) {
+    super(modelResidencyMessages.blocked(code));
+    this.code = code;
+    this.name = "ModelResidencyError";
+  }
+}
+var modelName = z19.string().min(1).refine((name) => name === name.trim());
+var LoadedModelSchema = z19.object({
+  model_name: modelName,
+  loaded: z19.boolean().optional(),
+  status: z19.string().optional(),
+  backend_alive: z19.boolean().optional(),
+  backend_health: z19.string().optional(),
+  watchdog_reset: z19.boolean().optional(),
+  watchdog_reset_reason: z19.string().optional(),
+  residency_class: z19.string().optional(),
+  slot_pool: z19.string().optional(),
+  checkpoint: z19.string().optional(),
+  type: z19.string().optional(),
+  device: z19.string().optional(),
+  backend_url: z19.string().optional(),
+  pid: z19.number().int().optional(),
+  launch_command: z19.unknown().optional(),
+  pinned: z19.boolean().optional(),
+  recipe: z19.string().optional(),
+  recipe_options: z19.unknown().optional(),
+  is_busy: z19.boolean().optional(),
+  is_streaming: z19.boolean().optional(),
+  max_context_window: z19.number().optional(),
+  cost_input_per_million: z19.number().optional(),
+  cost_output_per_million: z19.number().optional(),
+  last_use: z19.number().optional()
+}).strict();
+var TelemetrySchema = z19.object({
+  enabled: z19.boolean(),
+  captures: z19.array(z19.string()).optional()
+}).strict();
+var HealthSchema = z19.object({
+  status: z19.literal("ok"),
+  all_models_loaded: z19.array(LoadedModelSchema),
+  version: z19.string().optional(),
+  model_loaded: z19.string().nullable().optional(),
+  telemetry: TelemetrySchema.optional(),
+  max_models: z19.record(z19.string(), z19.number().int()).optional(),
+  pinned_models: z19.record(z19.string(), z19.number().int()).optional(),
+  pinned_helper_models: z19.record(z19.string(), z19.number().int()).optional(),
+  websocket_port: z19.number().int().optional(),
+  update_check_done: z19.boolean().optional()
+}).strict();
+var AliasSchema = z19.object({
+  alias: modelName,
+  target: modelName,
+  downloaded: z19.boolean().optional(),
+  recipe: z19.string().optional()
+}).strict();
+var AliasesSchema = z19.object({
+  aliases: z19.array(AliasSchema)
+}).strict();
+var MetadataRecordSchema = z19.record(z19.string(), z19.unknown());
+var inactiveStates = new Set([
+  "loading",
+  "downsizing",
+  "downsized",
+  "evicting",
+  "unloaded"
+]);
+var inactiveHealth = new Set(["stopped", "exited", "watchdog_reset"]);
+var standardPools = new Set([
+  "standard/llm",
+  "standard/embedding",
+  "standard/reranking",
+  "standard/transcription",
+  "standard/image",
+  "standard/tts",
+  "standard/audio-generation",
+  "standard/classification",
+  "standard/mesh"
+]);
+function usableState(entry) {
+  if (entry.loaded === false || entry.backend_alive === false || entry.watchdog_reset === true || typeof entry.status === "string" && inactiveStates.has(entry.status) || typeof entry.backend_health === "string" && inactiveHealth.has(entry.backend_health) || entry.residency_class === "routing_helper" || typeof entry.slot_pool === "string" && entry.slot_pool.startsWith("routing_helper/")) {
+    return false;
+  }
+  if (entry.loaded !== true || entry.backend_alive !== true || entry.watchdog_reset !== false || entry.status !== "ready" && entry.status !== "in_use" || entry.backend_health !== "ready" && entry.backend_health !== "busy" || entry.watchdog_reset_reason !== undefined && entry.watchdog_reset_reason !== "" || entry.residency_class !== undefined && entry.residency_class !== "standard" || entry.slot_pool !== undefined && (typeof entry.slot_pool !== "string" || !standardPools.has(entry.slot_pool))) {
+    return;
+  }
+  return true;
+}
+function projectMetadataObject(payload, keys) {
+  const record = MetadataRecordSchema.safeParse(payload);
+  if (!record.success)
+    throw new ModelResidencyError("unknown");
+  return Object.fromEntries(keys.filter((key) => Object.hasOwn(record.data, key)).map((key) => [key, record.data[key]]));
+}
+function parseResidency(healthPayload, aliasPayload) {
+  const healthFields = projectMetadataObject(healthPayload, Object.keys(HealthSchema.shape));
+  if (Array.isArray(healthFields.all_models_loaded)) {
+    healthFields.all_models_loaded = healthFields.all_models_loaded.map((entry) => projectMetadataObject(entry, Object.keys(LoadedModelSchema.shape)));
+  }
+  if (healthFields.telemetry !== undefined) {
+    healthFields.telemetry = projectMetadataObject(healthFields.telemetry, Object.keys(TelemetrySchema.shape));
+  }
+  const aliasFields = projectMetadataObject(aliasPayload, Object.keys(AliasesSchema.shape));
+  if (Array.isArray(aliasFields.aliases)) {
+    aliasFields.aliases = aliasFields.aliases.map((entry) => projectMetadataObject(entry, Object.keys(AliasSchema.shape)));
+  }
+  const health = HealthSchema.safeParse(healthFields);
+  const aliases = AliasesSchema.safeParse(aliasFields);
+  if (!health.success || !aliases.success)
+    throw new ModelResidencyError("unknown");
+  const result = new Map;
+  for (const entry of health.data.all_models_loaded) {
+    if (result.has(entry.model_name))
+      throw new ModelResidencyError("unknown");
+    result.set(entry.model_name, {
+      loaded: entry.model_name.endsWith(":latest") ? undefined : usableState(entry),
+      metadata: entry
+    });
+  }
+  const seenAliases = new Set;
+  for (const entry of aliases.data.aliases) {
+    if (seenAliases.has(entry.alias))
+      throw new ModelResidencyError("unknown");
+    seenAliases.add(entry.alias);
+    result.set(entry.alias, {
+      loaded: undefined,
+      metadata: result.get(entry.alias)?.metadata ?? {}
+    });
+  }
+  return result;
+}
+function lemonadeBaseURL(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ModelResidencyError("destination");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !/^\/(?:api\/)?v[01]\/?$/.test(url.pathname)) {
+    throw new ModelResidencyError("destination");
+  }
+  return `${url.origin}${url.pathname.replace(/\/$/, "")}`;
+}
+async function withResidencyDeadline(operation, options) {
+  const timeoutMs = options.timeoutMs ?? 5000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new ModelResidencyError("configuration");
+  }
+  const controller = new AbortController;
+  const cancel = () => controller.abort(new ModelResidencyError("cancelled"));
+  if (options.signal?.aborted)
+    throw new ModelResidencyError("cancelled");
+  options.signal?.addEventListener("abort", cancel, { once: true });
+  const schedule = options.scheduleTimeout ?? ((callback, 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) {
+  signal.throwIfAborted();
+  let payload;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal,
+      redirect: "error",
+      cache: "no-store"
+    });
+    signal.throwIfAborted();
+    if (!response.ok || response.redirected || response.url !== "" && response.url !== url) {
+      throw new ModelResidencyError("unknown");
+    }
+    payload = await response.json();
+  } catch {
+    signal.throwIfAborted();
+    throw new ModelResidencyError("unknown");
+  }
+  signal.throwIfAborted();
+  return payload;
+}
+async function readLemonadeResidency(baseURL, fetch, options = {}) {
+  const base = lemonadeBaseURL(baseURL);
+  const headers = new Headers(options.headers);
+  headers.delete("content-type");
+  headers.delete("content-length");
+  headers.set("accept", "application/json");
+  headers.set("cache-control", "no-cache, no-store");
+  headers.delete("if-none-match");
+  headers.delete("if-modified-since");
+  return withResidencyDeadline(async (signal) => {
+    const aliases = await metadata(`${new URL(base).origin}/internal/aliases`, fetch, signal, headers);
+    const health = await metadata(`${base}/health`, fetch, signal, headers);
+    return parseResidency(health, aliases);
+  }, options);
+}
+
 // src/local/lemonade.ts
 var LEMONADE_DEFAULT_BASE_URL = "http://localhost:13305/api/v1";
 var NON_TEXT_LABELS = new Set([
@@ -9908,36 +10273,19 @@ function isNonTextModel(entry) {
   return entry.labels.some((label) => typeof label === "string" && NON_TEXT_LABELS.has(label));
 }
 async function readLoadedModels(baseURL, fetch) {
-  let payload;
   try {
-    const response = await fetch(`${baseURL}/health`, {
-      method: "GET",
-      headers: { accept: "application/json" }
-    });
-    if (!response.ok) {
-      return;
-    }
-    payload = await response.json();
+    const residency = await readLemonadeResidency(baseURL, fetch);
+    return new Map([...residency].map(([name, entry]) => [
+      name,
+      {
+        loaded: entry.loaded,
+        slots: entry.loaded === true ? readSlotCount(entry.metadata) : undefined,
+        totalContextWindow: entry.loaded === true ? readLoadedContextWindow(entry.metadata) : undefined
+      }
+    ]));
   } catch {
     return;
   }
-  if (!isObject2(payload) || !Array.isArray(payload.all_models_loaded)) {
-    return;
-  }
-  const loaded = new Map;
-  for (const entry of payload.all_models_loaded) {
-    if (!isObject2(entry) || typeof entry.model_name !== "string") {
-      continue;
-    }
-    if (entry.loaded === false) {
-      continue;
-    }
-    loaded.set(entry.model_name, {
-      slots: readSlotCount(entry),
-      totalContextWindow: readLoadedContextWindow(entry)
-    });
-  }
-  return loaded;
 }
 function readSlotCount(entry) {
   return slotsFromLlamacppArgs(entry) ?? slotsFromLaunchCommand(entry);
@@ -10084,6 +10432,9 @@ function enrichWithLoadState(models, loaded) {
     if (hit === undefined) {
       return { ...base, loaded: false };
     }
+    if (hit.loaded !== true) {
+      return hit.loaded === false ? { ...base, loaded: false } : base;
+    }
     const contextWindow = derivedConservativeContextWindow(model.contextWindow, hit);
     return {
       ...base,
@@ -10227,6 +10578,14 @@ function reportedModelSlotsByRuntime(snapshots) {
 }
 
 // src/local/slotPool.ts
+function localModelAliases(providerID, models) {
+  const aliases = new Map;
+  for (const model of models ?? []) {
+    if (model.kind === "local" && model.providerID === providerID && model.runtimeModelID !== undefined && model.runtimeModelID !== model.modelID)
+      aliases.set(model.modelID, model.runtimeModelID);
+  }
+  return aliases;
+}
 var POOL_SEPARATOR = "::";
 function slotPoolKey(runtime, modelID) {
   if (modelID === undefined) {
@@ -10256,13 +10615,20 @@ function slotPoolReservedInteractive(runtime, modelID) {
 function unknownPoolCapacity() {
   return DEFAULT_LOCAL_MAX_CONCURRENCY;
 }
-function withReportedModelSlots(runtime, reported) {
-  if (reported === undefined || Object.keys(reported).length === 0) {
+function withReportedModelSlots(runtime, reported, aliases) {
+  const configured = Object.entries(runtime.modelConcurrency ?? {});
+  const hasAliasLimits = configured.some(([modelID]) => aliases?.has(modelID) === true);
+  if (!hasAliasLimits && (reported === undefined || Object.keys(reported).length === 0)) {
     return runtime;
   }
+  const explicit = new Map;
+  for (const [modelID, limit] of configured) {
+    const physicalID = aliases?.get(modelID) ?? modelID;
+    explicit.set(physicalID, Math.min(explicit.get(physicalID) ?? limit, limit));
+  }
   return {
     ...runtime,
-    modelConcurrency: { ...reported, ...runtime.modelConcurrency }
+    modelConcurrency: { ...reported, ...Object.fromEntries(explicit) }
   };
 }
 
@@ -10294,8 +10660,11 @@ var UNAUTHORIZED_MODEL_SWITCH_REASON = "routing-model-switch-not-authorized";
 function invalidRoleIdentifier(roleID) {
   return `invalid role identifier "${roleID}" — use letters, numbers, underscores, or hyphens, starting with a letter or number`;
 }
+function agentPreparationRemedy(agentName) {
+  return "Use `/create_roster` in opencode to complete the missing roster agent " + "definitions without changing existing aliases. " + `If \`.opencode/agent/${agentName}.md\` already exists, reload opencode ` + "to discover it before retrying; do not substitute an unrelated agent.";
+}
 function missingAgentDefinition(agentName, roleID) {
-  return `agent definition "${agentName}" is not installed for role "${roleID}". ` + `Create .opencode/agent/${agentName}.md or choose an installed builtin agent before retrying.`;
+  return `agent definition "${agentName}" is not installed for role "${roleID}". ` + agentPreparationRemedy(agentName);
 }
 function dependencyValidationError(code, detail) {
   return `dependency validation error: ${code} (${detail})`;
@@ -10356,14 +10725,14 @@ var readReportArtifact = async (reportPath) => {
 };
 
 // src/orchestrator/roster.ts
-import { z as z19 } from "zod";
-var RosterEntrySchema = z19.object({
-  roleID: z19.string().min(1),
-  agentName: z19.string().min(1)
+import { z as z20 } from "zod";
+var RosterEntrySchema = z20.object({
+  roleID: z20.string().min(1),
+  agentName: z20.string().min(1)
 }).strict();
-var RosterSchema = z19.object({
-  universe: z19.string().min(1),
-  entries: z19.array(RosterEntrySchema)
+var RosterSchema = z20.object({
+  universe: z20.string().min(1),
+  entries: z20.array(RosterEntrySchema)
 }).strict();
 var ROSTER_JSON_FENCE = /```json\s*([\s\S]*?)```/;
 
@@ -10548,6 +10917,50 @@ function lifecycleRecordingAdvisory(status) {
   return `Lifecycle history recording is ${status.state}${failure}; model execution continued without claiming complete history.`;
 }
 
+// src/orchestrator/sessionStatus.ts
+function dataProperties(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  try {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+      return;
+    if (Reflect.ownKeys(value).some((key) => typeof key !== "string"))
+      return;
+    const properties = Object.getOwnPropertyDescriptors(value);
+    return Object.values(properties).every((property) => ("value" in property) && property.enumerable === true) ? properties : undefined;
+  } catch {
+    return;
+  }
+}
+function parseSessionStatus(value) {
+  const properties = dataProperties(value);
+  if (properties === undefined)
+    return;
+  const type = properties.type?.value;
+  if (type === "idle" || type === "busy")
+    return { type };
+  const attempt = properties.attempt?.value;
+  const message = properties.message?.value;
+  const next = properties.next?.value;
+  if (type === "retry" && typeof attempt === "number" && Number.isFinite(attempt) && typeof message === "string" && typeof next === "number" && Number.isFinite(next))
+    return { type, attempt, message, next };
+  return;
+}
+function parseSessionStatusMap(value) {
+  const properties = dataProperties(value);
+  if (properties === undefined)
+    return;
+  const entries = [];
+  for (const [sessionID, property] of Object.entries(properties)) {
+    const status = parseSessionStatus(property.value);
+    if (status === undefined)
+      return;
+    entries.push([sessionID, status]);
+  }
+  return Object.fromEntries(entries);
+}
+
 // src/orchestrator/subsessions.ts
 var DEFAULT_ABORT_GRACE_MS = 2000;
 var DEFAULT_STATUS_POLL_MS = 100;
@@ -10773,28 +11186,6 @@ function statusArgs(directory, signal) {
 function abortArgs(sessionID, directory, signal) {
   return directory === undefined ? { path: { id: sessionID }, signal } : { path: { id: sessionID }, query: { directory }, signal };
 }
-function isSessionStatus(value) {
-  if (!isObject3(value))
-    return false;
-  const type = safeGet(value, "type");
-  if (type === "idle" || type === "busy")
-    return true;
-  if (type !== "retry")
-    return false;
-  return typeof safeGet(value, "attempt") === "number" && typeof safeGet(value, "message") === "string" && typeof safeGet(value, "next") === "number";
-}
-function isSessionStatusMap(value) {
-  if (!isObject3(value) || Array.isArray(value))
-    return false;
-  try {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null)
-      return false;
-    return Object.values(value).every(isSessionStatus);
-  } catch {
-    return false;
-  }
-}
 async function confirmSessionStopped(client, sessionID, directory, deps, deadline) {
   const abortSession = client.session.abort;
   if (abortSession === undefined) {
@@ -10843,8 +11234,8 @@ async function confirmSessionStopped(client, sessionID, directory, deps, deadlin
     if (safeGet(statuses, "error") !== undefined) {
       return { confirmed: false, cause: "status-error" };
     }
-    const snapshot = safeGet(statuses, "data");
-    if (!isSessionStatusMap(snapshot)) {
+    const snapshot = parseSessionStatusMap(safeGet(statuses, "data"));
+    if (snapshot === undefined) {
       return { confirmed: false, cause: "status-missing" };
     }
     if (!Object.hasOwn(snapshot, sessionID)) {
@@ -10986,10 +11377,21 @@ async function runSubsession(client, req, deps) {
   }
 }
 
+// src/local/modelResidency.ts
+function hasRequiredModelResidency(kind, model) {
+  return kind !== "lemonade" || model?.loaded === true;
+}
+
 // src/plugin/availability.ts
 function modelKey2(model) {
   return `${model.providerID}/${model.modelID}`;
 }
+function availabilityMetadata({
+  apiModelID: _apiModelID,
+  ...metadata2
+}) {
+  return metadata2;
+}
 function compareAvailableModels(left, right) {
   const kindOrder = Number(left.kind === "frontier") - Number(right.kind === "frontier");
   if (kindOrder !== 0) {
@@ -11007,6 +11409,9 @@ function uniqueSelections(models) {
 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));
+}
 function configuredFrontierProviderIDs(config) {
   const providerIDs = new Set([config.baseline.hardDefault.providerID]);
   if (config.baseline.mode === "pinned" && config.baseline.pinnedModel !== null) {
@@ -11101,7 +11506,7 @@ function frontierAvailableModels(config, configuredModels) {
   for (const model of configuredModels ?? frontierBaselines(config)) {
     if (!isConfiguredLocalModel(config, model)) {
       frontierByKey.set(modelKey2(model), {
-        ...model,
+        ...availabilityMetadata(model),
         kind: "frontier",
         available: true
       });
@@ -11117,7 +11522,7 @@ function defaultAvailableModels(config, configuredModels) {
     ...defaultLocalModels(config).map((model) => ({
       ...model,
       kind: "local",
-      available: true
+      available: !requiresModelResidency(config, model)
     })),
     ...frontierAvailableModels(config, configuredModels)
   ].sort(compareAvailableModels);
@@ -11131,7 +11536,8 @@ function toAvailableModels(snapshots, config, configuredModels) {
       continue;
     }
     localByKey.set(modelKey2(model), {
-      ...model,
+      ...availabilityMetadata(model),
+      ...model.apiModelID !== undefined && model.apiModelID !== model.modelID ? { runtimeModelID: model.apiModelID } : {},
       kind: "local",
       available: false
     });
@@ -11142,27 +11548,25 @@ function toAvailableModels(snapshots, config, configuredModels) {
       continue;
     }
     for (const model of snapshot.models) {
-      const ref = {
-        providerID: runtime.defaultModel.providerID,
-        modelID: model.modelID
-      };
-      if (registeredKeys !== undefined && !registeredKeys.has(modelKey2(ref))) {
-        continue;
-      }
-      const existing = localByKey.get(modelKey2(ref));
-      const availableModel = {
-        ...existing,
-        ...ref,
-        kind: "local",
-        available: snapshot.reachable || existing?.available === true
-      };
-      if (model.supportsTools !== "unknown") {
-        availableModel.supportsTools = model.supportsTools;
-      }
-      if (model.contextWindow !== undefined) {
-        availableModel.contextWindow = model.contextWindow;
+      const providerID = runtime.defaultModel.providerID;
+      const refs = configuredModels === undefined ? [{ providerID, modelID: model.modelID }] : configuredModels.filter((registered) => registered.providerID === providerID && (registered.apiModelID ?? registered.modelID) === model.modelID);
+      for (const ref of refs) {
+        const existing = localByKey.get(modelKey2(ref));
+        const availableModel = {
+          ...existing,
+          providerID: ref.providerID,
+          modelID: ref.modelID,
+          kind: "local",
+          available: snapshot.reachable && hasRequiredModelResidency(localRuntimeKind(runtime), model) || existing?.available === true
+        };
+        if (model.supportsTools !== "unknown") {
+          availableModel.supportsTools = model.supportsTools;
+        }
+        if (model.contextWindow !== undefined) {
+          availableModel.contextWindow = model.contextWindow;
+        }
+        localByKey.set(modelKey2(ref), availableModel);
       }
-      localByKey.set(modelKey2(ref), availableModel);
     }
   }
   return [
@@ -11171,7 +11575,7 @@ function toAvailableModels(snapshots, config, configuredModels) {
   ].sort(compareAvailableModels);
 }
 function createAvailabilityCache(options) {
-  let configuredModels = options.initialConfiguredModels === undefined ? undefined : [...options.initialConfiguredModels];
+  let configuredModels = options.initialConfiguredModels === undefined ? undefined : options.initialConfiguredModels.map((model) => ({ ...model }));
   let configuredProfiles = (options.initialConfiguredProfiles ?? []).map((profile) => profileForConfiguredDomain(options.config, profile));
   let cached = defaultAvailableModels(options.config, configuredModels);
   let inFlight;
@@ -11181,7 +11585,9 @@ function createAvailabilityCache(options) {
       if (options.listConfiguredInventory !== undefined) {
         const inventory = await options.listConfiguredInventory().then((value) => ({ kind: "models", value }), (error) => ({ kind: "error", error }));
         if (inventory.kind === "models") {
-          configuredModels = inventory.value.models;
+          configuredModels = inventory.value.models.map((model) => ({
+            ...model
+          }));
           configuredProfiles = inventory.value.profiles.map((profile) => profileForConfiguredDomain(options.config, profile));
         } else {
           options.onRefreshError?.(inventory.error);
@@ -11194,15 +11600,22 @@ function createAvailabilityCache(options) {
   }
   return {
     get: () => cloneAvailableModels(cached),
+    resolveApiModelID: (ref) => {
+      const registered = configuredModels?.find((model) => model.providerID === ref.providerID && model.modelID === ref.modelID);
+      return registered?.apiModelID ?? registered?.modelID;
+    },
     getProfiles: () => configuredProfiles.map((profile) => ({
       ...profile,
       ref: { ...profile.ref },
       costPer1M: { ...profile.costPer1M }
     })),
     refresh: () => {
-      inFlight ??= refreshNow().finally(() => {
-        inFlight = undefined;
-      });
+      if (inFlight === undefined) {
+        cached = cached.map((model) => requiresModelResidency(options.config, model) ? { ...model, available: false } : model);
+        inFlight = refreshNow().finally(() => {
+          inFlight = undefined;
+        });
+      }
       return inFlight;
     }
   };
@@ -11370,7 +11783,7 @@ function planWorktreeReconciliation(input) {
 }
 
 // src/telemetry/otelConfig.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/telemetry/fanout.ts
 function createFanOutSink(deps) {
@@ -11448,10 +11861,10 @@ function createOtelSink(deps) {
 }
 
 // src/telemetry/otelConfig.ts
-var OtelBackendConfigSchema = z20.object({
-  backend: z20.literal("opentelemetry"),
-  connectionEnv: z20.string().min(1),
-  serviceName: z20.string().min(1).optional()
+var OtelBackendConfigSchema = z21.object({
+  backend: z21.literal("opentelemetry"),
+  connectionEnv: z21.string().min(1),
+  serviceName: z21.string().min(1).optional()
 }).strict();
 function parseConnectionString(raw) {
   const pairs = new Map;
@@ -11876,7 +12289,7 @@ function parseOpencodeProviders(opencodeConfig) {
 function localRuntimeStates(config) {
   const map = new Map;
   for (const runtime of config.local.runtimes) {
-    map.set(runtime.id, { enabled: runtime.enabled });
+    map.set(runtime.defaultModel.providerID, { enabled: runtime.enabled });
   }
   return map;
 }
@@ -11884,7 +12297,7 @@ function disabledLocalProviderIDs(config) {
   const ids = new Set;
   for (const runtime of config.local.runtimes) {
     if (!runtime.enabled) {
-      ids.add(runtime.id);
+      ids.add(runtime.defaultModel.providerID);
     }
   }
   return ids;
@@ -11900,7 +12313,11 @@ function computeLive(model, isLocalProvider, liveModels) {
   if (!snapshot.reachable) {
     return "unreachable";
   }
-  return snapshot.modelIDs.has(model.modelID) ? "confirmed" : "not-advertised";
+  if (snapshot.modelIDs.has(model.modelID))
+    return "confirmed";
+  if (snapshot.residency?.has(model.modelID))
+    return snapshot.residency.get(model.modelID) === false ? "not-loaded" : "residency-unknown";
+  return "not-advertised";
 }
 function resolveAgentModel(model, context) {
   const isLocalProvider = KNOWN_LOCAL_PROVIDER_IDS.has(model.providerID) || context.localRuntimes.has(model.providerID);
@@ -13174,7 +13591,6 @@ var GENERATED_OPENTEAM_STATE_GROUPS = [
   { kind: "file", paths: [SOAK_RECORDER_ID_PATH] }
 ];
 var OPENCODE_DIR = ".opencode";
-var AGENT_DIR = `${OPENCODE_DIR}/agent`;
 function splitSetupPath(path3) {
   return path3.split("/").filter((segment) => segment.length > 0);
 }
@@ -14232,12 +14648,19 @@ function defaultModelFromOpencode(opencodeConfig) {
   }
   return;
 }
-function liveModelsFromSnapshots(snapshots) {
+function liveModelsFromSnapshots(snapshots, config) {
   const map = new Map;
   for (const snapshot of snapshots) {
-    map.set(snapshot.id, {
+    const runtime = config.local.runtimes.find((runtime2) => runtime2.id === snapshot.id);
+    if (runtime === undefined || !runtime.enabled)
+      continue;
+    const kind = localRuntimeKind(runtime);
+    map.set(runtime.defaultModel.providerID, {
       reachable: snapshot.reachable,
-      modelIDs: new Set(snapshot.models.map((model) => model.modelID))
+      modelIDs: new Set(snapshot.models.filter((model) => hasRequiredModelResidency(kind, model)).map((model) => model.modelID)),
+      ...kind === "lemonade" ? {
+        residency: new Map(snapshot.models.map((model) => [model.modelID, model.loaded]))
+      } : {}
     });
   }
   return map;
@@ -14523,7 +14946,7 @@ async function runCli(argv, deps) {
       const agentModels = diagnoseAgentModels(agentFiles, {
         opencodeProviders: parseOpencodeProviders(opencodeConfig),
         localRuntimes: localRuntimeStates(config),
-        liveModels: liveModelsFromSnapshots(snapshots),
+        liveModels: liveModelsFromSnapshots(snapshots, config),
         sourceDir: deps.agentDir,
         ...defaultModel !== undefined ? { defaultModel } : {}
       });
@@ -14562,29 +14985,53 @@ async function runCli(argv, deps) {
       const rosterMissing = deps.loadRosterForDoctor !== undefined && roster === undefined && rosterLoadError === undefined;
       const orchestratorAgentName = ORCHESTRATOR_AGENT_PATH.slice(ORCHESTRATOR_AGENT_PATH.lastIndexOf("/") + 1).replace(/\.md$/, "");
       const orchestratorAgentMissing = !agentFiles.some((file) => file.name === orchestratorAgentName);
+      const inventoryNotes = [];
+      const readySnapshots = snapshots.map((snapshot) => {
+        const runtime = config.local.runtimes.find((runtime2) => runtime2.id === snapshot.id);
+        if (runtime === undefined || localRuntimeKind(runtime) !== "lemonade")
+          return snapshot;
+        inventoryNotes.push(executionSetupMessages.lemonadeInventory(runtime.id, runtime.defaultModel.providerID, snapshot.models));
+        return {
+          ...snapshot,
+          models: snapshot.models.filter((model) => hasRequiredModelResidency(localRuntimeKind(runtime), model))
+        };
+      });
+      const residencyNotes = agentModels.flatMap((agent) => {
+        const live = agent.resolution?.live;
+        if (agent.model === undefined || live !== "not-loaded" && live !== "residency-unknown")
+          return [];
+        return [
+          executionSetupMessages.lemonadeAgentResidency(agent.name, `${agent.model.providerID}/${agent.model.modelID}`, live)
+        ];
+      });
       return {
         exitCode: 0,
-        stdout: renderDoctor({
-          config,
-          snapshots,
-          telemetryPath,
-          telemetryRecords: records.length,
-          agentModels,
-          opencodeConfigPaths,
-          ...opencodeConfig !== undefined ? { opencodeConfig } : {},
-          ...queueWait !== undefined ? { queueWait } : {},
-          ...rosterAudit !== undefined ? { rosterAudit } : {},
-          ...rosterRoleCount !== undefined ? { rosterRoleCount } : {},
-          ...rosterLoadError !== undefined ? { rosterLoadError } : {},
-          ...rosterMissing ? { rosterMissing } : {},
-          ...orchestratorAgentMissing ? { orchestratorAgentMissing } : {},
-          ...diagnostics !== undefined && diagnostics.length > 0 ? { diagnostics } : {},
-          ...opencodeConfigError !== undefined ? { opencodeConfigError } : {},
-          ...cacheEntries !== undefined ? { cacheEntries, cliVersion: deps.version } : {},
-          ...legacyLayout !== undefined && legacyLayout.length > 0 ? { legacyLayout } : {},
-          ...otelBackend !== undefined ? { otelBackend } : {},
-          ...gitignoreCoverage !== undefined ? { gitignore: gitignoreCoverage } : {}
-        })
+        stdout: [
+          renderDoctor({
+            config,
+            snapshots: readySnapshots,
+            telemetryPath,
+            telemetryRecords: records.length,
+            agentModels,
+            opencodeConfigPaths,
+            ...opencodeConfig !== undefined ? { opencodeConfig } : {},
+            ...queueWait !== undefined ? { queueWait } : {},
+            ...rosterAudit !== undefined ? { rosterAudit } : {},
+            ...rosterRoleCount !== undefined ? { rosterRoleCount } : {},
+            ...rosterLoadError !== undefined ? { rosterLoadError } : {},
+            ...rosterMissing ? { rosterMissing } : {},
+            ...orchestratorAgentMissing ? { orchestratorAgentMissing } : {},
+            ...diagnostics !== undefined && diagnostics.length > 0 ? { diagnostics } : {},
+            ...opencodeConfigError !== undefined ? { opencodeConfigError } : {},
+            ...cacheEntries !== undefined ? { cacheEntries, cliVersion: deps.version } : {},
+            ...legacyLayout !== undefined && legacyLayout.length > 0 ? { legacyLayout } : {},
+            ...otelBackend !== undefined ? { otelBackend } : {},
+            ...gitignoreCoverage !== undefined ? { gitignore: gitignoreCoverage } : {}
+          }),
+          ...inventoryNotes,
+          ...residencyNotes
+        ].join(`
+`)
       };
     }
     if (command === "migrate") {
@@ -14768,29 +15215,29 @@ import {
   writeFile as writeFile2
 } from "node:fs/promises";
 import { dirname as dirname5, join as join12, resolve as resolve7 } from "node:path";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var CONSOLE_RUNTIME_SCHEMA_VERSION = 1;
 var CONSOLE_RUNTIME_DIRECTORY = ".opencode/openteam-local/console";
 var CONSOLE_RUNTIME_FILE = "runtime.json";
 var CONSOLE_LAUNCH_LOCK_FILE = "launch.lock";
 var CONSOLE_LOG_FILE = "console.log";
-var ConsoleRuntimeStateSchema = z21.object({
-  schemaVersion: z21.literal(CONSOLE_RUNTIME_SCHEMA_VERSION),
-  pid: z21.number().int().positive(),
-  workspaceRoot: z21.string().min(1),
-  host: z21.string().min(1),
-  port: z21.number().int().min(1).max(65535),
-  url: z21.url(),
-  startedAt: z21.iso.datetime({ offset: true }),
-  launchId: z21.uuid(),
-  logPath: z21.string().min(1)
+var ConsoleRuntimeStateSchema = z22.object({
+  schemaVersion: z22.literal(CONSOLE_RUNTIME_SCHEMA_VERSION),
+  pid: z22.number().int().positive(),
+  workspaceRoot: z22.string().min(1),
+  host: z22.string().min(1),
+  port: z22.number().int().min(1).max(65535),
+  url: z22.url(),
+  startedAt: z22.iso.datetime({ offset: true }),
+  launchId: z22.uuid(),
+  logPath: z22.string().min(1)
 }).strict();
-var ConsoleLaunchLockSchema = z21.object({
-  schemaVersion: z21.literal(CONSOLE_RUNTIME_SCHEMA_VERSION),
-  workspaceRoot: z21.string().min(1),
-  launchId: z21.uuid(),
-  ownerPid: z21.number().int().positive(),
-  createdAt: z21.iso.datetime({ offset: true })
+var ConsoleLaunchLockSchema = z22.object({
+  schemaVersion: z22.literal(CONSOLE_RUNTIME_SCHEMA_VERSION),
+  workspaceRoot: z22.string().min(1),
+  launchId: z22.uuid(),
+  ownerPid: z22.number().int().positive(),
+  createdAt: z22.iso.datetime({ offset: true })
 }).strict();
 
 class ConsoleRuntimeStateFileError extends Error {
@@ -15489,36 +15936,36 @@ function formatResponse(response) {
 }
 
 // src/plugin/reportRunSchema.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/plugin/graphShadowIngress.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var LEGACY_EXECUTION_TRACE_VERSION = 1;
-var LegacyExecutionStatusSchema = z22.enum([
+var LegacyExecutionStatusSchema = z23.enum([
   "completed",
   "failed",
   "cancelled"
 ]);
-var LegacyReviewOutcomeSchema = z22.enum([
+var LegacyReviewOutcomeSchema = z23.enum([
   "approved",
   "rejected",
   "inconclusive"
 ]);
-var LegacyTraceNodeV1Schema = z22.object({
+var LegacyTraceNodeV1Schema = z23.object({
   id: NodeIDSchema,
   role: NodeRoleSchema,
-  model: z22.string().min(1),
-  sessionRef: z22.string().min(1).optional(),
+  model: z23.string().min(1),
+  sessionRef: z23.string().min(1).optional(),
   errorClass: ErrorClassSchema.optional()
 }).strict();
-var LegacyExecutionTraceV1Schema = z22.object({
-  version: z22.literal(LEGACY_EXECUTION_TRACE_VERSION),
+var LegacyExecutionTraceV1Schema = z23.object({
+  version: z23.literal(LEGACY_EXECUTION_TRACE_VERSION),
   runID: NodeIDSchema,
   status: LegacyExecutionStatusSchema,
   outcome: LegacyReviewOutcomeSchema,
-  fixes: z22.number().int().nonnegative(),
-  nodes: z22.array(LegacyTraceNodeV1Schema).min(1),
-  parentSessionRef: z22.string().min(1).optional()
+  fixes: z23.number().int().nonnegative(),
+  nodes: z23.array(LegacyTraceNodeV1Schema).min(1),
+  parentSessionRef: z23.string().min(1).optional()
 }).strict();
 function gateReason2(gate) {
   if (gate === undefined || gate.mode === "off") {
@@ -15589,20 +16036,20 @@ function parseLegacyExecutionTrace(input) {
 }
 
 // src/plugin/reportRunSchema.ts
-var ReportRunNodeSchema = z23.object({
+var ReportRunNodeSchema = z24.object({
   id: NodeIDSchema,
   role: NodeRoleSchema,
-  model: z23.string().min(1),
-  ok: z23.boolean(),
-  sessionRef: z23.string().min(1).optional(),
+  model: z24.string().min(1),
+  ok: z24.boolean(),
+  sessionRef: z24.string().min(1).optional(),
   errorClass: ErrorClassSchema.optional()
 }).strict();
-var ReportRunPayloadSchema = z23.object({
+var ReportRunPayloadSchema = z24.object({
   runID: NodeIDSchema,
   status: LegacyExecutionStatusSchema,
-  fixes: z23.number().int().nonnegative(),
-  nodes: z23.array(ReportRunNodeSchema).min(1),
-  parentSessionRef: z23.string().min(1).optional()
+  fixes: z24.number().int().nonnegative(),
+  nodes: z24.array(ReportRunNodeSchema).min(1),
+  parentSessionRef: z24.string().min(1).optional()
 }).strict();
 
 // src/orchestrator/graphShadow.ts
@@ -16706,6 +17153,309 @@ function hashPrompt(prompt) {
   return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
 }
 
+// src/plugin/modelResidency.ts
+import { z as z25 } from "zod";
+
+// src/local/lemonadeRequestGuard.ts
+var inferencePaths = new Set([
+  "/chat/completions",
+  "/completions",
+  "/embeddings",
+  "/responses"
+]);
+function modelID(payload) {
+  if (typeof payload !== "object" || payload === null || !("model" in payload) || typeof payload.model !== "string" || payload.model.length === 0 || payload.model !== payload.model.trim()) {
+    throw new ModelResidencyError("request");
+  }
+  if (payload.model.endsWith(":latest"))
+    throw new ModelResidencyError("identity");
+  return payload.model;
+}
+function createLemonadeGuardedFetch(options) {
+  const base = lemonadeBaseURL(options.baseURL);
+  const upstream = options.fetch;
+  const healthFetch = options.healthFetch ?? upstream;
+  return Object.assign(async (input, init) => {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    if (url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !request.url.startsWith(`${base}/`)) {
+      throw new ModelResidencyError("destination");
+    }
+    const path4 = request.url.slice(base.length);
+    const metadataOnly = request.method === "GET" && (path4 === "/health" || /^\/models(?:\/[^/]+)?$/.test(path4));
+    if (!metadataOnly && (request.method !== "POST" || !inferencePaths.has(path4))) {
+      throw new ModelResidencyError("request");
+    }
+    if (!metadataOnly) {
+      await withResidencyDeadline(async (signal) => {
+        signal.throwIfAborted();
+        let payload;
+        try {
+          payload = await request.clone().json();
+        } catch {
+          signal.throwIfAborted();
+          throw new ModelResidencyError("request");
+        }
+        signal.throwIfAborted();
+        const model = modelID(payload);
+        const modelIDs = typeof options.modelIDs === "function" ? await options.modelIDs() : options.modelIDs;
+        signal.throwIfAborted();
+        if (modelIDs !== undefined && !modelIDs.has(model)) {
+          throw new ModelResidencyError("identity");
+        }
+        const residency = await readLemonadeResidency(base, healthFetch, {
+          ...options,
+          signal,
+          headers: request.headers
+        });
+        signal.throwIfAborted();
+        const entry = residency.get(model);
+        if (entry?.loaded !== true) {
+          throw new ModelResidencyError(entry?.loaded === undefined && entry !== undefined ? "unknown" : "inactive");
+        }
+      }, { ...options, signal: request.signal });
+    }
+    if (request.signal.aborted)
+      throw new ModelResidencyError("cancelled");
+    const {
+      body: _body,
+      headers: _headers,
+      method: _method,
+      signal: _signal,
+      redirect: _redirect,
+      ...transportOptions
+    } = init ?? {};
+    return upstream(request, { ...transportOptions, redirect: "error" });
+  }, {
+    preconnect: (...args) => upstream.preconnect?.(...args)
+  });
+}
+
+// src/plugin/modelResidency.ts
+function isFetch(value) {
+  return typeof value === "function";
+}
+function origin(value) {
+  return typeof value === "string" && URL.canParse(value) ? new URL(value).origin : undefined;
+}
+var TEMPLATE_REFERENCE = /\$\{[^}]+\}/;
+function resolveTemplateReferences(value, readEnv) {
+  let unresolved = false;
+  const resolved = value.replace(/\$\{([^}]+)\}/g, (match, key) => {
+    const resolvedValue = readEnv(key);
+    if (resolvedValue === undefined) {
+      unresolved = true;
+      return match;
+    }
+    return resolvedValue;
+  });
+  return unresolved ? undefined : resolved;
+}
+function endpointBinding(value, readEnv) {
+  if (!TEMPLATE_REFERENCE.test(value))
+    return { ambiguous: false, origin: origin(value) };
+  const resolved = resolveTemplateReferences(value, readEnv);
+  return resolved === undefined ? { ambiguous: true } : { ambiguous: false, origin: origin(resolved) };
+}
+function optionBaseURL(value) {
+  return typeof value === "string" && value !== "" ? value : undefined;
+}
+function providerBase(provider, model) {
+  return optionBaseURL(provider.options?.baseURL) ?? model?.provider?.api ?? provider.api;
+}
+function providerRoutes(provider) {
+  const models = Object.values(provider.models ?? {});
+  return (models.length === 0 ? [undefined] : models).map((model) => ({
+    baseURL: providerBase(provider, model),
+    npm: model?.provider?.npm ?? provider.npm
+  }));
+}
+function wireID(key, model) {
+  const id = model?.id ?? key;
+  if (id.length === 0 || id !== id.trim())
+    throw new ModelResidencyError("identity");
+  return id;
+}
+function nativeEligibleID(id) {
+  return id === "openai" || id === "anthropic" || id.startsWith("opencode");
+}
+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");
+  }
+  return runtime;
+}
+function createModelResidencyGuard(config, options) {
+  const guarded = new Map;
+  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) => {
+    if (runtime.defaultModel.providerID === providerID)
+      return true;
+    if (baseURL === undefined)
+      return false;
+    const binding = endpointBinding(baseURL, readEnv);
+    if (binding.ambiguous)
+      return true;
+    return binding.origin !== undefined && binding.origin === origin(runtime.baseURL ?? LEMONADE_DEFAULT_BASE_URL);
+  });
+  const resolvedWireID = (model, declaredID) => {
+    const id = options.resolveApiModelID === undefined ? declaredID : options.resolveApiModelID(model);
+    if (id === undefined)
+      throw new ModelResidencyError("identity");
+    return wireID(id, undefined);
+  };
+  const configHook = async (host) => {
+    hostConfig = host;
+    const previousGuards = new Map(guarded);
+    guarded.clear();
+    blocked.clear();
+    for (const [providerID, provider] of Object.entries(host.provider ?? {})) {
+      const routes = providerRoutes(provider);
+      if (!routes.some((route) => protects(providerID, route.baseURL)))
+        continue;
+      const previous = previousGuards.get(providerID);
+      const configuredFetch = provider.options?.fetch;
+      const originalFetch = previous !== undefined && configuredFetch === previous.fetch ? previous.originalFetch : configuredFetch ?? options.fetch;
+      blocked.add(providerID);
+      const wasDisabled = host.disabled_providers?.includes(providerID) ?? false;
+      host.disabled_providers = [
+        ...new Set([...host.disabled_providers ?? [], providerID])
+      ];
+      const reject = Object.assign(async () => {
+        throw new ModelResidencyError("transport");
+      }, { 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");
+        if (routes.some((route) => route.npm !== "@ai-sdk/openai-compatible") || nativeEligibleID(providerID) || !isFetch(originalFetch))
+          throw new ModelResidencyError("transport");
+        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 (!modelKeys.has(runtime.defaultModel.modelID))
+          modelKeys.set(runtime.defaultModel.modelID, undefined);
+        const modelIDs = () => {
+          const ids = new Set;
+          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));
+          }
+          return ids;
+        };
+        const fetch = createLemonadeGuardedFetch({
+          ...options,
+          baseURL,
+          modelIDs: async () => {
+            await options.modelInventoryReady?.();
+            return modelIDs();
+          },
+          fetch: originalFetch,
+          healthFetch: options.fetch
+        });
+        provider.options.fetch = fetch;
+        guarded.set(providerID, {
+          baseURL,
+          fetch,
+          originalFetch,
+          modelIDs,
+          modelKeys
+        });
+        blocked.delete(providerID);
+        if (!wasDisabled) {
+          host.disabled_providers = host.disabled_providers.filter((id) => id !== providerID);
+        }
+      } catch (error) {
+        if (!(error instanceof ModelResidencyError))
+          throw error;
+        (options.warn ?? console.warn)(modelResidencyMessages.providerDisabled(providerID));
+      }
+    }
+  };
+  const beforeInference = async (input) => {
+    const base = optionBaseURL(input.provider.options.baseURL) ?? input.model.api.url;
+    if (!protects(input.model.providerID, base))
+      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");
+    }
+    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");
+    if (!provider.modelKeys.has(input.model.id))
+      provider.modelKeys.set(input.model.id, undefined);
+  };
+  const localTarget = (model) => {
+    const runtime = configuredRuntime(config, model.providerID);
+    if (hostConfig?.disabled_providers?.includes(model.providerID)) {
+      throw new ModelResidencyError("transport");
+    }
+    if (runtime.baseURL === undefined)
+      throw new ModelResidencyError("destination");
+    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");
+    }
+    const modelID2 = resolvedWireID(model, entry === undefined && localRuntimeKind(runtime) === "lemonade" ? undefined : wireID(model.modelID, entry));
+    let fetch = options.fetch;
+    if (localRuntimeKind(runtime) === "lemonade") {
+      const installed = guarded.get(model.providerID);
+      if (installed === undefined || blocked.has(model.providerID)) {
+        throw new ModelResidencyError("transport");
+      }
+      if (installed.baseURL !== lemonadeBaseURL(runtime.baseURL)) {
+        throw new ModelResidencyError("destination");
+      }
+      if (!installed.modelKeys.has(model.modelID))
+        installed.modelKeys.set(model.modelID, undefined);
+      if (!installed.modelIDs().has(modelID2))
+        throw new ModelResidencyError("identity");
+      fetch = installed.fetch;
+    }
+    const configuredHeaders = z25.record(z25.string(), z25.string()).safeParse(provider?.options?.headers ?? {});
+    if (!configuredHeaders.success)
+      throw new ModelResidencyError("configuration");
+    const headers = new Headers(configuredHeaders.data);
+    if (typeof provider?.options?.apiKey === "string" && !headers.has("authorization")) {
+      headers.set("authorization", `Bearer ${provider.options.apiKey}`);
+    }
+    for (const [name, value] of Object.entries(entry?.headers ?? {}))
+      headers.set(name, value);
+    const upstream = fetch;
+    return {
+      baseURL: runtime.baseURL,
+      modelID: modelID2,
+      fetch: [...headers].length === 0 ? fetch : Object.assign(async (input, init) => {
+        const request = new Request(input, init);
+        for (const [name, value] of headers) {
+          if (!request.headers.has(name))
+            request.headers.set(name, value);
+        }
+        return upstream(request);
+      }, {
+        preconnect: (...args) => upstream.preconnect?.(...args)
+      })
+    };
+  };
+  return { config: configHook, beforeInference, localTarget };
+}
+
 // src/plugin/hooks.ts
 var codeSignals = [
   "```",
@@ -16849,7 +17599,10 @@ 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,
     "chat.message": createChatMessageHook(config, getAvailable, options)
   };
 }
@@ -16903,62 +17656,62 @@ ${lines.join(`
 }
 
 // src/memory/types.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 var SHARED_OWNER_KEY = "*";
-var OwnerKeySchema = z24.string().min(1);
-var MemoryKindSchema = z24.enum(["fact", "preference", "entity"]);
-var MemoryBaseSchema = z24.object({
-  id: z24.string().min(1),
+var OwnerKeySchema = z26.string().min(1);
+var MemoryKindSchema = z26.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z26.object({
+  id: z26.string().min(1),
   ownerKey: OwnerKeySchema,
-  confidence: z24.number().min(0).max(1),
-  validFrom: z24.number().finite(),
-  validUntil: z24.number().finite().nullable().default(null),
-  createdAt: z24.number().finite(),
-  invalidatedAt: z24.number().finite().nullable().default(null),
-  sourceHash: z24.string().min(1),
-  supersededBy: z24.string().min(1).nullable().default(null)
+  confidence: z26.number().min(0).max(1),
+  validFrom: z26.number().finite(),
+  validUntil: z26.number().finite().nullable().default(null),
+  createdAt: z26.number().finite(),
+  invalidatedAt: z26.number().finite().nullable().default(null),
+  sourceHash: z26.string().min(1),
+  supersededBy: z26.string().min(1).nullable().default(null)
 }).strict();
 var FactSchema = MemoryBaseSchema.extend({
-  kind: z24.literal("fact"),
-  subject: z24.string().min(1),
-  predicate: z24.string().min(1),
-  object: z24.string().min(1),
-  category: z24.string().min(1).nullable().default(null)
+  kind: z26.literal("fact"),
+  subject: z26.string().min(1),
+  predicate: z26.string().min(1),
+  object: z26.string().min(1),
+  category: z26.string().min(1).nullable().default(null)
 });
 var PreferenceSchema = MemoryBaseSchema.extend({
-  kind: z24.literal("preference"),
-  category: z24.string().min(1),
-  preference: z24.string().min(1),
-  context: z24.string().min(1).nullable().default(null),
-  lastAccessedAt: z24.number().finite().nullable().default(null),
-  accessCount: z24.number().int().min(0).default(0)
+  kind: z26.literal("preference"),
+  category: z26.string().min(1),
+  preference: z26.string().min(1),
+  context: z26.string().min(1).nullable().default(null),
+  lastAccessedAt: z26.number().finite().nullable().default(null),
+  accessCount: z26.number().int().min(0).default(0)
 });
 var EntitySchema = MemoryBaseSchema.extend({
-  kind: z24.literal("entity"),
-  canonicalName: z24.string().min(1),
-  type: z24.string().min(1),
-  aliases: z24.array(z24.string().min(1)).default([])
+  kind: z26.literal("entity"),
+  canonicalName: z26.string().min(1),
+  type: z26.string().min(1),
+  aliases: z26.array(z26.string().min(1)).default([])
 });
 var RelationSchema = MemoryBaseSchema.extend({
-  kind: z24.literal("relation"),
-  from: z24.string().min(1),
-  to: z24.string().min(1),
-  predicate: z24.string().min(1),
-  annotation: z24.string().min(1).nullable().default(null)
+  kind: z26.literal("relation"),
+  from: z26.string().min(1),
+  to: z26.string().min(1),
+  predicate: z26.string().min(1),
+  annotation: z26.string().min(1).nullable().default(null)
 });
-var MemoryRecordSchema = z24.discriminatedUnion("kind", [
+var MemoryRecordSchema = z26.discriminatedUnion("kind", [
   FactSchema,
   PreferenceSchema,
   EntitySchema,
   RelationSchema
 ]);
-var RecallQuerySchema = z24.object({
+var RecallQuerySchema = z26.object({
   ownerKey: OwnerKeySchema,
-  kinds: z24.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
-  asOf: z24.number().finite().nullable().default(null),
-  limit: z24.number().int().positive().default(8),
-  minSimilarity: z24.number().min(0).max(1).default(0.2),
-  includeShared: z24.boolean().default(true)
+  kinds: z26.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z26.number().finite().nullable().default(null),
+  limit: z26.number().int().positive().default(8),
+  minSimilarity: z26.number().min(0).max(1).default(0.2),
+  includeShared: z26.boolean().default(true)
 }).strict();
 
 // src/memory/rank.ts
@@ -17529,42 +18282,42 @@ function buildMemoryInjector(deps, policy) {
 
 // src/plugin/memoryTool.ts
 import { tool as tool4 } from "@opencode-ai/plugin";
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 
 // src/memory/extract.ts
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 var REDACTED = "[redacted]";
-var RawFactSchema = z25.object({
-  subject: z25.string().min(1),
-  predicate: z25.string().min(1),
-  object: z25.string().min(1),
-  category: z25.string().min(1).nullable().optional(),
-  confidence: z25.number().min(0).max(1).optional()
+var RawFactSchema = z27.object({
+  subject: z27.string().min(1),
+  predicate: z27.string().min(1),
+  object: z27.string().min(1),
+  category: z27.string().min(1).nullable().optional(),
+  confidence: z27.number().min(0).max(1).optional()
 });
-var RawPreferenceSchema = z25.object({
-  category: z25.string().min(1),
-  preference: z25.string().min(1),
-  context: z25.string().min(1).nullable().optional(),
-  confidence: z25.number().min(0).max(1).optional()
+var RawPreferenceSchema = z27.object({
+  category: z27.string().min(1),
+  preference: z27.string().min(1),
+  context: z27.string().min(1).nullable().optional(),
+  confidence: z27.number().min(0).max(1).optional()
 });
-var RawEntitySchema = z25.object({
-  canonicalName: z25.string().min(1),
-  type: z25.string().min(1),
-  aliases: z25.array(z25.string().min(1)).optional(),
-  confidence: z25.number().min(0).max(1).optional()
+var RawEntitySchema = z27.object({
+  canonicalName: z27.string().min(1),
+  type: z27.string().min(1),
+  aliases: z27.array(z27.string().min(1)).optional(),
+  confidence: z27.number().min(0).max(1).optional()
 });
-var RawRelationSchema = z25.object({
-  from: z25.string().min(1),
-  to: z25.string().min(1),
-  predicate: z25.string().min(1),
-  annotation: z25.string().min(1).nullable().optional(),
-  confidence: z25.number().min(0).max(1).optional()
+var RawRelationSchema = z27.object({
+  from: z27.string().min(1),
+  to: z27.string().min(1),
+  predicate: z27.string().min(1),
+  annotation: z27.string().min(1).nullable().optional(),
+  confidence: z27.number().min(0).max(1).optional()
 }).strict();
-var RawExtractionSchema = z25.object({
-  facts: z25.array(RawFactSchema).default([]),
-  preferences: z25.array(RawPreferenceSchema).default([]),
-  entities: z25.array(RawEntitySchema).default([]),
-  relations: z25.array(RawRelationSchema).default([])
+var RawExtractionSchema = z27.object({
+  facts: z27.array(RawFactSchema).default([]),
+  preferences: z27.array(RawPreferenceSchema).default([]),
+  entities: z27.array(RawEntitySchema).default([]),
+  relations: z27.array(RawRelationSchema).default([])
 });
 var DEFAULT_CONFIDENCE = 0.6;
 var SYSTEM_PROMPT = [
@@ -17818,13 +18571,13 @@ var memoryToolMessages = {
 
 // src/plugin/memoryTool.ts
 var SCRIBE_ROLE_ID = "scribe";
-var MemoryMessageSchema = z26.object({
-  role: z26.enum(["system", "user", "assistant"]).describe(memoryToolMessages.messageRoleDescription),
-  content: z26.string().min(1).describe(memoryToolMessages.messageContentDescription)
+var MemoryMessageSchema = z28.object({
+  role: z28.enum(["system", "user", "assistant"]).describe(memoryToolMessages.messageRoleDescription),
+  content: z28.string().min(1).describe(memoryToolMessages.messageContentDescription)
 }).strict();
-var MemoryWritePayloadSchema = z26.object({
-  messages: z26.array(MemoryMessageSchema).min(1).describe(memoryToolMessages.messagesDescription),
-  roleID: z26.string().min(1).default(SCRIBE_ROLE_ID).describe(memoryToolMessages.roleIDDescription)
+var MemoryWritePayloadSchema = z28.object({
+  messages: z28.array(MemoryMessageSchema).min(1).describe(memoryToolMessages.messagesDescription),
+  roleID: z28.string().min(1).default(SCRIBE_ROLE_ID).describe(memoryToolMessages.roleIDDescription)
 }).strict();
 function createMemoryTool(deps) {
   return tool4({
@@ -17836,7 +18589,7 @@ function createMemoryTool(deps) {
       })).describe(memoryToolMessages.messagesDescription),
       roleID: tool4.schema.string().optional().describe(memoryToolMessages.roleIDDescription)
     },
-    async execute(args) {
+    async execute(args, toolContext) {
       const parsed = MemoryWritePayloadSchema.safeParse(args);
       if (!parsed.success) {
         return memoryToolMessages.validationError(parsed.error.message);
@@ -17857,33 +18610,83 @@ function createMemoryTool(deps) {
       if (executionMode2 === "frontier") {
         return memoryToolMessages.frontierDomainRefusal;
       }
-      if (!await deps.localRuntimeReachable()) {
-        return memoryToolMessages.localRuntimeUnavailable;
-      }
-      const runtime = deps.config.local.runtimes.find((rt) => rt.enabled && typeof rt.baseURL === "string" && rt.baseURL.length > 0);
-      if (runtime?.baseURL === undefined) {
-        return memoryToolMessages.localRuntimeBaseURLMissing;
-      }
-      const modelID = semantic.extraction.model?.modelID ?? runtime.defaultModel.modelID;
-      const transcript = messages.map((m) => `${m.role}: ${m.content}`).join(`
-`);
-      const sourceHash = sha256Hex(transcript);
-      const now = deps.now();
-      const context = {
-        ownerKey: semantic.scope === "user" ? "user" : "project",
-        now,
-        sourceHash,
-        storeContent: semantic.storeContent,
-        idPrefix: `${sourceHash.slice(0, 12)}:${now}`
-      };
       let records;
       try {
+        const signal = toolContext.abort;
+        const throwIfAborted = () => {
+          if (signal?.aborted)
+            throw new ModelResidencyError("cancelled");
+        };
+        throwIfAborted();
+        const configuredModel = semantic.extraction.model;
+        let runtime;
+        if (configuredModel != null) {
+          const matches = deps.config.local.runtimes.filter((candidate) => candidate.defaultModel.providerID === configuredModel.providerID);
+          runtime = matches[0];
+          if (matches.length !== 1 || runtime === undefined || !runtime.enabled) {
+            return modelResidencyMessages.extractionRuntimeUnavailable;
+          }
+        } else {
+          runtime = deps.config.local.runtimes.find((candidate) => candidate.enabled && typeof candidate.baseURL === "string" && candidate.baseURL.length > 0);
+        }
+        if (runtime?.baseURL === undefined || runtime.baseURL.length === 0) {
+          return memoryToolMessages.localRuntimeBaseURLMissing;
+        }
+        const baseURL = runtime.baseURL;
+        const model = configuredModel ?? runtime.defaultModel;
+        const selectedRuntime = runtime;
+        const deadline = {
+          ...deps.residencyOptions,
+          ...signal === undefined ? {} : { signal }
+        };
+        const reachable = localRuntimeKind(runtime) === "lemonade" ? await withResidencyDeadline((signal2) => deps.localRuntimeReachable(selectedRuntime, signal2), deadline) : await deps.localRuntimeReachable(runtime);
+        throwIfAborted();
+        if (!reachable)
+          return memoryToolMessages.localRuntimeUnavailable;
+        const resolveTarget = deps.resolveExtractionTarget;
+        const target = resolveTarget ? await withResidencyDeadline(async () => resolveTarget(model), deadline) : {
+          baseURL,
+          modelID: model.modelID,
+          fetch: localRuntimeKind(runtime) === "lemonade" ? createLemonadeGuardedFetch({
+            baseURL,
+            fetch: deps.fetch,
+            modelIDs: new Set([model.modelID]),
+            ...deps.residencyOptions
+          }) : deps.fetch
+        };
+        throwIfAborted();
+        if (target === undefined || target.baseURL !== baseURL) {
+          throw new ModelResidencyError("destination");
+        }
+        const fetch = signal === undefined ? target.fetch : Object.assign(async (input, init) => {
+          throwIfAborted();
+          const response = await target.fetch(input, {
+            ...init,
+            signal
+          });
+          throwIfAborted();
+          return response;
+        }, {
+          preconnect: (...args2) => target.fetch.preconnect?.(...args2)
+        });
+        const transcript = messages.map((m) => `${m.role}: ${m.content}`).join(`
+`);
+        const sourceHash = sha256Hex(transcript);
+        const now = deps.now();
+        const context = {
+          ownerKey: semantic.scope === "user" ? "user" : "project",
+          now,
+          sourceHash,
+          storeContent: semantic.storeContent,
+          idPrefix: `${sourceHash.slice(0, 12)}:${now}`
+        };
         records = await extractMemory({
-          baseURL: runtime.baseURL,
-          modelID,
+          baseURL: target.baseURL,
+          modelID: target.modelID,
           messages,
           context
-        }, { fetch: deps.fetch, ...deps.warn ? { warn: deps.warn } : {} });
+        }, { fetch, ...deps.warn ? { warn: deps.warn } : {} });
+        throwIfAborted();
       } catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
         return memoryToolMessages.extractionFailure(reason);
@@ -17949,10 +18752,10 @@ function createOrchestratedModelOwnership() {
 
 // src/plugin/orchestrateTool.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 
 // src/orchestrator/coordinator.ts
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 
 // src/orchestrator/nodeIteration.ts
 var DEFAULT_MAX_RETRIES = 2;
@@ -18162,12 +18965,15 @@ async function applyReportDurabilityGate(results, probe) {
 }
 
 // src/orchestrator/runtimeSelection.ts
-function configuredRuntime(runtimeId, config) {
+function configuredRuntime2(runtimeId, config) {
   return config.local.runtimes.find((runtime) => runtime.id === runtimeId);
 }
 function runtimeIdOfModel(model, config) {
   return config.local.runtimes.find((runtime) => sameModel(runtime.defaultModel, model))?.id;
 }
+function enabledRuntimeForProvider(providerID, config) {
+  return config.local.runtimes.find((runtime) => runtime.enabled && runtime.defaultModel.providerID === providerID)?.id;
+}
 function roleLocalModel(role, runtimeId, fallback, runtime) {
   const pinned = role.localModels?.[runtimeId];
   if (pinned !== undefined) {
@@ -18182,7 +18988,7 @@ function runtimeClassModel(modelClass, runtime) {
   }
   return modelClass === "thinking" ? runtime.thinkingModel : runtime.coderModel;
 }
-function selectDispatchRuntime(role, decision2, reachable, config) {
+function selectDispatchRuntime(role, decision2, reachable, config, availableModels2) {
   if (decision2.routeKind !== "local") {
     return { runtimeId: undefined, decision: decision2 };
   }
@@ -18193,7 +18999,7 @@ function selectDispatchRuntime(role, decision2, reachable, config) {
         if (!reachable.has(runtimeId)) {
           continue;
         }
-        const runtime = configuredRuntime(runtimeId, config);
+        const runtime = configuredRuntime2(runtimeId, config);
         if (runtime?.defaultModel.providerID === decision2.selected.providerID) {
           return { runtimeId, decision: decision2 };
         }
@@ -18203,15 +19009,17 @@ function selectDispatchRuntime(role, decision2, reachable, config) {
     if (exactRuntimeId !== undefined) {
       return { runtimeId: exactRuntimeId, decision: decision2 };
     }
-    const providerRuntime = config.local.runtimes.find((runtime) => runtime.enabled && runtime.defaultModel.providerID === decision2.selected.providerID);
-    return { runtimeId: providerRuntime?.id, decision: decision2 };
+    return {
+      runtimeId: enabledRuntimeForProvider(decision2.selected.providerID, config),
+      decision: decision2
+    };
   }
   if (listed !== undefined && listed.length > 0 && reachable !== undefined) {
     for (const runtimeId of listed) {
       if (!reachable.has(runtimeId)) {
         continue;
       }
-      const runtime = configuredRuntime(runtimeId, config);
+      const runtime = configuredRuntime2(runtimeId, config);
       if (runtime === undefined) {
         continue;
       }
@@ -18224,7 +19032,7 @@ function selectDispatchRuntime(role, decision2, reachable, config) {
   }
   const resolvedRuntimeId = runtimeIdOfModel(decision2.selected, config);
   if (resolvedRuntimeId !== undefined) {
-    const pinned = roleLocalModel(role, resolvedRuntimeId, decision2.selected, configuredRuntime(resolvedRuntimeId, config));
+    const pinned = roleLocalModel(role, resolvedRuntimeId, decision2.selected, configuredRuntime2(resolvedRuntimeId, config));
     if (pinned !== decision2.selected) {
       return {
         runtimeId: resolvedRuntimeId,
@@ -18232,8 +19040,9 @@ function selectDispatchRuntime(role, decision2, reachable, config) {
       };
     }
   }
+  const knownAlias = localModelAliases(decision2.selected.providerID, availableModels2).has(decision2.selected.modelID);
   return {
-    runtimeId: resolvedRuntimeId,
+    runtimeId: resolvedRuntimeId ?? (knownAlias ? enabledRuntimeForProvider(decision2.selected.providerID, config) : undefined),
     decision: decision2
   };
 }
@@ -18420,7 +19229,7 @@ function buildRecord(input, decision2, subsession, deps, decisionID, batchID) {
   }
   return record;
 }
-var TelemetryFailureClassSchema = z27.enum([
+var TelemetryFailureClassSchema = z29.enum([
   "create-rejected",
   "create-no-id",
   "prompt-rejected",
@@ -18679,7 +19488,7 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch, route
   if (routed.routeKind === "blocked") {
     throw new Error(coordinatorRoutingBlocked(input.roleID, routed.blockReason));
   }
-  const selection = selectDispatchRuntime(role, routed, batch.set, input.config);
+  const selection = selectDispatchRuntime(role, routed, batch.set, input.config, input.availableModels);
   const decision2 = selection.decision;
   const composed = composeSubsessionPrompt({
     prompt: input.prompt,
@@ -18761,8 +19570,9 @@ async function runRoleTaskWithCorrelation(input, deps, correlation, batch, route
   if (runtimeId !== undefined && deps.runtimeLimiter !== undefined) {
     const limiter = deps.runtimeLimiter;
     const priority = priorityForRole(role);
-    const dispatchRuntime = configuredRuntime(runtimeId, input.config) ?? { id: runtimeId };
-    const poolKey = slotPoolKey(withReportedModelSlots(dispatchRuntime, deps.reportedModelSlots?.(runtimeId)), decision2.selected.modelID);
+    const dispatchRuntime = configuredRuntime2(runtimeId, input.config) ?? { id: runtimeId };
+    const aliases = localModelAliases(decision2.selected.providerID, input.availableModels);
+    const poolKey = slotPoolKey(withReportedModelSlots(dispatchRuntime, deps.reportedModelSlots?.(runtimeId), aliases), aliases.get(decision2.selected.modelID) ?? decision2.selected.modelID);
     release = limiter.tryAcquire(poolKey, priority);
     let waitedMs = 0;
     if (release === undefined) {
@@ -19236,7 +20046,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 = z28.string().min(1).superRefine((roleID, ctx) => {
+var RoleIDSchema = z30.string().min(1).superRefine((roleID, ctx) => {
   if (!SAFE_ROLE_ID.test(roleID)) {
     ctx.addIssue({
       code: "custom",
@@ -19244,16 +20054,16 @@ var RoleIDSchema = z28.string().min(1).superRefine((roleID, ctx) => {
     });
   }
 });
-var RoleAssignmentSchema = z28.object({
+var RoleAssignmentSchema = z30.object({
   roleID: RoleIDSchema.describe("Role identifier from the roster"),
-  prompt: z28.string().min(1).describe("Work prompt for this role"),
-  title: z28.string().min(1).optional().describe("Human-readable title"),
-  dependsOn: z28.array(RoleIDSchema).optional().describe("Role IDs this assignment depends on (DAG edges)")
+  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)")
 }).strict();
-var OrchestratePayloadSchema = z28.object({
-  assignments: z28.array(RoleAssignmentSchema).min(1).describe("Role assignments to distribute"),
-  parentSessionID: z28.string().min(1).optional().describe(PARENT_SESSION_DESCRIPTION),
-  directory: z28.string().min(1).optional().describe("Working directory override")
+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")
 }).strict();
 function validateAssignmentDependencies(assignments) {
   const ids = new Set;
@@ -19989,7 +20799,7 @@ ${advisory}`;
 
 // src/plugin/registerCastTool.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
-import { z as z29 } from "zod";
+import { z as z31 } from "zod";
 
 // src/messages/rosterSummary.ts
 var ROSTER_SUMMARY_HEADING = "Registered team model policies";
@@ -20218,13 +21028,13 @@ async function persistPreparedTeam(storage, files) {
 }
 
 // src/plugin/registerCastTool.ts
-var CastEntrySchema = z29.object({
-  roleID: z29.string().min(1).describe("Stable role identifier, e.g. scribe or guardian"),
-  agentName: z29.string().min(1).describe("Themed character name assigned to the role")
+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")
 }).strict();
-var RegisterCastPayloadSchema = z29.object({
-  universe: z29.string().min(1).describe("Casting universe for this roster"),
-  entries: z29.array(CastEntrySchema).min(1).describe("Role-to-name mappings")
+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")
 }).strict();
 function offendingFields(error) {
   const fields = error.issues.flatMap((issue) => {
@@ -20343,6 +21153,307 @@ function createRegisterCastTool(deps) {
   });
 }
 
+// src/plugin/reloadTool.ts
+import { resolve as resolve9 } from "node:path";
+import { tool as tool7 } from "@opencode-ai/plugin/tool";
+var WAIT_MS = 30000;
+var SDK_TIMEOUT_MS = 5000;
+var POLL_MS2 = 1000;
+var schema = tool7.schema.object({
+  action: tool7.schema.enum(["request", "cancel"]).describe(reloadMessages.action),
+  confirmed: tool7.schema.boolean().describe(reloadMessages.confirmed)
+}).strict();
+function sdkData(value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  try {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+      return;
+    const error = Object.getOwnPropertyDescriptor(value, "error");
+    const data = Object.getOwnPropertyDescriptor(value, "data");
+    if (error !== undefined && (!("value" in error) || error.value !== undefined))
+      return;
+    return data !== undefined && "value" in data ? data.value : undefined;
+  } catch {
+    return;
+  }
+}
+function createReloadController(deps) {
+  const scheduler = deps.scheduler ?? {
+    now: () => Date.now(),
+    schedule: (run, ms) => {
+      const timer = setTimeout(run, ms);
+      timer.unref();
+      return () => clearTimeout(timer);
+    }
+  };
+  const directory = resolve9(deps.directory);
+  let pending;
+  let authorizing;
+  let closed = false;
+  function current(request) {
+    return pending === request && !request.abort.signal.aborted;
+  }
+  function finish(request, code) {
+    if (!current(request))
+      return;
+    pending = undefined;
+    request.stopDeadline();
+    request.stopPoll?.();
+    request.unlinkCaller();
+    request.abort.abort();
+    deps.notify(code);
+  }
+  function revokeAuthorization() {
+    authorizing?.abort.abort();
+    authorizing = undefined;
+  }
+  function cancel() {
+    revokeAuthorization();
+    if (pending !== undefined)
+      finish(pending, pending.disposing ? "reload-unconfirmed" : "reload-cancelled");
+  }
+  async function requestPermission(context, authorization) {
+    let finishInterruption;
+    const interrupted = new Promise((done) => {
+      finishInterruption = done;
+    });
+    const onAbort = () => finishInterruption("cancelled");
+    const stopTimer = scheduler.schedule(() => finishInterruption("timeout"), Math.max(0, authorization.deadline - scheduler.now()));
+    context.abort.addEventListener("abort", onAbort, { once: true });
+    authorization.abort.signal.addEventListener("abort", onAbort, {
+      once: true
+    });
+    try {
+      return await Promise.race([
+        context.ask({
+          permission: "openteam-reload",
+          patterns: [directory],
+          always: [directory],
+          metadata: { directory }
+        }).then(() => "approved"),
+        interrupted
+      ]);
+    } finally {
+      stopTimer();
+      context.abort.removeEventListener("abort", onAbort);
+      authorization.abort.signal.removeEventListener("abort", onAbort);
+    }
+  }
+  function bounded(request, run) {
+    return new Promise((done) => {
+      const operation = new AbortController;
+      let settled = false;
+      const settle = (outcome) => {
+        if (settled)
+          return;
+        settled = true;
+        stopTimer();
+        request.abort.signal.removeEventListener("abort", onAbort);
+        if (outcome.kind !== "settled")
+          operation.abort();
+        done(outcome);
+      };
+      const onAbort = () => settle({ kind: "cancelled" });
+      const stopTimer = scheduler.schedule(() => settle({ kind: "timeout" }), Math.max(0, Math.min(SDK_TIMEOUT_MS, request.deadline - scheduler.now())));
+      request.abort.signal.addEventListener("abort", onAbort, { once: true });
+      try {
+        run(operation.signal).then((value) => settle({ kind: "settled", value }), () => settle({ kind: "failed" }));
+      } catch {
+        settle({ kind: "failed" });
+      }
+    });
+  }
+  function poll(request) {
+    if (!current(request) || request.stopPoll !== undefined)
+      return;
+    request.stopPoll = scheduler.schedule(() => {
+      request.stopPoll = undefined;
+      probe(request);
+    }, POLL_MS2);
+  }
+  async function probe(request) {
+    if (!current(request) || !request.callerIdle || request.probing || request.disposing)
+      return;
+    if (scheduler.now() >= request.deadline) {
+      finish(request, "reload-timeout");
+      return;
+    }
+    request.stopPoll?.();
+    request.stopPoll = undefined;
+    request.probing = true;
+    const revision = request.revision;
+    try {
+      for (let check = 0;check < 2; check++) {
+        const outcome2 = await bounded(request, (signal) => deps.client.session.status({ query: { directory }, signal }));
+        if (!current(request))
+          return;
+        if (outcome2.kind !== "settled") {
+          finish(request, "reload-status-failed");
+          return;
+        }
+        const snapshot = parseSessionStatusMap(sdkData(outcome2.value));
+        if (snapshot === undefined) {
+          finish(request, "reload-status-failed");
+          return;
+        }
+        if (revision !== request.revision || !request.callerIdle) {
+          poll(request);
+          return;
+        }
+        if (Object.values(snapshot).some((status) => status.type !== "idle")) {
+          if (Object.hasOwn(snapshot, request.sessionID) && snapshot[request.sessionID]?.type !== "idle")
+            request.callerIdle = false;
+          if (!request.waitingReported) {
+            request.waitingReported = true;
+            deps.notify("reload-waiting");
+          }
+          poll(request);
+          return;
+        }
+      }
+      if (scheduler.now() >= request.deadline) {
+        finish(request, "reload-timeout");
+        return;
+      }
+      request.disposing = true;
+      closed = true;
+      const outcome = await bounded(request, (signal) => deps.client.instance.dispose({ query: { directory }, signal }));
+      if (!current(request))
+        return;
+      finish(request, outcome.kind === "timeout" ? "reload-unconfirmed" : outcome.kind === "settled" && sdkData(outcome.value) === true ? "reload-accepted" : "reload-dispose-failed");
+    } finally {
+      request.probing = false;
+      if (current(request) && request.callerIdle && !request.disposing && revision !== request.revision)
+        probe(request);
+    }
+  }
+  const definition = {
+    description: reloadMessages.description,
+    args: schema.shape,
+    async execute(args, context) {
+      const parsed = schema.safeParse(args);
+      if (!parsed.success)
+        return reloadMessages.invalid;
+      if (context.agent !== "openteam" || resolve9(context.directory) !== directory || context.sessionID.trim().length === 0)
+        return reloadMessages.denied;
+      if (parsed.data.action === "cancel") {
+        if ((pending?.sessionID ?? authorizing?.sessionID) !== context.sessionID)
+          return reloadMessages.none;
+        const message = pending?.disposing ? reloadMessages["reload-unconfirmed"] : reloadMessages["reload-cancelled"];
+        cancel();
+        return message;
+      }
+      if (!parsed.data.confirmed) {
+        const inFlight = pending?.sessionID === context.sessionID && pending.disposing;
+        if ((pending?.sessionID ?? authorizing?.sessionID) === context.sessionID)
+          cancel();
+        return inFlight ? reloadMessages["reload-unconfirmed"] : reloadMessages.declined;
+      }
+      if (context.abort.aborted)
+        return reloadMessages["reload-cancelled"];
+      if (closed)
+        return reloadMessages.closed;
+      if (authorizing !== undefined)
+        return authorizing.sessionID === context.sessionID ? reloadMessages.authorizing : reloadMessages.other;
+      if (pending !== undefined) {
+        if (pending.sessionID !== context.sessionID)
+          return reloadMessages.other;
+        pending.toolDone = false;
+        pending.callerIdle = false;
+        pending.revision++;
+        return reloadMessages["reload-queued"];
+      }
+      const authorization = {
+        sessionID: context.sessionID,
+        deadline: scheduler.now() + WAIT_MS,
+        abort: new AbortController
+      };
+      authorizing = authorization;
+      try {
+        const permission = await requestPermission(context, authorization);
+        if (closed)
+          return reloadMessages.closed;
+        if (authorizing !== authorization || context.abort.aborted || permission === "cancelled")
+          return reloadMessages["reload-cancelled"];
+        if (permission === "timeout" || scheduler.now() >= authorization.deadline) {
+          deps.notify("reload-timeout");
+          return reloadMessages["reload-timeout"];
+        }
+        const onAbort = () => {
+          if (pending === request)
+            cancel();
+        };
+        const request = {
+          sessionID: context.sessionID,
+          deadline: authorization.deadline,
+          abort: new AbortController,
+          unlinkCaller: () => context.abort.removeEventListener("abort", onAbort),
+          stopDeadline: () => {},
+          stopPoll: undefined,
+          toolDone: false,
+          callerIdle: false,
+          probing: false,
+          disposing: false,
+          waitingReported: false,
+          revision: 0
+        };
+        pending = request;
+        context.abort.addEventListener("abort", onAbort, { once: true });
+        request.stopDeadline = scheduler.schedule(() => finish(request, request.disposing ? "reload-unconfirmed" : "reload-timeout"), request.deadline - scheduler.now());
+        deps.notify("reload-queued");
+        return reloadMessages["reload-queued"];
+      } finally {
+        if (authorizing === authorization)
+          authorizing = undefined;
+      }
+    }
+  };
+  return {
+    tool: definition,
+    toolCompleted(sessionID) {
+      if (pending?.sessionID !== sessionID)
+        return;
+      pending.unlinkCaller();
+      pending.toolDone = true;
+      pending.callerIdle = false;
+      pending.revision++;
+    },
+    userTurn(_sessionID) {
+      cancel();
+    },
+    event(event) {
+      const sessionID = pending?.sessionID ?? authorizing?.sessionID;
+      if (sessionID === undefined)
+        return;
+      if (event.type === "session.error" && (event.properties.sessionID === undefined || event.properties.sessionID === sessionID) || event.type === "session.deleted" && event.properties.info.id === sessionID) {
+        cancel();
+        return;
+      }
+      if (event.type === "session.created" || event.type === "session.status" && event.properties.status.type !== "idle")
+        revokeAuthorization();
+      const request = pending;
+      if (request === undefined)
+        return;
+      if (event.type === "session.created" || event.type === "session.status") {
+        request.revision++;
+        if (event.type === "session.status" && event.properties.sessionID === request.sessionID && event.properties.status.type !== "idle")
+          request.callerIdle = false;
+      }
+      if (event.type === "session.idle" || event.type === "session.status" && event.properties.status.type === "idle") {
+        if (event.properties.sessionID === request.sessionID && request.toolDone)
+          request.callerIdle = true;
+        probe(request);
+      }
+    },
+    dispose() {
+      closed = true;
+      cancel();
+    }
+  };
+}
+
 // src/plugin/sessionTracker.ts
 function createSessionTracker() {
   const knownSessions = new Set;
@@ -20542,7 +21653,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
   if (runtime?.baseURL === undefined) {
     return;
   }
-  const modelID = semantic.embeddings.model?.modelID ?? runtime.defaultModel.modelID;
+  const modelID2 = semantic.embeddings.model?.modelID ?? runtime.defaultModel.modelID;
   const openDatabase = deps.openDatabase ?? createBunSqliteDatabase;
   const makeEmbedder = deps.createEmbedder ?? createLocalEmbedder;
   const fetchImpl = deps.fetch ?? globalThis.fetch;
@@ -20555,8 +21666,8 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
     if (rebuildResult.rejectedLines > 0) {
       warn(`[openteam] memory log rejected ${rebuildResult.rejectedLines} line(s); semantic memory may be incomplete.`);
     }
-    const embedder = makeEmbedder({ baseURL: runtime.baseURL, modelID }, { fetch: fetchImpl });
-    await ensureMemoryEmbeddings({ index, embedder, model: modelID, warn });
+    const embedder = makeEmbedder({ baseURL: runtime.baseURL, modelID: modelID2 }, { fetch: fetchImpl });
+    await ensureMemoryEmbeddings({ index, embedder, model: modelID2, warn });
     return {
       index,
       embedder,
@@ -20580,22 +21691,22 @@ import {
   statSync,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join15, resolve as resolve10 } from "node:path";
+import { join as join15, resolve as resolve11 } from "node:path";
 import { ZodError } from "zod";
 
 // src/storage/lifecycle/codec.ts
-import { z as z30 } from "zod";
+import { z as z32 } from "zod";
 var LIFECYCLE_CODEC_VERSION = 1;
 var LIFECYCLE_GENESIS_DIGEST = sha256Hex("openteam/lifecycle-journal/genesis/v1");
 var NUL5 = "\x00";
 var NEWLINE2 = `
 `;
-var frameSchema = z30.object({
-  v: z30.literal(LIFECYCLE_CODEC_VERSION),
-  seq: z30.number().int().nonnegative(),
-  prev: z30.string().min(1),
-  sum: z30.string().min(1),
-  event: z30.unknown()
+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()
 }).strict();
 function canonical2(value) {
   if (Array.isArray(value)) {
@@ -20699,7 +21810,7 @@ import {
   unlinkSync,
   writeSync as writeSync2
 } from "node:fs";
-import { basename as basename3, dirname as dirname7, join as join14, relative as relative3, resolve as resolve9 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join14, relative as relative3, resolve as resolve10 } 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 {
@@ -20723,7 +21834,7 @@ function validateRunID(runID) {
 }
 function resolvedLifecycleRoot(root) {
   try {
-    const absolute = resolve9(root);
+    const absolute = resolve10(root);
     mkdirSync2(absolute, { recursive: true });
     const rootStat = lstatSync2(absolute);
     if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
@@ -20766,7 +21877,7 @@ function assertExistingSafeRun(root, runID) {
     throw new LifecycleFsError("unavailable");
   }
   const child = relative3(root, real);
-  if (child === "" || child.startsWith("..") || resolve9(root, child) !== real || dirname7(real) !== root) {
+  if (child === "" || child.startsWith("..") || resolve10(root, child) !== real || dirname7(real) !== root) {
     throw new LifecycleFsError("corrupt");
   }
   return real;
@@ -20935,8 +22046,8 @@ function readRun(runDir, runID) {
   if (metadataText === undefined || eventsText === undefined) {
     throw new LifecycleFsError("corrupt");
   }
-  const metadata = parseJson(metadataText, parseLifecycleRunMetadata);
-  if (metadata.runID !== runID) {
+  const metadata2 = parseJson(metadataText, parseLifecycleRunMetadata);
+  if (metadata2.runID !== runID) {
     throw new LifecycleFsError("corrupt");
   }
   let decoded;
@@ -20951,10 +22062,10 @@ function readRun(runDir, runID) {
     }
   }
   const first = decoded.events[0];
-  if (first === undefined || first.type !== "run.started" || first.source !== metadata.source || first.executionAuthority !== metadata.executionAuthority || first.root.operationID !== metadata.root.operationID || first.root.taskID !== metadata.root.taskID) {
+  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) {
     throw new LifecycleFsError("corrupt");
   }
-  return { metadata, decoded };
+  return { metadata: metadata2, decoded };
 }
 function terminalOutcome(events) {
   const last = events.at(-1);
@@ -21006,7 +22117,7 @@ function canDeleteTerminalRun(runDir, runID, now) {
   return now >= lease.expiresAt;
 }
 var createFsLifecycleJournal = (options) => {
-  const configuredRoot = resolve10(options.root);
+  const configuredRoot = resolve11(options.root);
   const now = options.now ?? Date.now;
   const mutateRun = options.withMutationLock ?? withRunMutationLock;
   return {
@@ -21032,7 +22143,7 @@ var createFsLifecycleJournal = (options) => {
         mkdirSync3(stagingPath);
         const writerToken = issueWriterToken();
         const eventAt = now();
-        const metadata = parseLifecycleRunMetadata({
+        const metadata2 = parseLifecycleRunMetadata({
           ...parsedInput,
           version: 1,
           createdAt: eventAt
@@ -21048,7 +22159,7 @@ var createFsLifecycleJournal = (options) => {
           executionAuthority: parsedInput.executionAuthority,
           root: parsedInput.root
         });
-        writeDurable2(join15(stagingPath, METADATA_FILE), `${JSON.stringify(metadata)}
+        writeDurable2(join15(stagingPath, METADATA_FILE), `${JSON.stringify(metadata2)}
 `);
         writeDurable2(join15(stagingPath, EVENTS_FILE), encodeLifecycleJournal([event]));
         writeDurable2(join15(stagingPath, OWNER_FILE2), `${JSON.stringify(lease)}
@@ -21064,7 +22175,7 @@ var createFsLifecycleJournal = (options) => {
         stagingPath = undefined;
         return ok({
           handle: { runID, writerToken },
-          metadata,
+          metadata: metadata2,
           event,
           lease,
           head: 1
@@ -21638,8 +22749,8 @@ async function readOpencodeVersion(serverUrl, options = {}) {
 }
 var DEFAULT_OPENCODE_VERSION_BACKOFF_MS = [50, 250];
 function defaultSleep(ms) {
-  return new Promise((resolve11) => {
-    setTimeout(resolve11, ms);
+  return new Promise((resolve12) => {
+    setTimeout(resolve12, ms);
   });
 }
 function createLazyOpencodeVersionReader(serverUrl, options = {}) {
@@ -21925,6 +23036,9 @@ async function listConfiguredOpencodeInventory(ctx) {
         providerID: model.providerID,
         modelID: model.id
       };
+      if (typeof model.api?.id === "string" && model.api.id.length > 0 && model.api.id === model.api.id.trim() && model.api.id !== model.id) {
+        configuredModel.apiModelID = model.api.id;
+      }
       if (typeof model.capabilities?.toolcall === "boolean") {
         configuredModel.supportsTools = model.capabilities.toolcall;
       }
@@ -21994,12 +23108,20 @@ 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, {
+    fetch: globalThis.fetch,
+    ...ctx.client.config?.providers === undefined ? {} : {
+      resolveApiModelID: cache.resolveApiModelID,
+      modelInventoryReady: ensureAvailability
+    }
+  });
   const resolveAgentRole = async (agentName) => {
     const entry = (await readRoutingRosterEntries(storage)).find((candidate) => candidate.agentName === agentName);
     return entry?.roleID;
   };
   const hooks = createHooks(config, cache.get, injectMemory === undefined ? {
     sink,
+    modelResidency,
     beforeRoute: ensureAvailability,
     capabilityProfiles,
     orchestratedModelOwnership,
@@ -22007,6 +23129,7 @@ var server = async (ctx, rawOptions) => {
     onRoute: (sid, model) => sessionTracker.trackRoutedModel(sid, model)
   } : {
     sink,
+    modelResidency,
     beforeRoute: ensureAvailability,
     capabilityProfiles,
     injectMemory,
@@ -22127,7 +23250,7 @@ var server = async (ctx, rawOptions) => {
     if (runtime === undefined) {
       return;
     }
-    return withReportedModelSlots(runtime, reportedSlotsByRuntime.get(runtimeId));
+    return withReportedModelSlots(runtime, reportedSlotsByRuntime.get(runtimeId), localModelAliases(runtime.defaultModel.providerID, cache.get()));
   };
   const runtimeLimiter = createRuntimeConcurrencyLimiter({
     capacityFor: (key2) => {
@@ -22163,8 +23286,8 @@ var server = async (ctx, rawOptions) => {
     lifecycleRecorder,
     abortGraceMs: DEFAULT_ABORT_GRACE_MS,
     statusPollMs: DEFAULT_STATUS_POLL_MS,
-    delay: (ms) => new Promise((resolve11) => {
-      setTimeout(resolve11, ms);
+    delay: (ms) => new Promise((resolve12) => {
+      setTimeout(resolve12, ms);
     }),
     warn: diagnostics.warn("unknown-role")
   });
@@ -22172,7 +23295,27 @@ var server = async (ctx, rawOptions) => {
     config,
     storage,
     now,
-    localRuntimeReachable,
+    localRuntimeReachable: async (runtime, signal) => {
+      if (localRuntimeKind(runtime) === "lemonade") {
+        if (ctx.client.config?.providers !== undefined)
+          await ensureAvailability();
+        signal?.throwIfAborted();
+        const target = modelResidency.localTarget(resolveMemorySemantic(config).extraction.model ?? runtime.defaultModel);
+        const response = await target.fetch(`${target.baseURL}/health`, {
+          method: "GET",
+          ...signal === undefined ? {} : { signal }
+        });
+        return response.ok;
+      }
+      const snapshots = await registry.probe([runtime]);
+      rememberReportedSlots(snapshots);
+      return anyRuntimeReachable(snapshots);
+    },
+    resolveExtractionTarget: async (model) => {
+      if (ctx.client.config?.providers !== undefined)
+        await ensureAvailability();
+      return modelResidency.localTarget(model);
+    },
     fetch: globalThis.fetch,
     warn: diagnostics.warn("memory-extraction-warning", { toast: false })
   });
@@ -22184,23 +23327,43 @@ var server = async (ctx, rawOptions) => {
       options: rawOptions
     })
   });
+  const reload = createReloadController({
+    directory: ctx.directory,
+    client: ctx.client,
+    notify: (code) => diagnostics.emit({
+      code,
+      level: code === "reload-timeout" || code === "reload-status-failed" || code === "reload-dispose-failed" || code === "reload-unconfirmed" ? "warn" : "info"
+    }, { toast: code !== "reload-queued" })
+  });
   return {
     ...hooks,
+    "chat.message": async (input, output) => {
+      reload.userTurn(input.sessionID);
+      await hooks["chat.message"]?.(input, output);
+    },
+    dispose: async () => {
+      reload.dispose();
+      await hooks.dispose?.();
+    },
     tool: {
       openteam: createCommandTool(cliDeps),
       "openteam-console": createConsoleTool(),
       "openteam-graph": graphSurface.definition,
       "openteam-orchestrate": orchestrateTool,
       "openteam-memory": memoryTool,
-      "openteam-register-cast": registerCastTool
+      "openteam-register-cast": registerCastTool,
+      "openteam-reload": reload.tool
     },
     "tool.execute.before": async (input) => {
       toolcalls.before(input);
     },
     "tool.execute.after": async (input) => {
       await toolcalls.after(input);
+      if (input.tool === "openteam-reload")
+        reload.toolCompleted(input.sessionID);
     },
     event: async ({ event }) => {
+      reload.event(event);
       if (event.type === "session.created" || event.type === "session.idle") {
         cache.refresh();
       }